blob: 7817f8261505926e3e227725f1e3a552f69eed60 [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"
David Blaikie24bbfed22014-03-31 23:29:38 +000032#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000033#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000034#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000035#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000036#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000037#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000038#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000039#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/Support/raw_ostream.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000041#include <sys/stat.h>
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000042
Daniel Dunbar1a093d22009-03-18 06:00:36 +000043using namespace clang::driver;
44using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000045using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000046using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000047
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000048static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
49 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
50 options::OPT_fpic, options::OPT_fno_pic,
51 options::OPT_fPIE, options::OPT_fno_PIE,
52 options::OPT_fpie, options::OPT_fno_pie);
53 if (!LastPICArg)
54 return;
55 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
56 LastPICArg->getOption().matches(options::OPT_fpic) ||
57 LastPICArg->getOption().matches(options::OPT_fPIE) ||
58 LastPICArg->getOption().matches(options::OPT_fpie)) {
59 CmdArgs.push_back("-KPIC");
60 }
61}
62
Daniel Dunbar64198ef2009-09-10 01:21:05 +000063/// CheckPreprocessingOptions - Perform some validation of preprocessing
64/// arguments that is shared with gcc.
65static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
66 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Hans Wennborg70850d82013-07-18 20:29:38 +000067 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
Chris Lattner0e62c1c2011-07-23 10:55:15 +000068 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar64198ef2009-09-10 01:21:05 +000069 << A->getAsString(Args) << "-E";
70}
71
Daniel Dunbar4eadb602009-09-10 01:21:12 +000072/// CheckCodeGenerationOptions - Perform some validation of code generation
73/// arguments that is shared with gcc.
74static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
75 // In gcc, only ARM checks this, but it seems reasonable to check universally.
76 if (Args.hasArg(options::OPT_static))
77 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
78 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000079 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000080 << A->getAsString(Args) << "-static";
81}
82
Chris Lattnerbf2803f2010-03-29 17:55:58 +000083// Quote target names for inclusion in GNU Make dependency files.
84// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000085static void QuoteTarget(StringRef Target,
86 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000087 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
88 switch (Target[i]) {
89 case ' ':
90 case '\t':
91 // Escape the preceding backslashes
92 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
93 Res.push_back('\\');
94
95 // Escape the space/tab
96 Res.push_back('\\');
97 break;
98 case '$':
99 Res.push_back('$');
100 break;
101 case '#':
102 Res.push_back('\\');
103 break;
104 default:
105 break;
106 }
107
108 Res.push_back(Target[i]);
109 }
110}
111
Bill Wendlingc0938f32012-03-12 22:10:06 +0000112static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000113 ArgStringList &CmdArgs,
114 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000115 const char *EnvVar) {
116 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000117 bool CombinedArg = false;
118
Bill Wendling281ca292012-03-12 21:22:35 +0000119 if (!DirList)
120 return; // Nothing to do.
121
Chad Rosier616e8a52012-10-30 21:42:09 +0000122 StringRef Name(ArgName);
123 if (Name.equals("-I") || Name.equals("-L"))
124 CombinedArg = true;
125
Bill Wendling281ca292012-03-12 21:22:35 +0000126 StringRef Dirs(DirList);
127 if (Dirs.empty()) // Empty string should not add '.'.
128 return;
129
130 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000131 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000132 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000133 if (CombinedArg) {
134 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
135 } else {
136 CmdArgs.push_back(ArgName);
137 CmdArgs.push_back(".");
138 }
Bill Wendling281ca292012-03-12 21:22:35 +0000139 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000140 if (CombinedArg) {
141 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
142 } else {
143 CmdArgs.push_back(ArgName);
144 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
145 }
Bill Wendling281ca292012-03-12 21:22:35 +0000146 }
Nico Weber89355782012-03-19 15:00:03 +0000147 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000148 }
149
150 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000151 if (CombinedArg) {
152 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
153 } else {
154 CmdArgs.push_back(ArgName);
155 CmdArgs.push_back(".");
156 }
Bill Wendling281ca292012-03-12 21:22:35 +0000157 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000158 if (CombinedArg) {
159 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
160 } else {
161 CmdArgs.push_back(ArgName);
162 CmdArgs.push_back(Args.MakeArgString(Dirs));
163 }
Bill Wendling281ca292012-03-12 21:22:35 +0000164 }
165}
166
Daniel Dunbar54423b22010-09-17 00:24:54 +0000167static void AddLinkerInputs(const ToolChain &TC,
168 const InputInfoList &Inputs, const ArgList &Args,
169 ArgStringList &CmdArgs) {
170 const Driver &D = TC.getDriver();
171
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000172 // Add extra linker input arguments which are not treated as inputs
173 // (constructed via -Xarch_).
174 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
175
Daniel Dunbar54423b22010-09-17 00:24:54 +0000176 for (InputInfoList::const_iterator
177 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
178 const InputInfo &II = *it;
179
180 if (!TC.HasNativeLLVMSupport()) {
181 // Don't try to pass LLVM inputs unless we have native support.
182 if (II.getType() == types::TY_LLVM_IR ||
183 II.getType() == types::TY_LTO_IR ||
184 II.getType() == types::TY_LLVM_BC ||
185 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000186 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000187 << TC.getTripleString();
188 }
189
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000190 // Add filenames immediately.
191 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000192 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000193 continue;
194 }
195
196 // Otherwise, this is a linker input argument.
197 const Arg &A = II.getInputArg();
198
199 // Handle reserved library options.
200 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000201 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Senafeb03b2010-09-17 18:39:08 +0000202 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
203 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000204 } else
205 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000206 }
Bill Wendling281ca292012-03-12 21:22:35 +0000207
208 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000209 // and only supported on native toolchains.
210 if (!TC.isCrossCompiling())
211 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000212}
213
John McCall31168b02011-06-15 23:02:42 +0000214/// \brief Determine whether Objective-C automated reference counting is
215/// enabled.
216static bool isObjCAutoRefCount(const ArgList &Args) {
217 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
218}
219
Ted Kremeneke65b0862012-03-06 20:05:56 +0000220/// \brief Determine whether we are linking the ObjC runtime.
221static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000222 if (isObjCAutoRefCount(Args)) {
223 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000224 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000225 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000226 return Args.hasArg(options::OPT_fobjc_link_runtime);
227}
228
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000229static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000230 // Don't forward inputs from the original command line. They are added from
231 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000232 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000233 !O.hasFlag(options::DriverOption) &&
234 !O.hasFlag(options::LinkerInput);
235}
236
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000237void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000238 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000239 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000240 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000241 ArgStringList &CmdArgs,
242 const InputInfo &Output,
243 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000244 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000245
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000246 CheckPreprocessingOptions(D, Args);
247
248 Args.AddLastArg(CmdArgs, options::OPT_C);
249 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000250
251 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000252 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000253 (A = Args.getLastArg(options::OPT_MD)) ||
254 (A = Args.getLastArg(options::OPT_MMD))) {
255 // Determine the output location.
256 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000257 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000258 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000259 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000260 } else if (Output.getType() == types::TY_Dependencies) {
261 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000262 } else if (A->getOption().matches(options::OPT_M) ||
263 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000264 DepFile = "-";
265 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000266 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000267 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000268 }
269 CmdArgs.push_back("-dependency-file");
270 CmdArgs.push_back(DepFile);
271
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000272 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000273 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
274 const char *DepTarget;
275
276 // If user provided -o, that is the dependency target, except
277 // when we are only generating a dependency file.
278 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
279 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000280 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000281 } else {
282 // Otherwise derive from the base input.
283 //
284 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000285 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000286 llvm::sys::path::replace_extension(P, "o");
287 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000288 }
289
290 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000291 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000292 QuoteTarget(DepTarget, Quoted);
293 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000294 }
295
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000296 if (A->getOption().matches(options::OPT_M) ||
297 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000298 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000299
300 if (isa<PrecompileJobAction>(JA))
301 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 }
303
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000304 if (Args.hasArg(options::OPT_MG)) {
305 if (!A || A->getOption().matches(options::OPT_MD) ||
306 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000307 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000308 CmdArgs.push_back("-MG");
309 }
310
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000311 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000312
313 // Convert all -MQ <target> args to -MT <quoted target>
314 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
315 options::OPT_MQ),
316 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000317 const Arg *A = *it;
318 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000319
Daniel Dunbara442fd52010-06-11 22:00:13 +0000320 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000321 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000322 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000323 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000324 CmdArgs.push_back(Args.MakeArgString(Quoted));
325
326 // -MT flag - no change
327 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000328 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000329 }
330 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000331
Douglas Gregor111af7d2009-04-18 00:34:01 +0000332 // Add -i* options, and automatically translate to
333 // -include-pch/-include-pth for transparent PCH support. It's
334 // wonky, but we include looking for .gch so we can support seamless
335 // replacement into a build system already set up to be generating
336 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000337 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000338 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
339 ie = Args.filtered_end(); it != ie; ++it) {
340 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000341
342 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000343 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
344 RenderedImplicitInclude = true;
345
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000346 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000347 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000348
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000349 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000350 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000351 SmallString<128> P(A->getValue());
352 // We want the files to have a name like foo.h.pch. Add a dummy extension
353 // so that replace_extension does the right thing.
354 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000355 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000356 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000357 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000358 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000359 }
360
Douglas Gregor111af7d2009-04-18 00:34:01 +0000361 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000362 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000363 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000364 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000365 }
366
Douglas Gregor111af7d2009-04-18 00:34:01 +0000367 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000368 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000369 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000370 FoundPCH = UsePCH;
371 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000373 }
374
375 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000376 if (IsFirstImplicitInclude) {
377 A->claim();
378 if (UsePCH)
379 CmdArgs.push_back("-include-pch");
380 else
381 CmdArgs.push_back("-include-pth");
382 CmdArgs.push_back(Args.MakeArgString(P.str()));
383 continue;
384 } else {
385 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000386 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000387 << P.str() << A->getAsString(Args);
388 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000389 }
390 }
391
392 // Not translated, render as usual.
393 A->claim();
394 A->render(Args, CmdArgs);
395 }
396
397 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000398 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
399 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000400
401 // Add -Wp, and -Xassembler if using the preprocessor.
402
403 // FIXME: There is a very unfortunate problem here, some troubled
404 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
405 // really support that we would have to parse and then translate
406 // those options. :(
407 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
408 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000409
410 // -I- is a deprecated GCC feature, reject it.
411 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000412 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000413
414 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
415 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000416 StringRef sysroot = C.getSysRoot();
417 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000418 if (!Args.hasArg(options::OPT_isysroot)) {
419 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000420 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000421 }
422 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000423
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000424 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000425 // FIXME: We should probably sink the logic for handling these from the
426 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000427 // CPATH - included following the user specified includes (but prior to
428 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000429 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000430 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000431 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000432 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000433 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000434 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000435 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000436 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000437 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000438
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000439 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000440 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000441 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000442
443 // Add system include arguments.
444 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000445}
446
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000447// FIXME: Move to target hook.
448static bool isSignedCharDefault(const llvm::Triple &Triple) {
449 switch (Triple.getArch()) {
450 default:
451 return true;
452
Tim Northover9bb857a2013-01-31 12:13:10 +0000453 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000454 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +0000455 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +0000456 case llvm::Triple::arm64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000457 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000458 case llvm::Triple::armeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000459 if (Triple.isOSDarwin() || Triple.isOSWindows())
460 return true;
461 return false;
462
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000463 case llvm::Triple::ppc:
464 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000465 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000466 return true;
467 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000468
Bill Schmidt778d3872013-07-26 01:36:11 +0000469 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000470 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000471 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000472 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000473 }
474}
475
Robert Lytton0e076492013-08-13 09:43:10 +0000476static bool isNoCommonDefault(const llvm::Triple &Triple) {
477 switch (Triple.getArch()) {
478 default:
479 return false;
480
481 case llvm::Triple::xcore:
482 return true;
483 }
484}
485
Chad Rosiercfbfc582012-04-04 20:51:35 +0000486// Handle -mfpu=.
487//
488// FIXME: Centralize feature selection, defaulting shouldn't be also in the
489// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000490static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
491 const ArgList &Args,
492 std::vector<const char *> &Features) {
493 StringRef FPU = A->getValue();
494 if (FPU == "fp-armv8") {
495 Features.push_back("+fp-armv8");
496 } else if (FPU == "neon-fp-armv8") {
497 Features.push_back("+fp-armv8");
498 Features.push_back("+neon");
499 } else if (FPU == "crypto-neon-fp-armv8") {
500 Features.push_back("+fp-armv8");
501 Features.push_back("+neon");
502 Features.push_back("+crypto");
503 } else if (FPU == "neon") {
504 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000505 } else
506 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
507}
508
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000509// Handle -mhwdiv=.
510static void getARMHWDivFeatures(const Driver &D, const Arg *A,
511 const ArgList &Args,
512 std::vector<const char *> &Features) {
513 StringRef HWDiv = A->getValue();
514 if (HWDiv == "arm") {
515 Features.push_back("+hwdiv-arm");
516 Features.push_back("-hwdiv");
517 } else if (HWDiv == "thumb") {
518 Features.push_back("-hwdiv-arm");
519 Features.push_back("+hwdiv");
520 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
521 Features.push_back("+hwdiv-arm");
522 Features.push_back("+hwdiv");
523 } else if (HWDiv == "none") {
524 Features.push_back("-hwdiv-arm");
525 Features.push_back("-hwdiv");
526 } else
527 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
528}
529
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000530// Handle -mfpu=.
531//
532// FIXME: Centralize feature selection, defaulting shouldn't be also in the
533// frontend target.
534static void getARMFPUFeatures(const Driver &D, const Arg *A,
535 const ArgList &Args,
536 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000537 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000538
539 // Set the target features based on the FPU.
540 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
541 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000542 Features.push_back("-vfp2");
543 Features.push_back("-vfp3");
544 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000545 } else if (FPU == "vfp") {
546 Features.push_back("+vfp2");
547 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000548 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000549 Features.push_back("+vfp3");
550 Features.push_back("+d16");
551 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000552 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000553 Features.push_back("+vfp3");
554 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000555 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
556 Features.push_back("+vfp4");
557 Features.push_back("+d16");
558 Features.push_back("-neon");
559 } else if (FPU == "vfp4" || FPU == "vfpv4") {
560 Features.push_back("+vfp4");
561 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000562 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
563 Features.push_back("+vfp4");
564 Features.push_back("+d16");
565 Features.push_back("+fp-only-sp");
566 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000567 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000568 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000569 Features.push_back("-neon");
570 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000571 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000572 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000573 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000574 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000575 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000576 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000577 Features.push_back("+neon");
578 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000579 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000580 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000581 } else if (FPU == "none") {
582 Features.push_back("-vfp2");
583 Features.push_back("-vfp3");
584 Features.push_back("-vfp4");
585 Features.push_back("-fp-armv8");
586 Features.push_back("-crypto");
587 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000588 } else
589 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
590}
591
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000592// Select the float ABI as determined by -msoft-float, -mhard-float, and
593// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000594StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
595 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000596 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000597 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
598 options::OPT_mhard_float,
599 options::OPT_mfloat_abi_EQ)) {
600 if (A->getOption().matches(options::OPT_msoft_float))
601 FloatABI = "soft";
602 else if (A->getOption().matches(options::OPT_mhard_float))
603 FloatABI = "hard";
604 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000605 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000606 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000607 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000608 << A->getAsString(Args);
609 FloatABI = "soft";
610 }
611 }
612 }
613
614 // If unspecified, choose the default based on the platform.
615 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000616 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000617 case llvm::Triple::Darwin:
618 case llvm::Triple::MacOSX:
619 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000620 // Darwin defaults to "softfp" for v6 and v7.
621 //
622 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000623 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000624 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000625 if (StringRef(ArchName).startswith("v6") ||
626 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000627 FloatABI = "softfp";
628 else
629 FloatABI = "soft";
630 break;
631 }
632
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000633 // FIXME: this is invalid for WindowsCE
634 case llvm::Triple::Win32:
635 FloatABI = "hard";
636 break;
637
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000638 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000639 switch(Triple.getEnvironment()) {
640 case llvm::Triple::GNUEABIHF:
641 FloatABI = "hard";
642 break;
643 default:
644 // FreeBSD defaults to soft float
645 FloatABI = "soft";
646 break;
647 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000648 break;
649
Daniel Dunbar78485922009-09-10 23:00:09 +0000650 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000651 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000652 case llvm::Triple::GNUEABIHF:
653 FloatABI = "hard";
654 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000655 case llvm::Triple::GNUEABI:
656 FloatABI = "softfp";
657 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000658 case llvm::Triple::EABIHF:
659 FloatABI = "hard";
660 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000661 case llvm::Triple::EABI:
662 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
663 FloatABI = "softfp";
664 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000665 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000666 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000667 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000668 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000669 FloatABI = "softfp";
670 else
671 FloatABI = "soft";
672 break;
673 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000674 default:
675 // Assume "soft", but warn the user we are guessing.
676 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000677 if (Triple.getOS() != llvm::Triple::UnknownOS ||
678 !Triple.isOSBinFormatMachO())
679 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000680 break;
681 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000682 }
683 }
684
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000685 return FloatABI;
686}
687
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000688static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
689 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000690 std::vector<const char *> &Features,
691 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000692 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000693 if (!ForAS) {
694 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
695 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
696 // stripped out by the ARM target. We should probably pass this a new
697 // -target-option, which is handled by the -cc1/-cc1as invocation.
698 //
699 // FIXME2: For consistency, it would be ideal if we set up the target
700 // machine state the same when using the frontend or the assembler. We don't
701 // currently do that for the assembler, we pass the options directly to the
702 // backend and never even instantiate the frontend TargetInfo. If we did,
703 // and used its handleTargetFeatures hook, then we could ensure the
704 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000705
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000706 // Use software floating point operations?
707 if (FloatABI == "soft")
708 Features.push_back("+soft-float");
709
710 // Use software floating point argument passing?
711 if (FloatABI != "hard")
712 Features.push_back("+soft-float-abi");
713 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000714
715 // Honor -mfpu=.
716 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000717 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000718 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
719 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000720
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000721 // Setting -msoft-float effectively disables NEON because of the GCC
722 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000723 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000724 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000725 // Also need to explicitly disable features which imply NEON.
726 Features.push_back("-crypto");
727 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000728
729 // En/disable crc
730 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
731 options::OPT_mnocrc)) {
732 if (A->getOption().matches(options::OPT_mcrc))
733 Features.push_back("+crc");
734 else
735 Features.push_back("-crc");
736 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000737}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000738
739void Clang::AddARMTargetArgs(const ArgList &Args,
740 ArgStringList &CmdArgs,
741 bool KernelOrKext) const {
742 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000743 // Get the effective triple, which takes into account the deployment target.
744 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
745 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000746 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000747
748 // Select the ABI to use.
749 //
750 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000751 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000752 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000753 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000754 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000755 // The backend is hardwired to assume AAPCS for M-class processors, ensure
756 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000757 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000758 (Triple.getOS() == llvm::Triple::UnknownOS &&
759 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000760 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000761 ABIName = "aapcs";
762 } else {
763 ABIName = "apcs-gnu";
764 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000765 } else if (Triple.isOSWindows()) {
766 // FIXME: this is invalid for WindowsCE
767 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000768 } else {
769 // Select the default based on the platform.
770 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000771 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000772 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000773 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000774 ABIName = "aapcs-linux";
775 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000776 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000777 case llvm::Triple::EABI:
778 ABIName = "aapcs";
779 break;
780 default:
781 ABIName = "apcs-gnu";
782 }
783 }
784 CmdArgs.push_back("-target-abi");
785 CmdArgs.push_back(ABIName);
786
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000787 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000788 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000789 if (FloatABI == "soft") {
790 // Floating point operations and argument passing are soft.
791 //
792 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000793 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000794 CmdArgs.push_back("-mfloat-abi");
795 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000796 } else if (FloatABI == "softfp") {
797 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000798 CmdArgs.push_back("-mfloat-abi");
799 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000800 } else {
801 // Floating point operations and argument passing are hard.
802 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000803 CmdArgs.push_back("-mfloat-abi");
804 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000805 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000806
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000807 // Kernel code has more strict alignment requirements.
808 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000809 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000810 CmdArgs.push_back("-backend-option");
811 CmdArgs.push_back("-arm-long-calls");
812 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000813
Daniel Dunbar12100e22011-03-22 16:48:17 +0000814 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000815 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000816
817 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000818 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000819 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000820 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000821
822 // Setting -mno-global-merge disables the codegen global merge pass. Setting
823 // -mglobal-merge has no effect as the pass is enabled by default.
824 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
825 options::OPT_mno_global_merge)) {
826 if (A->getOption().matches(options::OPT_mno_global_merge))
827 CmdArgs.push_back("-mno-global-merge");
828 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000829
Bob Wilson9c8af452013-04-11 18:53:25 +0000830 if (!Args.hasFlag(options::OPT_mimplicit_float,
831 options::OPT_mno_implicit_float,
832 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000833 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000834
Logan Chien749763e2014-04-03 13:12:44 +0000835 // llvm does not support reserving registers in general. There is support
836 // for reserving r9 on ARM though (defined as a platform-specific register
837 // in ARM EABI).
838 if (Args.hasArg(options::OPT_ffixed_r9)) {
839 CmdArgs.push_back("-backend-option");
840 CmdArgs.push_back("-arm-reserve-r9");
841 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000842}
843
Tim Northover573cbee2014-05-24 12:52:07 +0000844/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
845/// targeting.
846static std::string getAArch64TargetCPU(const ArgList &Args) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000847 // If we have -mcpu=, use that.
848 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
849 StringRef MCPU = A->getValue();
850 // Handle -mcpu=native.
851 if (MCPU == "native")
852 return llvm::sys::getHostCPUName();
853 else
854 return MCPU;
855 }
856
857 // At some point, we may need to check -march here, but for now we only
858 // one arm64 architecture.
859
James Molloy9b1586b2014-04-17 12:51:17 +0000860 // Make sure we pick "cyclone" if -arch is used.
861 // FIXME: Should this be picked by checking the target triple instead?
862 if (Args.getLastArg(options::OPT_arch))
863 return "cyclone";
864
865 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000866}
867
Tim Northover573cbee2014-05-24 12:52:07 +0000868void Clang::AddAArch64TargetArgs(const ArgList &Args,
869 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000870 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
871 llvm::Triple Triple(TripleStr);
872
873 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
874 Args.hasArg(options::OPT_mkernel) ||
875 Args.hasArg(options::OPT_fapple_kext))
876 CmdArgs.push_back("-disable-red-zone");
877
878 if (!Args.hasFlag(options::OPT_mimplicit_float,
879 options::OPT_mno_implicit_float, true))
880 CmdArgs.push_back("-no-implicit-float");
881
Craig Topper92fc2df2014-05-17 16:56:41 +0000882 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000883 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
884 ABIName = A->getValue();
885 else if (Triple.isOSDarwin())
886 ABIName = "darwinpcs";
887 else
888 ABIName = "aapcs";
889
890 CmdArgs.push_back("-target-abi");
891 CmdArgs.push_back(ABIName);
892
893 CmdArgs.push_back("-target-cpu");
Tim Northover573cbee2014-05-24 12:52:07 +0000894 CmdArgs.push_back(Args.MakeArgString(getAArch64TargetCPU(Args)));
Tim Northovera2ee4332014-03-29 15:09:45 +0000895
896 if (Args.hasArg(options::OPT_mstrict_align)) {
897 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +0000898 CmdArgs.push_back("-aarch64-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000899 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000900
901 // Setting -mno-global-merge disables the codegen global merge pass. Setting
902 // -mglobal-merge has no effect as the pass is enabled by default.
903 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
904 options::OPT_mno_global_merge)) {
905 if (A->getOption().matches(options::OPT_mno_global_merge))
906 CmdArgs.push_back("-mno-global-merge");
907 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000908}
909
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000910// Get CPU and ABI names. They are not independent
911// so we have to calculate them together.
912static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000913 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000914 StringRef &CPUName,
915 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000916 const char *DefMips32CPU = "mips32r2";
917 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000918
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000919 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000920 options::OPT_mcpu_EQ))
921 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000922
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000923 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000924 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000925 // Convert a GNU style Mips ABI name to the name
926 // accepted by LLVM Mips backend.
927 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
928 .Case("32", "o32")
929 .Case("64", "n64")
930 .Default(ABIName);
931 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000932
933 // Setup default CPU and ABI names.
934 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000935 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000936 default:
937 llvm_unreachable("Unexpected triple arch name");
938 case llvm::Triple::mips:
939 case llvm::Triple::mipsel:
940 CPUName = DefMips32CPU;
941 break;
942 case llvm::Triple::mips64:
943 case llvm::Triple::mips64el:
944 CPUName = DefMips64CPU;
945 break;
946 }
947 }
948
949 if (!ABIName.empty()) {
950 // Deduce CPU name from ABI name.
951 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000952 .Cases("32", "o32", "eabi", DefMips32CPU)
953 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000954 .Default("");
955 }
956 else if (!CPUName.empty()) {
957 // Deduce ABI name from CPU name.
958 ABIName = llvm::StringSwitch<const char *>(CPUName)
959 .Cases("mips32", "mips32r2", "o32")
960 .Cases("mips64", "mips64r2", "n64")
961 .Default("");
962 }
963
964 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000965}
966
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000967// Convert ABI name to the GNU tools acceptable variant.
968static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
969 return llvm::StringSwitch<llvm::StringRef>(ABI)
970 .Case("o32", "32")
971 .Case("n64", "64")
972 .Default(ABI);
973}
974
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000975// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
976// and -mfloat-abi=.
977static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000978 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000979 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000980 options::OPT_mhard_float,
981 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000982 if (A->getOption().matches(options::OPT_msoft_float))
983 FloatABI = "soft";
984 else if (A->getOption().matches(options::OPT_mhard_float))
985 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000986 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000987 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000988 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000989 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000990 FloatABI = "hard";
991 }
992 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000993 }
994
995 // If unspecified, choose the default based on the platform.
996 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000997 // Assume "hard", because it's a default value used by gcc.
998 // When we start to recognize specific target MIPS processors,
999 // we will be able to select the default more correctly.
1000 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001001 }
1002
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001003 return FloatABI;
1004}
1005
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001006static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001007 std::vector<const char *> &Features,
1008 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001009 StringRef FeatureName) {
1010 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001011 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001012 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001013 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001014 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001015 }
1016}
1017
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001018static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1019 std::vector<const char *> &Features) {
1020 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001021 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001022 // FIXME: Note, this is a hack. We need to pass the selected float
1023 // mode to the MipsTargetInfoBase to define appropriate macros there.
1024 // Now it is the only method.
1025 Features.push_back("+soft-float");
1026 }
1027
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001028 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001029 StringRef Val = StringRef(A->getValue());
1030 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001031 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001032 else if (Val == "legacy")
1033 Features.push_back("-nan2008");
1034 else
1035 D.Diag(diag::err_drv_unsupported_option_argument)
1036 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001037 }
1038
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001039 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1040 options::OPT_mdouble_float, "single-float");
1041 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1042 "mips16");
1043 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1044 options::OPT_mno_micromips, "micromips");
1045 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1046 "dsp");
1047 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1048 "dspr2");
1049 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1050 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +00001051 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1052 "fp64");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001053}
1054
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001055void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001056 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001057 const Driver &D = getToolChain().getDriver();
1058 StringRef CPUName;
1059 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001060 const llvm::Triple &Triple = getToolChain().getTriple();
1061 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001062
1063 CmdArgs.push_back("-target-abi");
1064 CmdArgs.push_back(ABIName.data());
1065
1066 StringRef FloatABI = getMipsFloatABI(D, Args);
1067
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001068 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001069 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001070 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001071 CmdArgs.push_back("-mfloat-abi");
1072 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001073 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001074 else {
1075 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001076 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001077 CmdArgs.push_back("-mfloat-abi");
1078 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001079 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001080
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001081 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1082 if (A->getOption().matches(options::OPT_mxgot)) {
1083 CmdArgs.push_back("-mllvm");
1084 CmdArgs.push_back("-mxgot");
1085 }
1086 }
1087
Simon Atanasyanc580b322013-05-11 06:33:44 +00001088 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1089 options::OPT_mno_ldc1_sdc1)) {
1090 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1091 CmdArgs.push_back("-mllvm");
1092 CmdArgs.push_back("-mno-ldc1-sdc1");
1093 }
1094 }
1095
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001096 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1097 options::OPT_mno_check_zero_division)) {
1098 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1099 CmdArgs.push_back("-mllvm");
1100 CmdArgs.push_back("-mno-check-zero-division");
1101 }
1102 }
1103
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001104 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001105 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001106 CmdArgs.push_back("-mllvm");
1107 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1108 A->claim();
1109 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001110}
1111
Hal Finkel8eb59282012-06-11 22:35:19 +00001112/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1113static std::string getPPCTargetCPU(const ArgList &Args) {
1114 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001115 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001116
1117 if (CPUName == "native") {
1118 std::string CPU = llvm::sys::getHostCPUName();
1119 if (!CPU.empty() && CPU != "generic")
1120 return CPU;
1121 else
1122 return "";
1123 }
1124
1125 return llvm::StringSwitch<const char *>(CPUName)
1126 .Case("common", "generic")
1127 .Case("440", "440")
1128 .Case("440fp", "440")
1129 .Case("450", "450")
1130 .Case("601", "601")
1131 .Case("602", "602")
1132 .Case("603", "603")
1133 .Case("603e", "603e")
1134 .Case("603ev", "603ev")
1135 .Case("604", "604")
1136 .Case("604e", "604e")
1137 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001138 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001139 .Case("G3", "g3")
1140 .Case("7400", "7400")
1141 .Case("G4", "g4")
1142 .Case("7450", "7450")
1143 .Case("G4+", "g4+")
1144 .Case("750", "750")
1145 .Case("970", "970")
1146 .Case("G5", "g5")
1147 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001148 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001149 .Case("e500mc", "e500mc")
1150 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001151 .Case("power3", "pwr3")
1152 .Case("power4", "pwr4")
1153 .Case("power5", "pwr5")
1154 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001155 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001156 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001157 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001158 .Case("pwr3", "pwr3")
1159 .Case("pwr4", "pwr4")
1160 .Case("pwr5", "pwr5")
1161 .Case("pwr5x", "pwr5x")
1162 .Case("pwr6", "pwr6")
1163 .Case("pwr6x", "pwr6x")
1164 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001165 .Case("powerpc", "ppc")
1166 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001167 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001168 .Default("");
1169 }
1170
1171 return "";
1172}
1173
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001174static void getPPCTargetFeatures(const ArgList &Args,
1175 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001176 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1177 ie = Args.filtered_end();
1178 it != ie; ++it) {
1179 StringRef Name = (*it)->getOption().getName();
1180 (*it)->claim();
1181
1182 // Skip over "-m".
1183 assert(Name.startswith("m") && "Invalid feature name.");
1184 Name = Name.substr(1);
1185
1186 bool IsNegative = Name.startswith("no-");
1187 if (IsNegative)
1188 Name = Name.substr(3);
1189
1190 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1191 // pass the correct option to the backend while calling the frontend
1192 // option the same.
1193 // TODO: Change the LLVM backend option maybe?
1194 if (Name == "mfcrf")
1195 Name = "mfocrf";
1196
1197 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1198 }
1199
1200 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001201 AddTargetFeature(Args, Features, options::OPT_faltivec,
1202 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001203}
1204
Tom Stellard6674c702013-04-01 20:56:53 +00001205/// Get the (LLVM) name of the R600 gpu we are targeting.
1206static std::string getR600TargetGPU(const ArgList &Args) {
1207 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001208 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001209 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001210 .Cases("rv630", "rv635", "r600")
1211 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001212 .Case("rv740", "rv770")
1213 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001214 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001215 .Case("hemlock", "cypress")
1216 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001217 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001218 }
1219 return "";
1220}
1221
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001222static void getSparcTargetFeatures(const ArgList &Args,
1223 std::vector<const char *> Features) {
1224 bool SoftFloatABI = true;
1225 if (Arg *A =
1226 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1227 if (A->getOption().matches(options::OPT_mhard_float))
1228 SoftFloatABI = false;
1229 }
1230 if (SoftFloatABI)
1231 Features.push_back("+soft-float");
1232}
1233
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001234void Clang::AddSparcTargetArgs(const ArgList &Args,
1235 ArgStringList &CmdArgs) const {
1236 const Driver &D = getToolChain().getDriver();
1237
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001238 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001239 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001240 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1241 options::OPT_mhard_float)) {
1242 if (A->getOption().matches(options::OPT_msoft_float))
1243 FloatABI = "soft";
1244 else if (A->getOption().matches(options::OPT_mhard_float))
1245 FloatABI = "hard";
1246 }
1247
1248 // If unspecified, choose the default based on the platform.
1249 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001250 // Assume "soft", but warn the user we are guessing.
1251 FloatABI = "soft";
1252 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001253 }
1254
1255 if (FloatABI == "soft") {
1256 // Floating point operations and argument passing are soft.
1257 //
1258 // FIXME: This changes CPP defines, we need -target-soft-float.
1259 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001260 } else {
1261 assert(FloatABI == "hard" && "Invalid float abi!");
1262 CmdArgs.push_back("-mhard-float");
1263 }
1264}
1265
Richard Sandiford4652d892013-07-19 16:51:51 +00001266static const char *getSystemZTargetCPU(const ArgList &Args) {
1267 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1268 return A->getValue();
1269 return "z10";
1270}
1271
Chandler Carruth953fb082013-01-13 11:46:33 +00001272static const char *getX86TargetCPU(const ArgList &Args,
1273 const llvm::Triple &Triple) {
1274 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001275 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001276 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001277 return "core-avx2";
1278
Chandler Carruth953fb082013-01-13 11:46:33 +00001279 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001280 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001281
1282 // FIXME: Reject attempts to use -march=native unless the target matches
1283 // the host.
1284 //
1285 // FIXME: We should also incorporate the detected target features for use
1286 // with -native.
1287 std::string CPU = llvm::sys::getHostCPUName();
1288 if (!CPU.empty() && CPU != "generic")
1289 return Args.MakeArgString(CPU);
1290 }
1291
1292 // Select the default CPU if none was given (or detection failed).
1293
1294 if (Triple.getArch() != llvm::Triple::x86_64 &&
1295 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001296 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001297
1298 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1299
1300 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001301 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001302 if (Triple.getArchName() == "x86_64h")
1303 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001304 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001305 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001306
Alexey Bataev286d1b92014-01-31 04:07:13 +00001307 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001308 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001309 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001310
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001311 // Everything else goes to x86-64 in 64-bit mode.
1312 if (Is64Bit)
1313 return "x86-64";
1314
1315 switch (Triple.getOS()) {
1316 case llvm::Triple::FreeBSD:
1317 case llvm::Triple::NetBSD:
1318 case llvm::Triple::OpenBSD:
1319 return "i486";
1320 case llvm::Triple::Haiku:
1321 return "i586";
1322 case llvm::Triple::Bitrig:
1323 return "i686";
1324 default:
1325 // Fallback to p4.
1326 return "pentium4";
1327 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001328}
1329
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001330static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1331 switch(T.getArch()) {
1332 default:
1333 return "";
1334
Amara Emerson703da2e2013-10-31 09:32:33 +00001335 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001336 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001337 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001338 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001339 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001340
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001341 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001342 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001343 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001344 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001345 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001346
1347 case llvm::Triple::mips:
1348 case llvm::Triple::mipsel:
1349 case llvm::Triple::mips64:
1350 case llvm::Triple::mips64el: {
1351 StringRef CPUName;
1352 StringRef ABIName;
1353 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1354 return CPUName;
1355 }
1356
1357 case llvm::Triple::ppc:
1358 case llvm::Triple::ppc64:
1359 case llvm::Triple::ppc64le: {
1360 std::string TargetCPUName = getPPCTargetCPU(Args);
1361 // LLVM may default to generating code for the native CPU,
1362 // but, like gcc, we default to a more generic option for
1363 // each architecture. (except on Darwin)
1364 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1365 if (T.getArch() == llvm::Triple::ppc64)
1366 TargetCPUName = "ppc64";
1367 else if (T.getArch() == llvm::Triple::ppc64le)
1368 TargetCPUName = "ppc64le";
1369 else
1370 TargetCPUName = "ppc";
1371 }
1372 return TargetCPUName;
1373 }
1374
1375 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001376 case llvm::Triple::sparcv9:
1377 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001378 return A->getValue();
1379 return "";
1380
1381 case llvm::Triple::x86:
1382 case llvm::Triple::x86_64:
1383 return getX86TargetCPU(Args, T);
1384
1385 case llvm::Triple::hexagon:
1386 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1387
1388 case llvm::Triple::systemz:
1389 return getSystemZTargetCPU(Args);
1390
1391 case llvm::Triple::r600:
1392 return getR600TargetGPU(Args);
1393 }
1394}
1395
Alp Tokerce365ca2013-12-02 12:43:03 +00001396static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1397 ArgStringList &CmdArgs) {
1398 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1399 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1400 // forward.
1401 CmdArgs.push_back("-plugin");
1402 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1403 CmdArgs.push_back(Args.MakeArgString(Plugin));
1404
1405 // Try to pass driver level flags relevant to LTO code generation down to
1406 // the plugin.
1407
1408 // Handle flags for selecting CPU variants.
1409 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1410 if (!CPU.empty())
1411 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1412}
1413
Jim Grosbach82eee262013-11-16 00:53:35 +00001414static void getX86TargetFeatures(const llvm::Triple &Triple,
1415 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001416 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001417 if (Triple.getArchName() == "x86_64h") {
1418 // x86_64h implies quite a few of the more modern subtarget features
1419 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1420 Features.push_back("-rdrnd");
1421 Features.push_back("-aes");
1422 Features.push_back("-pclmul");
1423 Features.push_back("-rtm");
1424 Features.push_back("-hle");
1425 Features.push_back("-fsgsbase");
1426 }
1427
Alexey Bataev286d1b92014-01-31 04:07:13 +00001428 if (Triple.getEnvironment() == llvm::Triple::Android) {
1429 // Add sse3 feature to comply with gcc on Android
1430 Features.push_back("+sse3");
1431 }
1432
Jim Grosbach82eee262013-11-16 00:53:35 +00001433 // Now add any that the user explicitly requested on the command line,
1434 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001435 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1436 ie = Args.filtered_end();
1437 it != ie; ++it) {
1438 StringRef Name = (*it)->getOption().getName();
1439 (*it)->claim();
1440
1441 // Skip over "-m".
1442 assert(Name.startswith("m") && "Invalid feature name.");
1443 Name = Name.substr(1);
1444
1445 bool IsNegative = Name.startswith("no-");
1446 if (IsNegative)
1447 Name = Name.substr(3);
1448
1449 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1450 }
1451}
1452
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001453void Clang::AddX86TargetArgs(const ArgList &Args,
1454 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001455 if (!Args.hasFlag(options::OPT_mred_zone,
1456 options::OPT_mno_red_zone,
1457 true) ||
1458 Args.hasArg(options::OPT_mkernel) ||
1459 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001460 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001461
Bob Wilson2616e2e2013-02-10 16:01:41 +00001462 // Default to avoid implicit floating-point for kernel/kext code, but allow
1463 // that to be overridden with -mno-soft-float.
1464 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1465 Args.hasArg(options::OPT_fapple_kext));
1466 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1467 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001468 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001469 options::OPT_mno_implicit_float)) {
1470 const Option &O = A->getOption();
1471 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1472 O.matches(options::OPT_msoft_float));
1473 }
1474 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001475 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001476
1477 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1478 StringRef Value = A->getValue();
1479 if (Value == "intel" || Value == "att") {
1480 CmdArgs.push_back("-mllvm");
1481 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1482 } else {
1483 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1484 << A->getOption().getName() << Value;
1485 }
1486 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001487}
1488
Matthew Curtise8f80a12012-12-06 17:49:03 +00001489static inline bool HasPICArg(const ArgList &Args) {
1490 return Args.hasArg(options::OPT_fPIC)
1491 || Args.hasArg(options::OPT_fpic);
1492}
1493
1494static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1495 return Args.getLastArg(options::OPT_G,
1496 options::OPT_G_EQ,
1497 options::OPT_msmall_data_threshold_EQ);
1498}
1499
1500static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1501 std::string value;
1502 if (HasPICArg(Args))
1503 value = "0";
1504 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1505 value = A->getValue();
1506 A->claim();
1507 }
1508 return value;
1509}
1510
Tony Linthicum76329bf2011-12-12 21:14:55 +00001511void Clang::AddHexagonTargetArgs(const ArgList &Args,
1512 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001513 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001514 CmdArgs.push_back("-mqdsp6-compat");
1515 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001516
Matthew Curtise8f80a12012-12-06 17:49:03 +00001517 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1518 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001519 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001520 CmdArgs.push_back(Args.MakeArgString(
1521 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001522 }
1523
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001524 if (!Args.hasArg(options::OPT_fno_short_enums))
1525 CmdArgs.push_back("-fshort-enums");
1526 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1527 CmdArgs.push_back ("-mllvm");
1528 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1529 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001530 CmdArgs.push_back ("-mllvm");
1531 CmdArgs.push_back ("-machine-sink-split=0");
1532}
1533
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001534static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1535 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001536 // Honor -mfpu=.
1537 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001538 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001539 else
1540 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001541
1542 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1543 Features.push_back("-fp-armv8");
1544 Features.push_back("-crypto");
1545 Features.push_back("-neon");
1546 }
Bradley Smith418c5932014-05-02 15:17:51 +00001547
1548 // En/disable crc
1549 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1550 options::OPT_mnocrc)) {
1551 if (A->getOption().matches(options::OPT_mcrc))
1552 Features.push_back("+crc");
1553 else
1554 Features.push_back("-crc");
1555 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001556}
1557
1558static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001559 const ArgList &Args, ArgStringList &CmdArgs,
1560 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001561 std::vector<const char *> Features;
1562 switch (Triple.getArch()) {
1563 default:
1564 break;
1565 case llvm::Triple::mips:
1566 case llvm::Triple::mipsel:
1567 case llvm::Triple::mips64:
1568 case llvm::Triple::mips64el:
1569 getMIPSTargetFeatures(D, Args, Features);
1570 break;
1571
1572 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001573 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001574 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001575 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001576 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001577 break;
1578
1579 case llvm::Triple::ppc:
1580 case llvm::Triple::ppc64:
1581 case llvm::Triple::ppc64le:
1582 getPPCTargetFeatures(Args, Features);
1583 break;
1584 case llvm::Triple::sparc:
1585 getSparcTargetFeatures(Args, Features);
1586 break;
1587 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001588 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001589 case llvm::Triple::arm64:
1590 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001591 getAArch64TargetFeatures(D, Args, Features);
1592 break;
1593 case llvm::Triple::x86:
1594 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001595 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001596 break;
1597 }
Rafael Espindola43964802013-08-21 17:34:32 +00001598
1599 // Find the last of each feature.
1600 llvm::StringMap<unsigned> LastOpt;
1601 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1602 const char *Name = Features[I];
1603 assert(Name[0] == '-' || Name[0] == '+');
1604 LastOpt[Name + 1] = I;
1605 }
1606
1607 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1608 // If this feature was overridden, ignore it.
1609 const char *Name = Features[I];
1610 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1611 assert(LastI != LastOpt.end());
1612 unsigned Last = LastI->second;
1613 if (Last != I)
1614 continue;
1615
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001616 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001617 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001618 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001619}
1620
Eric Christopher84fbdb42011-08-19 00:30:14 +00001621static bool
John McCall5fb5df92012-06-20 06:18:46 +00001622shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001623 const llvm::Triple &Triple) {
1624 // We use the zero-cost exception tables for Objective-C if the non-fragile
1625 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1626 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001627 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001628 return true;
1629
Bob Wilson83e723a2013-12-05 19:38:42 +00001630 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001631 return false;
1632
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001633 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001634 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001635 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001636}
1637
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001638namespace {
1639 struct ExceptionSettings {
1640 bool ExceptionsEnabled;
1641 bool ShouldUseExceptionTables;
1642 ExceptionSettings() : ExceptionsEnabled(false),
1643 ShouldUseExceptionTables(false) {}
1644 };
1645} // end anonymous namespace.
1646
Nico Webere8e53112014-05-11 01:04:02 +00001647// exceptionSettings() exists to share the logic between -cc1 and linker
1648// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001649static ExceptionSettings exceptionSettings(const ArgList &Args,
1650 const llvm::Triple &Triple) {
1651 ExceptionSettings ES;
1652
1653 // Are exceptions enabled by default?
1654 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1655
1656 // This keeps track of whether exceptions were explicitly turned on or off.
1657 bool DidHaveExplicitExceptionFlag = false;
1658
1659 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1660 options::OPT_fno_exceptions)) {
1661 if (A->getOption().matches(options::OPT_fexceptions))
1662 ES.ExceptionsEnabled = true;
1663 else
1664 ES.ExceptionsEnabled = false;
1665
1666 DidHaveExplicitExceptionFlag = true;
1667 }
1668
1669 // Exception tables and cleanups can be enabled with -fexceptions even if the
1670 // language itself doesn't support exceptions.
1671 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1672 ES.ShouldUseExceptionTables = true;
1673
1674 return ES;
1675}
1676
Anders Carlssone96ab552011-02-28 02:27:16 +00001677/// addExceptionArgs - Adds exception related arguments to the driver command
1678/// arguments. There's a master flag, -fexceptions and also language specific
1679/// flags to enable/disable C++ and Objective-C exceptions.
1680/// This makes it possible to for example disable C++ exceptions but enable
1681/// Objective-C exceptions.
1682static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1683 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001684 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001685 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001686 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001687 if (KernelOrKext) {
1688 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1689 // arguments now to avoid warnings about unused arguments.
1690 Args.ClaimAllArgs(options::OPT_fexceptions);
1691 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1692 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1693 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1694 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1695 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001696 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001697 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001698
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001699 // Gather the exception settings from the command line arguments.
1700 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001701
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001702 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1703 // is not necessarily sensible, but follows GCC.
1704 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001705 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001706 options::OPT_fno_objc_exceptions,
1707 true)) {
1708 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001709
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001710 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001711 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001712 }
1713
1714 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001715 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001716
Eric Christopher84fbdb42011-08-19 00:30:14 +00001717 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1718 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001719 options::OPT_fexceptions,
1720 options::OPT_fno_exceptions)) {
1721 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1722 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001723 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001724 CXXExceptionsEnabled = false;
1725 }
1726
1727 if (CXXExceptionsEnabled) {
1728 CmdArgs.push_back("-fcxx-exceptions");
1729
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001730 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001731 }
1732 }
1733
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001734 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001735 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001736}
1737
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001738static bool ShouldDisableAutolink(const ArgList &Args,
1739 const ToolChain &TC) {
1740 bool Default = true;
1741 if (TC.getTriple().isOSDarwin()) {
1742 // The native darwin assembler doesn't support the linker_option directives,
1743 // so we disable them if we think the .s file will be passed to it.
1744 Default = TC.useIntegratedAs();
1745 }
1746 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1747 Default);
1748}
1749
Ted Kremenek62093662013-03-12 17:02:12 +00001750static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1751 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001752 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1753 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001754 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001755 return !UseDwarfDirectory;
1756}
1757
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001758/// \brief Check whether the given input tree contains any compilation actions.
1759static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001760 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001761 return true;
1762
1763 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1764 if (ContainsCompileAction(*it))
1765 return true;
1766
1767 return false;
1768}
1769
1770/// \brief Check if -relax-all should be passed to the internal assembler.
1771/// This is done by default when compiling non-assembler source with -O0.
1772static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1773 bool RelaxDefault = true;
1774
1775 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1776 RelaxDefault = A->getOption().matches(options::OPT_O0);
1777
1778 if (RelaxDefault) {
1779 RelaxDefault = false;
1780 for (ActionList::const_iterator it = C.getActions().begin(),
1781 ie = C.getActions().end(); it != ie; ++it) {
1782 if (ContainsCompileAction(*it)) {
1783 RelaxDefault = true;
1784 break;
1785 }
1786 }
1787 }
1788
1789 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1790 RelaxDefault);
1791}
1792
David Blaikie9260ed62013-07-25 21:19:01 +00001793static void CollectArgsForIntegratedAssembler(Compilation &C,
1794 const ArgList &Args,
1795 ArgStringList &CmdArgs,
1796 const Driver &D) {
1797 if (UseRelaxAll(C, Args))
1798 CmdArgs.push_back("-mrelax-all");
1799
David Peixottodfb66142013-11-14 22:52:58 +00001800 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001801 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001802 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1803 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1804 // arg after parsing the '-I' arg.
1805 bool TakeNextArg = false;
1806
David Blaikie9260ed62013-07-25 21:19:01 +00001807 // When using an integrated assembler, translate -Wa, and -Xassembler
1808 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001809 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001810 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1811 options::OPT_Xassembler),
1812 ie = Args.filtered_end(); it != ie; ++it) {
1813 const Arg *A = *it;
1814 A->claim();
1815
1816 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1817 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001818 if (TakeNextArg) {
1819 CmdArgs.push_back(Value.data());
1820 TakeNextArg = false;
1821 continue;
1822 }
David Blaikie9260ed62013-07-25 21:19:01 +00001823
1824 if (Value == "-force_cpusubtype_ALL") {
1825 // Do nothing, this is the default and we don't support anything else.
1826 } else if (Value == "-L") {
1827 CmdArgs.push_back("-msave-temp-labels");
1828 } else if (Value == "--fatal-warnings") {
1829 CmdArgs.push_back("-mllvm");
1830 CmdArgs.push_back("-fatal-assembler-warnings");
1831 } else if (Value == "--noexecstack") {
1832 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001833 } else if (Value == "-compress-debug-sections" ||
1834 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001835 CompressDebugSections = true;
1836 } else if (Value == "-nocompress-debug-sections" ||
1837 Value == "--nocompress-debug-sections") {
1838 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001839 } else if (Value.startswith("-I")) {
1840 CmdArgs.push_back(Value.data());
1841 // We need to consume the next argument if the current arg is a plain
1842 // -I. The next arg will be the include directory.
1843 if (Value == "-I")
1844 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00001845 } else if (Value.startswith("-gdwarf-")) {
1846 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00001847 } else {
1848 D.Diag(diag::err_drv_unsupported_option_argument)
1849 << A->getOption().getName() << Value;
1850 }
1851 }
1852 }
David Blaikie24bbfed22014-03-31 23:29:38 +00001853 if (CompressDebugSections) {
1854 if (llvm::zlib::isAvailable())
1855 CmdArgs.push_back("-compress-debug-sections");
1856 else
1857 D.Diag(diag::warn_debug_compression_unavailable);
1858 }
David Blaikie9260ed62013-07-25 21:19:01 +00001859}
1860
Renato Goline807c122014-01-31 11:47:28 +00001861// Until ARM libraries are build separately, we have them all in one library
1862static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001863 if (TC.getArch() == llvm::Triple::arm ||
1864 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00001865 return "arm";
1866 else
1867 return TC.getArchName();
1868}
1869
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001870static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1871 // The runtimes are located in the OS-specific resource directory.
1872 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001873 const llvm::Triple &Triple = TC.getTriple();
1874 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1875 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1876 "freebsd" : TC.getOS();
1877 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001878 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001879}
1880
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001881// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00001882// FIXME: Make sure we can also emit shared objects if they're requested
1883// and available, check for possible errors, etc.
1884static void addClangRTLinux(
1885 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001886 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001887 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
1888 getArchNameForCompilerRTLib(TC) +
1889 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00001890
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001891 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001892 CmdArgs.push_back("-lgcc_s");
1893 if (TC.getDriver().CCCIsCXX())
1894 CmdArgs.push_back("-lgcc_eh");
1895}
1896
Alexey Samsonov7811d192014-02-20 13:57:37 +00001897static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001898 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1899 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1900 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001901 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001902 Args.hasArg(options::OPT_fcreate_profile) ||
1903 Args.hasArg(options::OPT_coverage)))
1904 return;
1905
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001906 // -fprofile-instr-generate requires position-independent code to build with
1907 // shared objects. Link against the right archive.
1908 const char *Lib = "libclang_rt.profile-";
1909 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1910 Args.hasArg(options::OPT_shared))
1911 Lib = "libclang_rt.profile-pic-";
1912
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001913 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1914 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001915 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001916
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00001917 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00001918}
1919
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001920static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
1921 const StringRef Sanitizer,
1922 bool Shared) {
1923 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
1924 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
1925 const char *EnvSuffix =
1926 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001927 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1928 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001929 Twine("libclang_rt.") + Sanitizer + "-" +
1930 getArchNameForCompilerRTLib(TC) + EnvSuffix +
1931 (Shared ? ".so" : ".a"));
1932 return LibSanitizer;
1933}
1934
1935static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
1936 ArgStringList &CmdArgs,
1937 const StringRef Sanitizer,
1938 bool BeforeLibStdCXX,
1939 bool ExportSymbols = true,
1940 bool LinkDeps = true) {
1941 SmallString<128> LibSanitizer =
1942 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00001943
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001944 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1945 // etc.) so that the linker picks custom versions of the global 'operator
1946 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001947 // strategy of inserting it at the front of the link command. It also
1948 // needs to be forced to end up in the executable, so wrap it in
1949 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001950 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001951 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001952 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001953 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001954
1955 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1956 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1957
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001958 if (LinkDeps) {
1959 // Link sanitizer dependencies explicitly
1960 CmdArgs.push_back("-lpthread");
1961 CmdArgs.push_back("-lrt");
1962 CmdArgs.push_back("-lm");
1963 // There's no libdl on FreeBSD.
1964 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1965 CmdArgs.push_back("-ldl");
1966 }
Richard Smithf3e624c2013-03-23 00:30:08 +00001967
1968 // If possible, use a dynamic symbols file to export the symbols from the
1969 // runtime library. If we can't do so, use -export-dynamic instead to export
1970 // all symbols from the binary.
1971 if (ExportSymbols) {
1972 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1973 CmdArgs.push_back(
1974 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1975 else
1976 CmdArgs.push_back("-export-dynamic");
1977 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001978}
1979
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001980/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1981/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001982static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001983 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001984 if (Shared) {
1985 // Link dynamic runtime if necessary.
1986 SmallString<128> LibSanitizer =
1987 getSanitizerRTLibName(TC, "asan", Shared);
1988 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001989 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001990
1991 // Do not link static runtime to DSOs or if compiling for Android.
1992 if (Args.hasArg(options::OPT_shared) ||
1993 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
1994 return;
1995
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001996 if (Shared) {
1997 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
1998 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
1999 /*LinkDeps*/ false);
2000 } else {
2001 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2002 if (IsCXX)
2003 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2004 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002005}
2006
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002007/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2008/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002009static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2010 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002011 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002012 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002013}
2014
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002015/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2016/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002017static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2018 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002019 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002020 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002021}
2022
2023/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2024/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002025static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2026 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002027 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002028 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002029}
2030
Richard Smithe30752c2012-10-09 19:52:38 +00002031/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2032/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002033static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2034 ArgStringList &CmdArgs, bool IsCXX,
2035 bool HasOtherSanitizerRt) {
Richard Smith4244ea92014-06-04 23:28:46 +00002036 // Export symbols if we're not building a shared library. This allows two
2037 // models: either every DSO containing ubsan-sanitized code contains the
2038 // ubsan runtime, or the main executable does (or both).
2039 const bool ExportSymbols = !Args.hasArg(options::OPT_shared);
2040
Nick Lewycky24921692013-10-19 00:27:23 +00002041 // Need a copy of sanitizer_common. This could come from another sanitizer
2042 // runtime; if we're not including one, include our own copy.
2043 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002044 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002045
Richard Smith4244ea92014-06-04 23:28:46 +00002046 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, ExportSymbols);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002047
2048 // Only include the bits of the runtime which need a C++ ABI library if
2049 // we're linking in C++ mode.
2050 if (IsCXX)
Richard Smith4244ea92014-06-04 23:28:46 +00002051 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false,
2052 ExportSymbols);
Richard Smithe30752c2012-10-09 19:52:38 +00002053}
2054
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002055static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2056 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002057 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002058 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2059}
2060
2061// Should be called before we add C++ ABI library.
2062static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2063 ArgStringList &CmdArgs) {
2064 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2065 const Driver &D = TC.getDriver();
2066 if (Sanitize.needsUbsanRt())
2067 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2068 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2069 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2070 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002071 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002072 if (Sanitize.needsTsanRt())
2073 addTsanRT(TC, Args, CmdArgs);
2074 if (Sanitize.needsMsanRt())
2075 addMsanRT(TC, Args, CmdArgs);
2076 if (Sanitize.needsLsanRt())
2077 addLsanRT(TC, Args, CmdArgs);
2078 if (Sanitize.needsDfsanRt())
2079 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002080}
2081
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002082static bool shouldUseFramePointerForTarget(const ArgList &Args,
2083 const llvm::Triple &Triple) {
2084 switch (Triple.getArch()) {
2085 // Don't use a frame pointer on linux if optimizing for certain targets.
2086 case llvm::Triple::mips64:
2087 case llvm::Triple::mips64el:
2088 case llvm::Triple::mips:
2089 case llvm::Triple::mipsel:
2090 case llvm::Triple::systemz:
2091 case llvm::Triple::x86:
2092 case llvm::Triple::x86_64:
2093 if (Triple.isOSLinux())
2094 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2095 if (!A->getOption().matches(options::OPT_O0))
2096 return false;
2097 return true;
2098 case llvm::Triple::xcore:
2099 return false;
2100 default:
2101 return true;
2102 }
2103}
2104
Rafael Espindola224dd632011-12-14 21:02:23 +00002105static bool shouldUseFramePointer(const ArgList &Args,
2106 const llvm::Triple &Triple) {
2107 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2108 options::OPT_fomit_frame_pointer))
2109 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2110
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002111 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002112}
2113
Eric Christopherb7d97e92013-04-03 01:58:53 +00002114static bool shouldUseLeafFramePointer(const ArgList &Args,
2115 const llvm::Triple &Triple) {
2116 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2117 options::OPT_momit_leaf_frame_pointer))
2118 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2119
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002120 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002121}
2122
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002123/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002124static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002125 SmallString<128> cwd;
2126 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002127 CmdArgs.push_back("-fdebug-compilation-dir");
2128 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002129 }
2130}
2131
Eric Christopherd3804002013-02-22 20:12:52 +00002132static const char *SplitDebugName(const ArgList &Args,
2133 const InputInfoList &Inputs) {
2134 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2135 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2136 SmallString<128> T(FinalOutput->getValue());
2137 llvm::sys::path::replace_extension(T, "dwo");
2138 return Args.MakeArgString(T);
2139 } else {
2140 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002141 SmallString<128> T(
2142 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002143 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2144 llvm::sys::path::replace_extension(F, "dwo");
2145 T += F;
2146 return Args.MakeArgString(F);
2147 }
2148}
2149
2150static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2151 const Tool &T, const JobAction &JA,
2152 const ArgList &Args, const InputInfo &Output,
2153 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002154 ArgStringList ExtractArgs;
2155 ExtractArgs.push_back("--extract-dwo");
2156
2157 ArgStringList StripArgs;
2158 StripArgs.push_back("--strip-dwo");
2159
2160 // Grabbing the output of the earlier compile step.
2161 StripArgs.push_back(Output.getFilename());
2162 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002163 ExtractArgs.push_back(OutFile);
2164
2165 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002166 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002167
2168 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002169 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002170
2171 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002172 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002173}
2174
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002175/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002176/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2177static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002178 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002179 if (A->getOption().matches(options::OPT_O4) ||
2180 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002181 return true;
2182
2183 if (A->getOption().matches(options::OPT_O0))
2184 return false;
2185
2186 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2187
Rafael Espindola91780de2013-08-26 14:05:41 +00002188 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002189 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002190 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002191 return true;
2192
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002193 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002194 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002195 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002196
2197 unsigned OptLevel = 0;
2198 if (S.getAsInteger(10, OptLevel))
2199 return false;
2200
2201 return OptLevel > 1;
2202 }
2203
2204 return false;
2205}
2206
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002207/// Add -x lang to \p CmdArgs for \p Input.
2208static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2209 ArgStringList &CmdArgs) {
2210 // When using -verify-pch, we don't want to provide the type
2211 // 'precompiled-header' if it was inferred from the file extension
2212 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2213 return;
2214
2215 CmdArgs.push_back("-x");
2216 if (Args.hasArg(options::OPT_rewrite_objc))
2217 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2218 else
2219 CmdArgs.push_back(types::getTypeName(Input.getType()));
2220}
2221
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002222void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002223 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002224 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002225 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002226 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002227 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2228 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002229 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002230 ArgStringList CmdArgs;
2231
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002232 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002233 bool IsWindowsCygnus =
2234 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002235 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2236
Daniel Dunbare521a892009-03-31 20:53:55 +00002237 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2238
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002239 // Invoke ourselves in -cc1 mode.
2240 //
2241 // FIXME: Implement custom jobs for internal actions.
2242 CmdArgs.push_back("-cc1");
2243
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002244 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002245 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002246 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002247 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002248
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002249 const llvm::Triple TT(TripleStr);
2250 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2251 TT.getArch() == llvm::Triple::thumb)) {
2252 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2253 unsigned Version;
2254 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2255 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002256 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2257 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002258 }
2259
Tim Northover336f1892014-03-29 13:16:12 +00002260 // Push all default warning arguments that are specific to
2261 // the given target. These come before user provided warning options
2262 // are provided.
2263 getToolChain().addClangWarningOptions(CmdArgs);
2264
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002265 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002266 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002267
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002268 if (isa<AnalyzeJobAction>(JA)) {
2269 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2270 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002271 } else if (isa<MigrateJobAction>(JA)) {
2272 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002273 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002274 if (Output.getType() == types::TY_Dependencies)
2275 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002276 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002277 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002278 if (Args.hasArg(options::OPT_rewrite_objc) &&
2279 !Args.hasArg(options::OPT_g_Group))
2280 CmdArgs.push_back("-P");
2281 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002282 } else if (isa<AssembleJobAction>(JA)) {
2283 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002284
David Blaikie9260ed62013-07-25 21:19:01 +00002285 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002286
2287 // Also ignore explicit -force_cpusubtype_ALL option.
2288 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002289 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002290 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002291 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002292
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002293 if (JA.getType() == types::TY_Nothing)
2294 CmdArgs.push_back("-fsyntax-only");
2295 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002296 CmdArgs.push_back("-emit-pch");
2297 else
2298 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002299 } else if (isa<VerifyPCHJobAction>(JA)) {
2300 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002301 } else {
2302 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002303
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002304 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002305 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002306 } else if (JA.getType() == types::TY_LLVM_IR ||
2307 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002308 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002309 } else if (JA.getType() == types::TY_LLVM_BC ||
2310 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002311 CmdArgs.push_back("-emit-llvm-bc");
2312 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002313 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002314 } else if (JA.getType() == types::TY_AST) {
2315 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002316 } else if (JA.getType() == types::TY_ModuleFile) {
2317 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002318 } else if (JA.getType() == types::TY_RewrittenObjC) {
2319 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002320 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002321 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2322 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002323 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002324 } else {
2325 assert(JA.getType() == types::TY_PP_Asm &&
2326 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002327 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002328 }
2329
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002330 // The make clang go fast button.
2331 CmdArgs.push_back("-disable-free");
2332
John McCallbb79b5f2010-02-13 03:50:24 +00002333 // Disable the verification pass in -asserts builds.
2334#ifdef NDEBUG
2335 CmdArgs.push_back("-disable-llvm-verifier");
2336#endif
2337
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002338 // Set the main file name, so that debug info works even with
2339 // -save-temps.
2340 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002341 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002342
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002343 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002344 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002345 if (Args.hasArg(options::OPT_static))
2346 CmdArgs.push_back("-static-define");
2347
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002348 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002349 // Enable region store model by default.
2350 CmdArgs.push_back("-analyzer-store=region");
2351
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002352 // Treat blocks as analysis entry points.
2353 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2354
Ted Kremenek49c79792011-03-24 00:28:47 +00002355 CmdArgs.push_back("-analyzer-eagerly-assume");
2356
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002357 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002358 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002359 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002360
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002361 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002362 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002363
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002364 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002365 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002366
2367 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002368
Jordan Rose10ad0812013-04-05 17:55:07 +00002369 if (types::isCXX(Inputs[0].getType()))
2370 CmdArgs.push_back("-analyzer-checker=cplusplus");
2371
Nico Webere8e53112014-05-11 01:04:02 +00002372 // Enable the following experimental checkers for testing.
2373 CmdArgs.push_back(
2374 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002375 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2376 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2377 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2378 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2379 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002380 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002381
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002382 // Set the output format. The default is plist, for (lame) historical
2383 // reasons.
2384 CmdArgs.push_back("-analyzer-output");
2385 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002386 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002387 else
2388 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002389
Ted Kremenekfe449a22010-03-22 22:32:05 +00002390 // Disable the presentation of standard compiler warnings when
2391 // using --analyze. We only want to show static analyzer diagnostics
2392 // or frontend errors.
2393 CmdArgs.push_back("-w");
2394
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002395 // Add -Xanalyzer arguments when running as analyzer.
2396 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002397 }
2398
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002399 CheckCodeGenerationOptions(D, Args);
2400
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002401 bool PIE = getToolChain().isPIEDefault();
2402 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002403 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002404
Alexey Bataev40e75222014-01-28 06:30:35 +00002405 // Android-specific defaults for PIC/PIE
2406 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2407 switch (getToolChain().getTriple().getArch()) {
2408 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002409 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002410 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002411 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002412 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002413 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002414 case llvm::Triple::mips:
2415 case llvm::Triple::mipsel:
2416 case llvm::Triple::mips64:
2417 case llvm::Triple::mips64el:
2418 PIC = true; // "-fpic"
2419 break;
2420
2421 case llvm::Triple::x86:
2422 case llvm::Triple::x86_64:
2423 PIC = true; // "-fPIC"
2424 IsPICLevelTwo = true;
2425 break;
2426
2427 default:
2428 break;
2429 }
2430 }
2431
Alexey Samsonov090301e2013-04-09 12:28:19 +00002432 // For the PIC and PIE flag options, this logic is different from the
2433 // legacy logic in very old versions of GCC, as that logic was just
2434 // a bug no one had ever fixed. This logic is both more rational and
2435 // consistent with GCC's new logic now that the bugs are fixed. The last
2436 // argument relating to either PIC or PIE wins, and no other argument is
2437 // used. If the last argument is any flavor of the '-fno-...' arguments,
2438 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2439 // at the same level.
2440 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2441 options::OPT_fpic, options::OPT_fno_pic,
2442 options::OPT_fPIE, options::OPT_fno_PIE,
2443 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002444 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2445 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002446 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002447 if (LastPICArg) {
2448 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002449 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2450 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2451 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2452 PIC = PIE || O.matches(options::OPT_fPIC) ||
2453 O.matches(options::OPT_fpic);
2454 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2455 O.matches(options::OPT_fPIC);
2456 } else {
2457 PIE = PIC = false;
2458 }
2459 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002460 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002461
Nick Lewycky609dd662013-10-11 03:33:53 +00002462 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002463 // specified while enabling PIC enabled level 1 PIC, just force it back to
2464 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2465 // informal testing).
2466 if (PIC && getToolChain().getTriple().isOSDarwin())
2467 IsPICLevelTwo |= getToolChain().isPICDefault();
2468
Chandler Carruthc0c04552012-04-08 16:40:35 +00002469 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2470 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002471 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002472 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002473 Triple.getArch() == llvm::Triple::arm64 ||
2474 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002475 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002476 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002477 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002478
Chandler Carruth76a943b2012-11-19 03:52:03 +00002479 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2480 // This is a very special mode. It trumps the other modes, almost no one
2481 // uses it, and it isn't even valid on any OS but Darwin.
2482 if (!getToolChain().getTriple().isOSDarwin())
2483 D.Diag(diag::err_drv_unsupported_opt_for_target)
2484 << A->getSpelling() << getToolChain().getTriple().str();
2485
2486 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2487
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002488 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002489 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002490
Chandler Carruth76a943b2012-11-19 03:52:03 +00002491 // Only a forced PIC mode can cause the actual compile to have PIC defines
2492 // etc., no flags are sufficient. This behavior was selected to closely
2493 // match that of llvm-gcc and Apple GCC before that.
2494 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2495 CmdArgs.push_back("-pic-level");
2496 CmdArgs.push_back("2");
2497 }
2498 } else {
2499 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2500 // handled in Clang's IRGen by the -pie-level flag.
2501 CmdArgs.push_back("-mrelocation-model");
2502 CmdArgs.push_back(PIC ? "pic" : "static");
2503
2504 if (PIC) {
2505 CmdArgs.push_back("-pic-level");
2506 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2507 if (PIE) {
2508 CmdArgs.push_back("-pie-level");
2509 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2510 }
2511 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002512 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002513
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002514 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2515 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002516 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002517
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002518 // LLVM Code Generator Options.
2519
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002520 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2521 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002522 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002523 }
2524
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002525 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2526 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002527 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002528 D.Diag(diag::err_drv_unsupported_opt_for_target)
2529 << A->getSpelling() << getToolChain().getTriple().str();
2530 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2531 CmdArgs.push_back("-fpcc-struct-return");
2532 } else {
2533 assert(A->getOption().matches(options::OPT_freg_struct_return));
2534 CmdArgs.push_back("-freg-struct-return");
2535 }
2536 }
2537
Roman Divacky65b88cd2011-03-01 17:40:53 +00002538 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2539 CmdArgs.push_back("-mrtd");
2540
Rafael Espindola224dd632011-12-14 21:02:23 +00002541 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002542 CmdArgs.push_back("-mdisable-fp-elim");
2543 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2544 options::OPT_fno_zero_initialized_in_bss))
2545 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002546
2547 bool OFastEnabled = isOptimizationLevelFast(Args);
2548 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2549 // enabled. This alias option is being used to simplify the hasFlag logic.
2550 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2551 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002552 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2553 // doesn't do any TBAA.
2554 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002555 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002556 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002557 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002558 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2559 options::OPT_fno_struct_path_tbaa))
2560 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002561 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2562 false))
2563 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002564 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2565 options::OPT_fno_optimize_sibling_calls))
2566 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002567
Eric Christopher006208c2013-04-04 06:29:47 +00002568 // Handle segmented stacks.
2569 if (Args.hasArg(options::OPT_fsplit_stack))
2570 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002571
2572 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2573 // This alias option is being used to simplify the getLastArg logic.
2574 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2575 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002576
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002577 // Handle various floating point optimization flags, mapping them to the
2578 // appropriate LLVM code generation flags. The pattern for all of these is to
2579 // default off the codegen optimizations, and if any flag enables them and no
2580 // flag disables them after the flag enabling them, enable the codegen
2581 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002582 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002583 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002584 options::OPT_ffinite_math_only,
2585 options::OPT_fno_finite_math_only,
2586 options::OPT_fhonor_infinities,
2587 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002588 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2589 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002590 A->getOption().getID() != options::OPT_fhonor_infinities)
2591 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002592 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002593 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002594 options::OPT_ffinite_math_only,
2595 options::OPT_fno_finite_math_only,
2596 options::OPT_fhonor_nans,
2597 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002598 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2599 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002600 A->getOption().getID() != options::OPT_fhonor_nans)
2601 CmdArgs.push_back("-menable-no-nans");
2602
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002603 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2604 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002605 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002606 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002607 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002608 options::OPT_fno_math_errno)) {
2609 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2610 // However, turning *off* -ffast_math merely restores the toolchain default
2611 // (which may be false).
2612 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2613 A->getOption().getID() == options::OPT_ffast_math ||
2614 A->getOption().getID() == options::OPT_Ofast)
2615 MathErrno = false;
2616 else if (A->getOption().getID() == options::OPT_fmath_errno)
2617 MathErrno = true;
2618 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002619 if (MathErrno)
2620 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002621
2622 // There are several flags which require disabling very specific
2623 // optimizations. Any of these being disabled forces us to turn off the
2624 // entire set of LLVM optimizations, so collect them through all the flag
2625 // madness.
2626 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002627 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002628 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002629 options::OPT_funsafe_math_optimizations,
2630 options::OPT_fno_unsafe_math_optimizations,
2631 options::OPT_fassociative_math,
2632 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002633 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2634 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002635 A->getOption().getID() != options::OPT_fno_associative_math)
2636 AssociativeMath = true;
2637 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002638 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002639 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002640 options::OPT_funsafe_math_optimizations,
2641 options::OPT_fno_unsafe_math_optimizations,
2642 options::OPT_freciprocal_math,
2643 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002644 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2645 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002646 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2647 ReciprocalMath = true;
2648 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002649 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002650 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002651 options::OPT_funsafe_math_optimizations,
2652 options::OPT_fno_unsafe_math_optimizations,
2653 options::OPT_fsigned_zeros,
2654 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002655 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2656 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002657 A->getOption().getID() != options::OPT_fsigned_zeros)
2658 SignedZeros = false;
2659 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002660 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002661 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002662 options::OPT_funsafe_math_optimizations,
2663 options::OPT_fno_unsafe_math_optimizations,
2664 options::OPT_ftrapping_math,
2665 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002666 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2667 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002668 A->getOption().getID() != options::OPT_ftrapping_math)
2669 TrappingMath = false;
2670 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2671 !TrappingMath)
2672 CmdArgs.push_back("-menable-unsafe-fp-math");
2673
Lang Hamesaa53b932012-07-06 00:59:19 +00002674
2675 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002676 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002677 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002678 options::OPT_ffp_contract)) {
2679 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002680 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002681 if (Val == "fast" || Val == "on" || Val == "off") {
2682 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2683 } else {
2684 D.Diag(diag::err_drv_unsupported_option_argument)
2685 << A->getOption().getName() << Val;
2686 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002687 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2688 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002689 // If fast-math is set then set the fp-contract mode to fast.
2690 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2691 }
2692 }
2693
Bob Wilson6a039162012-07-19 03:52:53 +00002694 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2695 // and if we find them, tell the frontend to provide the appropriate
2696 // preprocessor macros. This is distinct from enabling any optimizations as
2697 // these options induce language changes which must survive serialization
2698 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002699 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2700 options::OPT_fno_fast_math))
2701 if (!A->getOption().matches(options::OPT_fno_fast_math))
2702 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002703 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2704 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002705 if (A->getOption().matches(options::OPT_ffinite_math_only))
2706 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002707
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002708 // Decide whether to use verbose asm. Verbose assembly is the default on
2709 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002710 bool IsIntegratedAssemblerDefault =
2711 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002712 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002713 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002714 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002715 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002716
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002717 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002718 IsIntegratedAssemblerDefault))
2719 CmdArgs.push_back("-no-integrated-as");
2720
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002721 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2722 CmdArgs.push_back("-mdebug-pass");
2723 CmdArgs.push_back("Structure");
2724 }
2725 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2726 CmdArgs.push_back("-mdebug-pass");
2727 CmdArgs.push_back("Arguments");
2728 }
2729
John McCall8517abc2010-02-19 02:45:38 +00002730 // Enable -mconstructor-aliases except on darwin, where we have to
2731 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002732 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002733 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002734
John McCall7ef5cb32011-03-18 02:56:14 +00002735 // Darwin's kernel doesn't support guard variables; just die if we
2736 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002737 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002738 CmdArgs.push_back("-fforbid-guard-variables");
2739
Douglas Gregordbe39272011-02-01 15:15:22 +00002740 if (Args.hasArg(options::OPT_mms_bitfields)) {
2741 CmdArgs.push_back("-mms-bitfields");
2742 }
John McCall8517abc2010-02-19 02:45:38 +00002743
Daniel Dunbar306945d2009-09-16 06:17:29 +00002744 // This is a coarse approximation of what llvm-gcc actually does, both
2745 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2746 // complicated ways.
2747 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002748 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2749 options::OPT_fno_asynchronous_unwind_tables,
2750 (getToolChain().IsUnwindTablesDefault() ||
2751 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2752 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002753 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2754 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002755 CmdArgs.push_back("-munwind-tables");
2756
Chandler Carruth05fb5852012-11-21 23:40:23 +00002757 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002758
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002759 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2760 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002761 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002762 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002763
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002764 // FIXME: Handle -mtune=.
2765 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002766
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002767 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002768 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002769 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002770 }
2771
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002772 // Add the target cpu
2773 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2774 llvm::Triple ETriple(ETripleStr);
2775 std::string CPU = getCPUName(Args, ETriple);
2776 if (!CPU.empty()) {
2777 CmdArgs.push_back("-target-cpu");
2778 CmdArgs.push_back(Args.MakeArgString(CPU));
2779 }
2780
Rafael Espindolaeb265472013-08-21 21:59:03 +00002781 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2782 CmdArgs.push_back("-mfpmath");
2783 CmdArgs.push_back(A->getValue());
2784 }
2785
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002786 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002787 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002788
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002789 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002790 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002791 default:
2792 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002793
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002794 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002795 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002796 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002797 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002798 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002799 break;
2800
Tim Northover573cbee2014-05-24 12:52:07 +00002801 case llvm::Triple::aarch64:
2802 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002803 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002804 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002805 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002806 break;
2807
Eric Christopher0b26a612010-03-02 02:41:08 +00002808 case llvm::Triple::mips:
2809 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002810 case llvm::Triple::mips64:
2811 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002812 AddMIPSTargetArgs(Args, CmdArgs);
2813 break;
2814
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002815 case llvm::Triple::sparc:
2816 AddSparcTargetArgs(Args, CmdArgs);
2817 break;
2818
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002819 case llvm::Triple::x86:
2820 case llvm::Triple::x86_64:
2821 AddX86TargetArgs(Args, CmdArgs);
2822 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002823
2824 case llvm::Triple::hexagon:
2825 AddHexagonTargetArgs(Args, CmdArgs);
2826 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002827 }
2828
Hans Wennborg75958c42013-08-08 00:17:41 +00002829 // Add clang-cl arguments.
2830 if (getToolChain().getDriver().IsCLMode())
2831 AddClangCLArgs(Args, CmdArgs);
2832
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002833 // Pass the linker version in use.
2834 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2835 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002836 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002837 }
2838
Eric Christopherb7d97e92013-04-03 01:58:53 +00002839 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002840 CmdArgs.push_back("-momit-leaf-frame-pointer");
2841
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002842 // Explicitly error on some things we know we don't support and can't just
2843 // ignore.
2844 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002845 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2846 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002847 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002848 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002849 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002850 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2851 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002852 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002853 << Unsupported->getOption().getName();
2854 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002855 }
2856
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002857 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002858 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002859 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002860 CmdArgs.push_back("-header-include-file");
2861 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2862 D.CCPrintHeadersFilename : "-");
2863 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002864 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002865 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002866
Chad Rosierbe10f982011-08-02 17:58:04 +00002867 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002868 CmdArgs.push_back("-diagnostic-log-file");
2869 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2870 D.CCLogDiagnosticsFilename : "-");
2871 }
2872
Manman Ren17bdb0f2013-11-20 20:22:14 +00002873 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2874 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002875 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002876 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002877 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002878 // FIXME: we should support specifying dwarf version with
2879 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002880 CmdArgs.push_back("-gline-tables-only");
Adrian Prantl549c5142014-02-17 17:40:52 +00002881 // Default is dwarf-2 for darwin.
2882 if (getToolChain().getTriple().isOSDarwin())
2883 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002884 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002885 CmdArgs.push_back("-gdwarf-2");
2886 else if (A->getOption().matches(options::OPT_gdwarf_3))
2887 CmdArgs.push_back("-gdwarf-3");
2888 else if (A->getOption().matches(options::OPT_gdwarf_4))
2889 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002890 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002891 !A->getOption().matches(options::OPT_ggdb0)) {
2892 // Default is dwarf-2 for darwin.
2893 if (getToolChain().getTriple().isOSDarwin())
2894 CmdArgs.push_back("-gdwarf-2");
2895 else
2896 CmdArgs.push_back("-g");
2897 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002898 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002899
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002900 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2901 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002902 if (Args.hasArg(options::OPT_gcolumn_info))
2903 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002904
Eric Christopher138c32b2013-09-13 22:37:55 +00002905 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002906 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2907 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002908 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002909 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002910 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002911 CmdArgs.push_back("-g");
2912 CmdArgs.push_back("-backend-option");
2913 CmdArgs.push_back("-split-dwarf=Enable");
2914 }
2915
Eric Christopher138c32b2013-09-13 22:37:55 +00002916 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2917 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2918 CmdArgs.push_back("-backend-option");
2919 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2920 }
Eric Christophereec89c22013-06-18 00:03:50 +00002921
Eric Christopher0d403d22014-02-14 01:27:03 +00002922 // -gdwarf-aranges turns on the emission of the aranges section in the
2923 // backend.
2924 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2925 CmdArgs.push_back("-backend-option");
2926 CmdArgs.push_back("-generate-arange-section");
2927 }
2928
David Blaikief36d9ba2014-01-27 18:52:43 +00002929 if (Args.hasFlag(options::OPT_fdebug_types_section,
2930 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002931 CmdArgs.push_back("-backend-option");
2932 CmdArgs.push_back("-generate-type-units");
2933 }
Eric Christophereec89c22013-06-18 00:03:50 +00002934
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002935 if (Args.hasFlag(options::OPT_ffunction_sections,
2936 options::OPT_fno_function_sections, false)) {
2937 CmdArgs.push_back("-ffunction-sections");
2938 }
2939
2940 if (Args.hasFlag(options::OPT_fdata_sections,
2941 options::OPT_fno_data_sections, false)) {
2942 CmdArgs.push_back("-fdata-sections");
2943 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002944
Chris Lattner3c77a352010-06-22 00:03:40 +00002945 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2946
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002947 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2948 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2949 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2950 D.Diag(diag::err_drv_argument_not_allowed_with)
2951 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2952
2953 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2954
2955 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2956 A->render(Args, CmdArgs);
2957 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2958 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2959
Nick Lewycky207bce32011-04-21 23:44:07 +00002960 if (Args.hasArg(options::OPT_ftest_coverage) ||
2961 Args.hasArg(options::OPT_coverage))
2962 CmdArgs.push_back("-femit-coverage-notes");
2963 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2964 Args.hasArg(options::OPT_coverage))
2965 CmdArgs.push_back("-femit-coverage-data");
2966
Nick Lewycky480cb992011-05-04 20:46:58 +00002967 if (C.getArgs().hasArg(options::OPT_c) ||
2968 C.getArgs().hasArg(options::OPT_S)) {
2969 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002970 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002971 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002972 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002973 SmallString<128> Pwd;
2974 if (!llvm::sys::fs::current_path(Pwd)) {
2975 llvm::sys::path::append(Pwd, CoverageFilename.str());
2976 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002977 }
2978 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002979 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002980 }
2981 }
2982
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002983 // Pass options for controlling the default header search paths.
2984 if (Args.hasArg(options::OPT_nostdinc)) {
2985 CmdArgs.push_back("-nostdsysteminc");
2986 CmdArgs.push_back("-nobuiltininc");
2987 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002988 if (Args.hasArg(options::OPT_nostdlibinc))
2989 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002990 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2991 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2992 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002993
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002994 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00002995 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00002996 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00002997
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002998 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2999
Ted Kremenekf7639e12012-03-06 20:06:33 +00003000 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003001 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003002 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003003 options::OPT_ccc_arcmt_modify,
3004 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003005 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003006 switch (A->getOption().getID()) {
3007 default:
3008 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003009 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003010 CmdArgs.push_back("-arcmt-check");
3011 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003012 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003013 CmdArgs.push_back("-arcmt-modify");
3014 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003015 case options::OPT_ccc_arcmt_migrate:
3016 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003017 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003018 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003019
3020 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3021 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003022 break;
John McCalld70fb982011-06-15 23:25:17 +00003023 }
3024 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003025 } else {
3026 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3027 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3028 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003029 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003030
Ted Kremenekf7639e12012-03-06 20:06:33 +00003031 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3032 if (ARCMTEnabled) {
3033 D.Diag(diag::err_drv_argument_not_allowed_with)
3034 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3035 }
3036 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003037 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003038
3039 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003040 options::OPT_objcmt_migrate_subscripting,
3041 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003042 // None specified, means enable them all.
3043 CmdArgs.push_back("-objcmt-migrate-literals");
3044 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003045 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003046 } else {
3047 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3048 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003049 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003050 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003051 } else {
3052 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3053 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3054 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3055 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3056 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3057 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3058 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3059 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3060 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3061 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3062 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3063 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3064 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003065 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003066 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003067 }
3068
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003069 // Add preprocessing options like -I, -D, etc. if we are using the
3070 // preprocessor.
3071 //
3072 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003073 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003074 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003075
Rafael Espindolaa7431922011-07-21 23:40:37 +00003076 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3077 // that "The compiler can only warn and ignore the option if not recognized".
3078 // When building with ccache, it will pass -D options to clang even on
3079 // preprocessed inputs and configure concludes that -fPIC is not supported.
3080 Args.ClaimAllArgs(options::OPT_D);
3081
Alp Toker7874bdc2013-11-15 20:40:58 +00003082 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003083 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3084 if (A->getOption().matches(options::OPT_O4)) {
3085 CmdArgs.push_back("-O3");
3086 D.Diag(diag::warn_O4_is_O3);
3087 } else {
3088 A->render(Args, CmdArgs);
3089 }
3090 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003091
Chad Rosier86b82082012-12-12 20:06:31 +00003092 // Don't warn about unused -flto. This can happen when we're preprocessing or
3093 // precompiling.
3094 Args.ClaimAllArgs(options::OPT_flto);
3095
Daniel Dunbar945577c2009-10-29 02:24:45 +00003096 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003097 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3098 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003099 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003100 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003101
3102 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003103 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003104 //
3105 // If a std is supplied, only add -trigraphs if it follows the
3106 // option.
3107 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3108 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003109 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003110 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003111 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003112 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003113 else
3114 Std->render(Args, CmdArgs);
3115
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003116 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3117 options::OPT_trigraphs))
3118 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003119 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003120 } else {
3121 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003122 //
3123 // FIXME: Clang doesn't correctly handle -std= when the input language
3124 // doesn't match. For the time being just ignore this for C++ inputs;
3125 // eventually we want to do all the standard defaulting here instead of
3126 // splitting it between the driver and clang -cc1.
3127 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003128 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3129 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003130 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003131 CmdArgs.push_back("-std=c++11");
3132
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003133 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003134 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003135
Richard Smith282b4492013-09-04 22:50:31 +00003136 // GCC's behavior for -Wwrite-strings is a bit strange:
3137 // * In C, this "warning flag" changes the types of string literals from
3138 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3139 // for the discarded qualifier.
3140 // * In C++, this is just a normal warning flag.
3141 //
3142 // Implementing this warning correctly in C is hard, so we follow GCC's
3143 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3144 // a non-const char* in C, rather than using this crude hack.
3145 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003146 // FIXME: This should behave just like a warning flag, and thus should also
3147 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3148 Arg *WriteStrings =
3149 Args.getLastArg(options::OPT_Wwrite_strings,
3150 options::OPT_Wno_write_strings, options::OPT_w);
3151 if (WriteStrings &&
3152 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003153 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003154 }
3155
Chandler Carruth61fbf622011-04-23 09:27:53 +00003156 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003157 // during C++ compilation, which it is by default. GCC keeps this define even
3158 // in the presence of '-w', match this behavior bug-for-bug.
3159 if (types::isCXX(InputType) &&
3160 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3161 true)) {
3162 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003163 }
3164
Chandler Carruthe0391482010-05-22 02:21:53 +00003165 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3166 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3167 if (Asm->getOption().matches(options::OPT_fasm))
3168 CmdArgs.push_back("-fgnu-keywords");
3169 else
3170 CmdArgs.push_back("-fno-gnu-keywords");
3171 }
3172
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003173 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3174 CmdArgs.push_back("-fno-dwarf-directory-asm");
3175
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003176 if (ShouldDisableAutolink(Args, getToolChain()))
3177 CmdArgs.push_back("-fno-autolink");
3178
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003179 // Add in -fdebug-compilation-dir if necessary.
3180 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003181
Richard Smith9a568822011-11-21 19:36:32 +00003182 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3183 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003184 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003185 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003186 }
3187
Richard Smith79c927b2013-11-06 19:31:51 +00003188 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3189 CmdArgs.push_back("-foperator-arrow-depth");
3190 CmdArgs.push_back(A->getValue());
3191 }
3192
Richard Smith9a568822011-11-21 19:36:32 +00003193 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3194 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003195 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003196 }
3197
Richard Smitha3d3bd22013-05-08 02:12:03 +00003198 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3199 CmdArgs.push_back("-fconstexpr-steps");
3200 CmdArgs.push_back(A->getValue());
3201 }
3202
Richard Smithb3a14522013-02-22 01:59:51 +00003203 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3204 CmdArgs.push_back("-fbracket-depth");
3205 CmdArgs.push_back(A->getValue());
3206 }
3207
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003208 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3209 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003210 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003211 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003212 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3213 } else
3214 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003215 }
3216
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003217
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003218 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003219 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003220
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003221 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3222 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003223 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003224 }
David Chisnall5778fce2009-08-31 16:41:57 +00003225
Chris Lattnere23003d2010-01-09 21:54:33 +00003226 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3227 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003228 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003229 }
3230
Chris Lattnerb35583d2010-04-07 20:49:23 +00003231 CmdArgs.push_back("-ferror-limit");
3232 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003233 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003234 else
3235 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003236
Chandler Carrutha77a7272010-05-06 04:55:18 +00003237 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3238 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003239 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003240 }
3241
3242 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3243 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003244 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003245 }
3246
Richard Smithf6f003a2011-12-16 19:06:07 +00003247 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3248 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003249 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003250 }
3251
Daniel Dunbar2c978472009-11-04 06:24:47 +00003252 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003253 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003254 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003255 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003256 } else {
3257 // If -fmessage-length=N was not specified, determine whether this is a
3258 // terminal and, if so, implicitly define -fmessage-length appropriately.
3259 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003260 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003261 }
3262
John McCallb4a99d32013-02-19 01:57:35 +00003263 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3264 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3265 options::OPT_fvisibility_ms_compat)) {
3266 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3267 CmdArgs.push_back("-fvisibility");
3268 CmdArgs.push_back(A->getValue());
3269 } else {
3270 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3271 CmdArgs.push_back("-fvisibility");
3272 CmdArgs.push_back("hidden");
3273 CmdArgs.push_back("-ftype-visibility");
3274 CmdArgs.push_back("default");
3275 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003276 }
3277
Douglas Gregor08329632010-06-15 17:05:35 +00003278 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003279
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003280 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3281
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003282 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003283 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3284 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003285 CmdArgs.push_back("-ffreestanding");
3286
Daniel Dunbare357d562009-12-03 18:42:11 +00003287 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003288 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003289 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003290 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3291 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003292 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003293 // AltiVec language extensions aren't relevant for assembling.
3294 if (!isa<PreprocessJobAction>(JA) ||
3295 Output.getType() != types::TY_PP_Asm)
3296 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003297 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3298 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003299
Peter Collingbourne32701642013-11-01 18:16:25 +00003300 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3301 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003302
Will Dietz3676d562012-12-30 20:53:28 +00003303 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3304 options::OPT_fno_sanitize_recover,
3305 true))
3306 CmdArgs.push_back("-fno-sanitize-recover");
3307
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003308 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003309 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3310 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3311
Eric Christopher459d2712013-02-19 06:16:53 +00003312 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003313 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003314 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003315 getToolChain().getArch() == llvm::Triple::ppc64 ||
3316 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003317 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003318 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003319
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003320 if (getToolChain().SupportsProfiling())
3321 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003322
3323 // -flax-vector-conversions is default.
3324 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3325 options::OPT_fno_lax_vector_conversions))
3326 CmdArgs.push_back("-fno-lax-vector-conversions");
3327
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003328 if (Args.getLastArg(options::OPT_fapple_kext))
3329 CmdArgs.push_back("-fapple-kext");
3330
David Blaikie690f21e2012-06-14 18:55:27 +00003331 if (Args.hasFlag(options::OPT_frewrite_includes,
3332 options::OPT_fno_rewrite_includes, false))
3333 CmdArgs.push_back("-frewrite-includes");
3334
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003335 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003336 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003337 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003338 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3339 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003340
3341 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3342 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003343 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003344 }
3345
Bob Wilson14adb362012-02-03 06:27:22 +00003346 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003347
Chandler Carruth6e501032011-03-27 00:04:55 +00003348 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3349 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3350 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3351 options::OPT_fno_wrapv)) {
3352 if (A->getOption().matches(options::OPT_fwrapv))
3353 CmdArgs.push_back("-fwrapv");
3354 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3355 options::OPT_fno_strict_overflow)) {
3356 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3357 CmdArgs.push_back("-fwrapv");
3358 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003359
3360 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3361 options::OPT_fno_reroll_loops))
3362 if (A->getOption().matches(options::OPT_freroll_loops))
3363 CmdArgs.push_back("-freroll-loops");
3364
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003365 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003366 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3367 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003368
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003369 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3370
Mahesha S6a682be42012-10-27 07:47:56 +00003371
Daniel Dunbar4930e332009-11-17 08:07:36 +00003372 // -stack-protector=0 is default.
3373 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003374 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3375 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003376 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003377 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003378 if (A->getOption().matches(options::OPT_fstack_protector)) {
3379 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3380 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3381 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003382 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003383 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003384 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003385 } else {
3386 StackProtectorLevel =
3387 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3388 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003389 if (StackProtectorLevel) {
3390 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003391 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003392 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003393
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003394 // --param ssp-buffer-size=
3395 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3396 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003397 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003398 if (Str.startswith("ssp-buffer-size=")) {
3399 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003400 CmdArgs.push_back("-stack-protector-buffer-size");
3401 // FIXME: Verify the argument is a valid integer.
3402 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003403 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003404 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003405 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003406 }
3407
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003408 // Translate -mstackrealign
3409 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3410 false)) {
3411 CmdArgs.push_back("-backend-option");
3412 CmdArgs.push_back("-force-align-stack");
3413 }
3414 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3415 false)) {
3416 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3417 }
3418
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003419 if (Args.hasArg(options::OPT_mstack_alignment)) {
3420 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3421 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003422 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003423 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003424 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003425 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3426 options::OPT_munaligned_access)) {
3427 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3428 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003429 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3430 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3431 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003432 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003433 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003434 else
3435 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003436 } else {
3437 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003438 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3439 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3440 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003441 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003442 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003443 else
3444 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003445 }
Renato Golina146a482013-08-24 14:44:41 +00003446 }
Chad Rosier60027022012-11-09 17:29:19 +00003447 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003448
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003449 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3450 options::OPT_mno_restrict_it)) {
3451 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3452 CmdArgs.push_back("-backend-option");
3453 CmdArgs.push_back("-arm-restrict-it");
3454 } else {
3455 CmdArgs.push_back("-backend-option");
3456 CmdArgs.push_back("-arm-no-restrict-it");
3457 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003458 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3459 TT.getArch() == llvm::Triple::thumb)) {
3460 // Windows on ARM expects restricted IT blocks
3461 CmdArgs.push_back("-backend-option");
3462 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003463 }
3464
Daniel Dunbard18049a2009-04-07 21:16:11 +00003465 // Forward -f options with positive and negative forms; we translate
3466 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003467 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3468 StringRef fname = A->getValue();
3469 if (!llvm::sys::fs::exists(fname))
3470 D.Diag(diag::err_drv_no_such_file) << fname;
3471 else
3472 A->render(Args, CmdArgs);
3473 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003474
Diego Novillo829b1702014-04-16 16:54:24 +00003475 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3476 A->render(Args, CmdArgs);
3477
Diego Novillod23ec942014-05-29 19:55:06 +00003478 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3479 A->render(Args, CmdArgs);
3480
3481 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3482 A->render(Args, CmdArgs);
3483
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003484 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003485 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003486 CmdArgs.push_back("-fapple-kext");
3487 if (!Args.hasArg(options::OPT_fbuiltin))
3488 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003489 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003490 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003491 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003492 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003493 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003494
Nuno Lopes13c88c72009-12-16 16:59:22 +00003495 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3496 options::OPT_fno_assume_sane_operator_new))
3497 CmdArgs.push_back("-fno-assume-sane-operator-new");
3498
Daniel Dunbar4930e332009-11-17 08:07:36 +00003499 // -fblocks=0 is default.
3500 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003501 getToolChain().IsBlocksDefault()) ||
3502 (Args.hasArg(options::OPT_fgnu_runtime) &&
3503 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3504 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003505 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003506
3507 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3508 !getToolChain().hasBlocksRuntime())
3509 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003510 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003511
Douglas Gregor226173a2012-01-18 15:19:58 +00003512 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3513 // users must also pass -fcxx-modules. The latter flag will disappear once the
3514 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003515 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003516 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3517 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3518 options::OPT_fno_cxx_modules,
3519 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003520 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003521 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003522 HaveModules = true;
3523 }
3524 }
3525
Daniel Jasper07e6c402013-08-05 20:26:17 +00003526 // -fmodule-maps enables module map processing (off by default) for header
3527 // checking. It is implied by -fmodules.
3528 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3529 false)) {
3530 CmdArgs.push_back("-fmodule-maps");
3531 }
3532
Daniel Jasperac42b752013-10-21 06:34:34 +00003533 // -fmodules-decluse checks that modules used are declared so (off by
3534 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003535 if (Args.hasFlag(options::OPT_fmodules_decluse,
3536 options::OPT_fno_modules_decluse,
3537 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003538 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003539 }
3540
Daniel Jasper962b38e2014-04-11 11:47:45 +00003541 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3542 // all #included headers are part of modules.
3543 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3544 options::OPT_fno_modules_strict_decluse,
3545 false)) {
3546 CmdArgs.push_back("-fmodules-strict-decluse");
3547 }
3548
Daniel Jasperac42b752013-10-21 06:34:34 +00003549 // -fmodule-name specifies the module that is currently being built (or
3550 // used for header checking by -fmodule-maps).
3551 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3552 A->claim();
3553 A->render(Args, CmdArgs);
3554 }
3555
3556 // -fmodule-map-file can be used to specify a file containing module
3557 // definitions.
3558 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3559 A->claim();
3560 A->render(Args, CmdArgs);
3561 }
3562
Douglas Gregor35b04d62013-02-07 19:01:24 +00003563 // If a module path was provided, pass it along. Otherwise, use a temporary
3564 // directory.
3565 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3566 A->claim();
3567 if (HaveModules) {
3568 A->render(Args, CmdArgs);
3569 }
3570 } else if (HaveModules) {
3571 SmallString<128> DefaultModuleCache;
3572 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3573 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003574 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3575 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003576 const char Arg[] = "-fmodules-cache-path=";
3577 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3578 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003579 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3580 }
3581
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003582 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3583 A->claim();
3584 if (HaveModules) {
3585 A->render(Args, CmdArgs);
3586 }
3587 }
3588
Douglas Gregor35b04d62013-02-07 19:01:24 +00003589 // Pass through all -fmodules-ignore-macro arguments.
3590 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003591 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3592 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003593
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003594 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3595
3596 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3597 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3598 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3599
3600 Args.AddLastArg(CmdArgs,
3601 options::OPT_fmodules_validate_once_per_build_session);
3602 }
3603
Ben Langmuirdcf73862014-03-12 00:06:17 +00003604 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3605
John McCalldfea9982010-04-09 19:12:06 +00003606 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003607 if (Args.hasFlag(options::OPT_fno_access_control,
3608 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003609 false))
John McCall3155f572010-04-09 19:03:51 +00003610 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003611
Anders Carlssond470fef2010-11-21 00:09:52 +00003612 // -felide-constructors is the default.
3613 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3614 options::OPT_felide_constructors,
3615 false))
3616 CmdArgs.push_back("-fno-elide-constructors");
3617
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003618 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003619 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003620 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003621 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003622
Richard Smith52be6192012-11-05 22:04:41 +00003623 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003624 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003625 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003626 Args.getLastArg(options::OPT_mkernel,
3627 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003628 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003629 D.Diag(diag::err_drv_argument_not_allowed_with)
3630 << "-fsanitize=vptr" << NoRttiArg;
3631 }
3632 }
3633
Tony Linthicum76329bf2011-12-12 21:14:55 +00003634 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003635 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003636 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003637 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003638 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003639 CmdArgs.push_back("-fshort-enums");
3640
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003641 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003642 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003643 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003644 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003645
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003646 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003647 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003648 options::OPT_fno_threadsafe_statics))
3649 CmdArgs.push_back("-fno-threadsafe-statics");
3650
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003651 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003652 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3653 options::OPT_fno_use_cxa_atexit,
3654 !IsWindowsCygnus && !IsWindowsGNU &&
3655 getToolChain().getArch() != llvm::Triple::hexagon &&
3656 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003657 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003658 CmdArgs.push_back("-fno-use-cxa-atexit");
3659
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003660 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003661 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003662 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003663 CmdArgs.push_back("-fms-extensions");
3664
Francois Pichet1b4f1632011-09-17 04:32:15 +00003665 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003666 if (Args.hasFlag(options::OPT_fms_compatibility,
3667 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003668 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3669 options::OPT_fno_ms_extensions,
3670 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003671 CmdArgs.push_back("-fms-compatibility");
3672
Reid Klecknerc106fda2013-09-18 00:33:59 +00003673 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003674 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003675 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003676 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003677 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003678 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003679 else
3680 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3681 }
3682
3683
Eric Christopher5ecce122013-02-18 00:38:31 +00003684 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003685 if (Args.hasFlag(options::OPT_fborland_extensions,
3686 options::OPT_fno_borland_extensions, false))
3687 CmdArgs.push_back("-fborland-extensions");
3688
Francois Pichet02744872011-09-01 16:38:08 +00003689 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3690 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003691 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003692 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003693 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003694
Chandler Carruthe03aa552010-04-17 20:17:31 +00003695 // -fgnu-keywords default varies depending on language; only pass if
3696 // specified.
3697 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003698 options::OPT_fno_gnu_keywords))
3699 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003700
Rafael Espindola922a6242011-06-02 17:30:53 +00003701 if (Args.hasFlag(options::OPT_fgnu89_inline,
3702 options::OPT_fno_gnu89_inline,
3703 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003704 CmdArgs.push_back("-fgnu89-inline");
3705
Chad Rosier9c76d242012-03-15 22:31:42 +00003706 if (Args.hasArg(options::OPT_fno_inline))
3707 CmdArgs.push_back("-fno-inline");
3708
Chad Rosier64d6be92012-03-06 21:17:19 +00003709 if (Args.hasArg(options::OPT_fno_inline_functions))
3710 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003711
John McCall5fb5df92012-06-20 06:18:46 +00003712 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003713
John McCall5fb5df92012-06-20 06:18:46 +00003714 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003715 // legacy is the default. Except for deployment taget of 10.5,
3716 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3717 // gets ignored silently.
3718 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003719 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3720 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003721 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003722 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003723 if (getToolChain().UseObjCMixedDispatch())
3724 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3725 else
3726 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3727 }
3728 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003729
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003730 // When ObjectiveC legacy runtime is in effect on MacOSX,
3731 // turn on the option to do Array/Dictionary subscripting
3732 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003733 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3734 getToolChain().getTriple().isMacOSX() &&
3735 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3736 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003737 objcRuntime.isNeXTFamily())
3738 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3739
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003740 // -fencode-extended-block-signature=1 is default.
3741 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3742 CmdArgs.push_back("-fencode-extended-block-signature");
3743 }
3744
John McCall24fc0de2011-07-06 00:26:06 +00003745 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3746 // NOTE: This logic is duplicated in ToolChains.cpp.
3747 bool ARC = isObjCAutoRefCount(Args);
3748 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003749 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003750
John McCall24fc0de2011-07-06 00:26:06 +00003751 CmdArgs.push_back("-fobjc-arc");
3752
Chandler Carruth491db322011-11-04 07:34:47 +00003753 // FIXME: It seems like this entire block, and several around it should be
3754 // wrapped in isObjC, but for now we just use it here as this is where it
3755 // was being used previously.
3756 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3757 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3758 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3759 else
3760 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3761 }
3762
John McCall24fc0de2011-07-06 00:26:06 +00003763 // Allow the user to enable full exceptions code emission.
3764 // We define off for Objective-CC, on for Objective-C++.
3765 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3766 options::OPT_fno_objc_arc_exceptions,
3767 /*default*/ types::isCXX(InputType)))
3768 CmdArgs.push_back("-fobjc-arc-exceptions");
3769 }
3770
3771 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3772 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003773 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003774 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003775
John McCall24fc0de2011-07-06 00:26:06 +00003776 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3777 // takes precedence.
3778 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3779 if (!GCArg)
3780 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3781 if (GCArg) {
3782 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003783 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003784 << GCArg->getAsString(Args);
3785 } else if (getToolChain().SupportsObjCGC()) {
3786 GCArg->render(Args, CmdArgs);
3787 } else {
3788 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003789 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003790 << GCArg->getAsString(Args);
3791 }
3792 }
3793
John McCallb5f652e2011-06-22 00:53:57 +00003794 // Add exception args.
3795 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003796 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003797
3798 if (getToolChain().UseSjLjExceptions())
3799 CmdArgs.push_back("-fsjlj-exceptions");
3800
3801 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003802 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3803 options::OPT_fno_assume_sane_operator_new))
3804 CmdArgs.push_back("-fno-assume-sane-operator-new");
3805
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003806 // -fconstant-cfstrings is default, and may be subject to argument translation
3807 // on Darwin.
3808 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3809 options::OPT_fno_constant_cfstrings) ||
3810 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3811 options::OPT_mno_constant_cfstrings))
3812 CmdArgs.push_back("-fno-constant-cfstrings");
3813
John Thompsoned4e2952009-11-05 20:14:16 +00003814 // -fshort-wchar default varies depending on platform; only
3815 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003816 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3817 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003818 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003819
Hans Wennborg28c96312013-07-31 23:39:13 +00003820 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003821 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003822 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003823 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003824 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003825
Daniel Dunbar096ed292011-10-05 21:04:55 +00003826 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3827 // -fno-pack-struct doesn't apply to -fpack-struct=.
3828 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003829 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003830 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003831 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003832 } else if (Args.hasFlag(options::OPT_fpack_struct,
3833 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003834 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003835 }
3836
Robert Lytton0e076492013-08-13 09:43:10 +00003837 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003838 if (!Args.hasArg(options::OPT_fcommon))
3839 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003840 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003841 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003842
Daniel Dunbard18049a2009-04-07 21:16:11 +00003843 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003844 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003845 CmdArgs.push_back("-fno-common");
3846
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003847 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003848 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003849 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003850 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003851 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003852 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3853
Daniel Dunbar6358d682010-10-15 22:30:42 +00003854 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3855 if (!Args.hasFlag(options::OPT_ffor_scope,
3856 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003857 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003858 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3859
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003860 // -fcaret-diagnostics is default.
3861 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3862 options::OPT_fno_caret_diagnostics, true))
3863 CmdArgs.push_back("-fno-caret-diagnostics");
3864
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003865 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003866 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003867 options::OPT_fno_diagnostics_fixit_info))
3868 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003869
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003870 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003871 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003872 options::OPT_fno_diagnostics_show_option))
3873 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003874
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003875 if (const Arg *A =
3876 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3877 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003878 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003879 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003880
Douglas Gregor643c9222011-05-21 17:07:29 +00003881 if (const Arg *A =
3882 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3883 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003884 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003885 }
3886
Chandler Carruthb6766f02011-03-27 01:50:55 +00003887 if (Arg *A = Args.getLastArg(
3888 options::OPT_fdiagnostics_show_note_include_stack,
3889 options::OPT_fno_diagnostics_show_note_include_stack)) {
3890 if (A->getOption().matches(
3891 options::OPT_fdiagnostics_show_note_include_stack))
3892 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3893 else
3894 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3895 }
3896
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003897 // Color diagnostics are the default, unless the terminal doesn't support
3898 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003899 // Support both clang's -f[no-]color-diagnostics and gcc's
3900 // -f[no-]diagnostics-colors[=never|always|auto].
3901 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3902 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3903 it != ie; ++it) {
3904 const Option &O = (*it)->getOption();
3905 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3906 !O.matches(options::OPT_fdiagnostics_color) &&
3907 !O.matches(options::OPT_fno_color_diagnostics) &&
3908 !O.matches(options::OPT_fno_diagnostics_color) &&
3909 !O.matches(options::OPT_fdiagnostics_color_EQ))
3910 continue;
3911
3912 (*it)->claim();
3913 if (O.matches(options::OPT_fcolor_diagnostics) ||
3914 O.matches(options::OPT_fdiagnostics_color)) {
3915 ShowColors = Colors_On;
3916 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3917 O.matches(options::OPT_fno_diagnostics_color)) {
3918 ShowColors = Colors_Off;
3919 } else {
3920 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3921 StringRef value((*it)->getValue());
3922 if (value == "always")
3923 ShowColors = Colors_On;
3924 else if (value == "never")
3925 ShowColors = Colors_Off;
3926 else if (value == "auto")
3927 ShowColors = Colors_Auto;
3928 else
3929 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3930 << ("-fdiagnostics-color=" + value).str();
3931 }
3932 }
3933 if (ShowColors == Colors_On ||
3934 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003935 CmdArgs.push_back("-fcolor-diagnostics");
3936
Nico Rieck7857d462013-09-11 00:38:02 +00003937 if (Args.hasArg(options::OPT_fansi_escape_codes))
3938 CmdArgs.push_back("-fansi-escape-codes");
3939
Daniel Dunbardb097022009-06-08 21:13:54 +00003940 if (!Args.hasFlag(options::OPT_fshow_source_location,
3941 options::OPT_fno_show_source_location))
3942 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003943
Douglas Gregor643c9222011-05-21 17:07:29 +00003944 if (!Args.hasFlag(options::OPT_fshow_column,
3945 options::OPT_fno_show_column,
3946 true))
3947 CmdArgs.push_back("-fno-show-column");
3948
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003949 if (!Args.hasFlag(options::OPT_fspell_checking,
3950 options::OPT_fno_spell_checking))
3951 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003952
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003953
Chad Rosierc8e56e82012-12-05 21:08:21 +00003954 // -fno-asm-blocks is default.
3955 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3956 false))
3957 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003958
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003959 // Enable vectorization per default according to the optimization level
3960 // selected. For optimization levels that want vectorization we use the alias
3961 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003962 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003963 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003964 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003965 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003966 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003967 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003968
Chad Rosier136d67d2014-04-28 19:30:57 +00003969 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003970 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
3971 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00003972 options::OPT_fslp_vectorize;
3973 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003974 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003975 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003976
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003977 // -fno-slp-vectorize-aggressive is default.
3978 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003979 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003980 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003981
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00003982 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3983 A->render(Args, CmdArgs);
3984
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003985 // -fdollars-in-identifiers default varies depending on platform and
3986 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00003987 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003988 options::OPT_fno_dollars_in_identifiers)) {
3989 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003990 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003991 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00003992 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00003993 }
3994
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003995 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3996 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00003997 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00003998 options::OPT_fno_unit_at_a_time)) {
3999 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004000 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004001 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004002
Eli Friedman055c9702011-11-02 01:53:16 +00004003 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4004 options::OPT_fno_apple_pragma_pack, false))
4005 CmdArgs.push_back("-fapple-pragma-pack");
4006
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004007 // le32-specific flags:
4008 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4009 // by default.
4010 if (getToolChain().getArch() == llvm::Triple::le32) {
4011 CmdArgs.push_back("-fno-math-builtin");
4012 }
4013
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004014 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004015 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004016 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004017#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004018 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004019 (getToolChain().getArch() == llvm::Triple::arm ||
4020 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004021 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4022 CmdArgs.push_back("-fno-builtin-strcat");
4023 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4024 CmdArgs.push_back("-fno-builtin-strcpy");
4025 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004026#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004027
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004028 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004029 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004030 options::OPT_traditional_cpp)) {
4031 if (isa<PreprocessJobAction>(JA))
4032 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004033 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004034 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004035 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004036
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004037 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004038 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004039
4040 // Handle serialized diagnostics.
4041 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4042 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004043 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004044 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004045
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004046 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4047 CmdArgs.push_back("-fretain-comments-from-system-headers");
4048
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004049 // Forward -fcomment-block-commands to -cc1.
4050 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004051 // Forward -fparse-all-comments to -cc1.
4052 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004053
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004054 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4055 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004056 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004057 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4058 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004059 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004060
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004061 // We translate this by hand to the -cc1 argument, since nightly test uses
4062 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004063 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004064 CmdArgs.push_back("-disable-llvm-optzns");
4065 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004066 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004067 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004068
Daniel Dunbard67a3222009-03-30 06:36:42 +00004069 if (Output.getType() == types::TY_Dependencies) {
4070 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004071 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004072 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004073 CmdArgs.push_back(Output.getFilename());
4074 } else {
4075 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004076 }
4077
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004078 for (InputInfoList::const_iterator
4079 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4080 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004081
4082 addDashXForInput(Args, II, CmdArgs);
4083
Daniel Dunbarb440f562010-08-02 02:38:21 +00004084 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004085 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004086 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004087 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004088 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004089
Chris Lattnere9d7d782009-11-03 19:50:27 +00004090 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4091
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004092 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004093
4094 // Optionally embed the -cc1 level arguments into the debug info, for build
4095 // analysis.
4096 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004097 ArgStringList OriginalArgs;
4098 for (ArgList::const_iterator it = Args.begin(),
4099 ie = Args.end(); it != ie; ++it)
4100 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004101
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004102 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004103 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004104 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004105 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004106 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004107 }
4108 CmdArgs.push_back("-dwarf-debug-flags");
4109 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4110 }
4111
Eric Christopherd3804002013-02-22 20:12:52 +00004112 // Add the split debug info name to the command lines here so we
4113 // can propagate it to the backend.
4114 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004115 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004116 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004117 const char *SplitDwarfOut;
4118 if (SplitDwarf) {
4119 CmdArgs.push_back("-split-dwarf-file");
4120 SplitDwarfOut = SplitDebugName(Args, Inputs);
4121 CmdArgs.push_back(SplitDwarfOut);
4122 }
4123
4124 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004125 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004126 Output.getType() == types::TY_Object &&
4127 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00004128 tools::visualstudio::Compile CL(getToolChain());
4129 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
4130 LinkingOutput);
Reid Kleckner47c2f842014-05-14 16:03:05 +00004131 // RTTI support in clang-cl is a work in progress. Fall back to MSVC early
4132 // if we are using 'clang-cl /fallback /GR'.
4133 // FIXME: Remove this when RTTI is finished.
4134 if (Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti, false)) {
4135 D.Diag(diag::warn_drv_rtti_fallback) << CLCommand->getExecutable();
4136 C.addCommand(CLCommand);
4137 } else {
4138 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
4139 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00004140 } else {
4141 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4142 }
4143
Daniel Dunbar17731772009-03-23 19:03:36 +00004144
Eric Christopherf1545832013-02-22 23:50:16 +00004145 // Handle the debug info splitting at object creation time if we're
4146 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004147 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004148 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004149 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004150
Roman Divacky178e01602011-02-10 16:52:03 +00004151 if (Arg *A = Args.getLastArg(options::OPT_pg))
4152 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004153 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004154 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004155
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004156 // Claim some arguments which clang supports automatically.
4157
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004158 // -fpch-preprocess is used with gcc to add a special marker in the output to
4159 // include the PCH file. Clang's PTH solution is completely transparent, so we
4160 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004161 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004162
Daniel Dunbar17731772009-03-23 19:03:36 +00004163 // Claim some arguments which clang doesn't support, but we don't
4164 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004165 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4166 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004167
Rafael Espindolab0092d72013-09-04 19:37:35 +00004168 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004169 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004170}
4171
John McCall5fb5df92012-06-20 06:18:46 +00004172/// Add options related to the Objective-C runtime/ABI.
4173///
4174/// Returns true if the runtime is non-fragile.
4175ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4176 ArgStringList &cmdArgs,
4177 RewriteKind rewriteKind) const {
4178 // Look for the controlling runtime option.
4179 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4180 options::OPT_fgnu_runtime,
4181 options::OPT_fobjc_runtime_EQ);
4182
4183 // Just forward -fobjc-runtime= to the frontend. This supercedes
4184 // options about fragility.
4185 if (runtimeArg &&
4186 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4187 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004188 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004189 if (runtime.tryParse(value)) {
4190 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4191 << value;
4192 }
4193
4194 runtimeArg->render(args, cmdArgs);
4195 return runtime;
4196 }
4197
4198 // Otherwise, we'll need the ABI "version". Version numbers are
4199 // slightly confusing for historical reasons:
4200 // 1 - Traditional "fragile" ABI
4201 // 2 - Non-fragile ABI, version 1
4202 // 3 - Non-fragile ABI, version 2
4203 unsigned objcABIVersion = 1;
4204 // If -fobjc-abi-version= is present, use that to set the version.
4205 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004206 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004207 if (value == "1")
4208 objcABIVersion = 1;
4209 else if (value == "2")
4210 objcABIVersion = 2;
4211 else if (value == "3")
4212 objcABIVersion = 3;
4213 else
4214 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4215 << value;
4216 } else {
4217 // Otherwise, determine if we are using the non-fragile ABI.
4218 bool nonFragileABIIsDefault =
4219 (rewriteKind == RK_NonFragile ||
4220 (rewriteKind == RK_None &&
4221 getToolChain().IsObjCNonFragileABIDefault()));
4222 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4223 options::OPT_fno_objc_nonfragile_abi,
4224 nonFragileABIIsDefault)) {
4225 // Determine the non-fragile ABI version to use.
4226#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4227 unsigned nonFragileABIVersion = 1;
4228#else
4229 unsigned nonFragileABIVersion = 2;
4230#endif
4231
4232 if (Arg *abiArg = args.getLastArg(
4233 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004234 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004235 if (value == "1")
4236 nonFragileABIVersion = 1;
4237 else if (value == "2")
4238 nonFragileABIVersion = 2;
4239 else
4240 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4241 << value;
4242 }
4243
4244 objcABIVersion = 1 + nonFragileABIVersion;
4245 } else {
4246 objcABIVersion = 1;
4247 }
4248 }
4249
4250 // We don't actually care about the ABI version other than whether
4251 // it's non-fragile.
4252 bool isNonFragile = objcABIVersion != 1;
4253
4254 // If we have no runtime argument, ask the toolchain for its default runtime.
4255 // However, the rewriter only really supports the Mac runtime, so assume that.
4256 ObjCRuntime runtime;
4257 if (!runtimeArg) {
4258 switch (rewriteKind) {
4259 case RK_None:
4260 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4261 break;
4262 case RK_Fragile:
4263 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4264 break;
4265 case RK_NonFragile:
4266 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4267 break;
4268 }
4269
4270 // -fnext-runtime
4271 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4272 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004273 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004274 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4275
4276 // Otherwise, build for a generic macosx port.
4277 } else {
4278 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4279 }
4280
4281 // -fgnu-runtime
4282 } else {
4283 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004284 // Legacy behaviour is to target the gnustep runtime if we are i
4285 // non-fragile mode or the GCC runtime in fragile mode.
4286 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004287 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004288 else
4289 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004290 }
4291
4292 cmdArgs.push_back(args.MakeArgString(
4293 "-fobjc-runtime=" + runtime.getAsString()));
4294 return runtime;
4295}
4296
Hans Wennborg75958c42013-08-08 00:17:41 +00004297void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4298 unsigned RTOptionID = options::OPT__SLASH_MT;
4299
Hans Wennborgf1a74252013-09-10 20:18:04 +00004300 if (Args.hasArg(options::OPT__SLASH_LDd))
4301 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4302 // but defining _DEBUG is sticky.
4303 RTOptionID = options::OPT__SLASH_MTd;
4304
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004305 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004306 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004307
Hans Wennborg75958c42013-08-08 00:17:41 +00004308 switch(RTOptionID) {
4309 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004310 if (Args.hasArg(options::OPT__SLASH_LDd))
4311 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004312 CmdArgs.push_back("-D_MT");
4313 CmdArgs.push_back("-D_DLL");
4314 CmdArgs.push_back("--dependent-lib=msvcrt");
4315 break;
4316 case options::OPT__SLASH_MDd:
4317 CmdArgs.push_back("-D_DEBUG");
4318 CmdArgs.push_back("-D_MT");
4319 CmdArgs.push_back("-D_DLL");
4320 CmdArgs.push_back("--dependent-lib=msvcrtd");
4321 break;
4322 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004323 if (Args.hasArg(options::OPT__SLASH_LDd))
4324 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004325 CmdArgs.push_back("-D_MT");
4326 CmdArgs.push_back("--dependent-lib=libcmt");
4327 break;
4328 case options::OPT__SLASH_MTd:
4329 CmdArgs.push_back("-D_DEBUG");
4330 CmdArgs.push_back("-D_MT");
4331 CmdArgs.push_back("--dependent-lib=libcmtd");
4332 break;
4333 default:
4334 llvm_unreachable("Unexpected option ID.");
4335 }
4336
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004337 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4338 // users want. The /Za flag to cl.exe turns this off, but it's not
4339 // implemented in clang.
4340 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004341
Hans Wennborg0fd62072013-08-09 00:32:23 +00004342 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4343 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004344
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004345 // RTTI is currently not supported, so disable it by default.
4346 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4347 CmdArgs.push_back("-fno-rtti");
4348
David Majnemer86c318f2014-02-11 21:05:00 +00004349 const Driver &D = getToolChain().getDriver();
4350 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4351 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4352 if (MostGeneralArg && BestCaseArg)
4353 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4354 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4355
4356 if (MostGeneralArg) {
4357 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4358 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4359 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4360
4361 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4362 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4363 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4364 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4365 << FirstConflict->getAsString(Args)
4366 << SecondConflict->getAsString(Args);
4367
4368 if (SingleArg)
4369 CmdArgs.push_back("-fms-memptr-rep=single");
4370 else if (MultipleArg)
4371 CmdArgs.push_back("-fms-memptr-rep=multiple");
4372 else
4373 CmdArgs.push_back("-fms-memptr-rep=virtual");
4374 }
4375
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004376 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4377 A->render(Args, CmdArgs);
4378
Hans Wennborg81f74482013-09-10 01:07:07 +00004379 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4380 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004381 if (Args.hasArg(options::OPT__SLASH_fallback))
4382 CmdArgs.push_back("msvc-fallback");
4383 else
4384 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004385 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004386}
4387
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004388void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004389 const InputInfo &Output,
4390 const InputInfoList &Inputs,
4391 const ArgList &Args,
4392 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004393 ArgStringList CmdArgs;
4394
4395 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4396 const InputInfo &Input = Inputs[0];
4397
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004398 // Don't warn about "clang -w -c foo.s"
4399 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004400 // and "clang -emit-llvm -c foo.s"
4401 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004402
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004403 // Invoke ourselves in -cc1as mode.
4404 //
4405 // FIXME: Implement custom jobs for internal actions.
4406 CmdArgs.push_back("-cc1as");
4407
4408 // Add the "effective" target triple.
4409 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004410 std::string TripleStr =
4411 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004412 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4413
4414 // Set the output mode, we currently only expect to be used as a real
4415 // assembler.
4416 CmdArgs.push_back("-filetype");
4417 CmdArgs.push_back("obj");
4418
Eric Christopher45f2e712012-12-18 00:31:10 +00004419 // Set the main file name, so that debug info works even with
4420 // -save-temps or preprocessed assembly.
4421 CmdArgs.push_back("-main-file-name");
4422 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4423
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004424 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004425 const llvm::Triple &Triple = getToolChain().getTriple();
4426 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004427 if (!CPU.empty()) {
4428 CmdArgs.push_back("-target-cpu");
4429 CmdArgs.push_back(Args.MakeArgString(CPU));
4430 }
4431
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004432 // Add the target features
4433 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004434 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004435
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004436 // Ignore explicit -force_cpusubtype_ALL option.
4437 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004438
Eric Christopherfc3ee562012-01-10 00:38:01 +00004439 // Determine the original source input.
4440 const Action *SourceAction = &JA;
4441 while (SourceAction->getKind() != Action::InputClass) {
4442 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4443 SourceAction = SourceAction->getInputs()[0];
4444 }
4445
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004446 // Forward -g and handle debug info related flags, assuming we are dealing
4447 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004448 if (SourceAction->getType() == types::TY_Asm ||
4449 SourceAction->getType() == types::TY_PP_Asm) {
4450 Args.ClaimAllArgs(options::OPT_g_Group);
4451 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4452 if (!A->getOption().matches(options::OPT_g0))
4453 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004454
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004455 if (Args.hasArg(options::OPT_gdwarf_2))
4456 CmdArgs.push_back("-gdwarf-2");
4457 if (Args.hasArg(options::OPT_gdwarf_3))
4458 CmdArgs.push_back("-gdwarf-3");
4459 if (Args.hasArg(options::OPT_gdwarf_4))
4460 CmdArgs.push_back("-gdwarf-4");
4461
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004462 // Add the -fdebug-compilation-dir flag if needed.
4463 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004464
4465 // Set the AT_producer to the clang version when using the integrated
4466 // assembler on assembly source files.
4467 CmdArgs.push_back("-dwarf-debug-producer");
4468 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004469 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004470
4471 // Optionally embed the -cc1as level arguments into the debug info, for build
4472 // analysis.
4473 if (getToolChain().UseDwarfDebugFlags()) {
4474 ArgStringList OriginalArgs;
4475 for (ArgList::const_iterator it = Args.begin(),
4476 ie = Args.end(); it != ie; ++it)
4477 (*it)->render(Args, OriginalArgs);
4478
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004479 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004480 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4481 Flags += Exec;
4482 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4483 Flags += " ";
4484 Flags += OriginalArgs[i];
4485 }
4486 CmdArgs.push_back("-dwarf-debug-flags");
4487 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4488 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004489
4490 // FIXME: Add -static support, once we have it.
4491
David Blaikie372d9502014-01-17 03:17:40 +00004492 // Consume all the warning flags. Usually this would be handled more
4493 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4494 // doesn't handle that so rather than warning about unused flags that are
4495 // actually used, we'll lie by omission instead.
4496 // FIXME: Stop lying and consume only the appropriate driver flags
4497 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4498 ie = Args.filtered_end();
4499 it != ie; ++it)
4500 (*it)->claim();
4501
David Blaikie9260ed62013-07-25 21:19:01 +00004502 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4503 getToolChain().getDriver());
4504
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004505 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004506
4507 assert(Output.isFilename() && "Unexpected lipo output.");
4508 CmdArgs.push_back("-o");
4509 CmdArgs.push_back(Output.getFilename());
4510
Daniel Dunbarb440f562010-08-02 02:38:21 +00004511 assert(Input.isFilename() && "Invalid input.");
4512 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004513
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004514 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004515 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004516
4517 // Handle the debug info splitting at object creation time if we're
4518 // creating an object.
4519 // TODO: Currently only works on linux with newer objcopy.
4520 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004521 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004522 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4523 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004524}
4525
Daniel Dunbara3246a02009-03-18 08:07:30 +00004526void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004527 const InputInfo &Output,
4528 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004529 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004530 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004531 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004532 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004533
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004534 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004535 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004536 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004537 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004538 // Don't forward any -g arguments to assembly steps.
4539 if (isa<AssembleJobAction>(JA) &&
4540 A->getOption().matches(options::OPT_g_Group))
4541 continue;
4542
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004543 // Don't forward any -W arguments to assembly and link steps.
4544 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4545 A->getOption().matches(options::OPT_W_Group))
4546 continue;
4547
Daniel Dunbar2da02722009-03-19 07:55:12 +00004548 // It is unfortunate that we have to claim here, as this means
4549 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004550 // platforms using a generic gcc, even if we are just using gcc
4551 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004552 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004553 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004554 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004555 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004556
Daniel Dunbar4e295052010-01-25 22:35:08 +00004557 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004558
4559 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004560 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004561 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004562 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004563
4564 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004565 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004566 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004567 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004568 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004569 else if (Arch == llvm::Triple::ppc64le)
4570 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004571 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004572 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004573 }
4574
Daniel Dunbar5716d872009-05-02 21:41:52 +00004575 // Try to force gcc to match the tool chain we want, if we recognize
4576 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004577 //
4578 // FIXME: The triple class should directly provide the information we want
4579 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004580 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004581 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004582 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4583 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004584 CmdArgs.push_back("-m64");
4585
Daniel Dunbarb440f562010-08-02 02:38:21 +00004586 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004587 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004588 CmdArgs.push_back(Output.getFilename());
4589 } else {
4590 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004591 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004592 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004593
Tony Linthicum76329bf2011-12-12 21:14:55 +00004594 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4595 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004596
4597 // Only pass -x if gcc will understand it; otherwise hope gcc
4598 // understands the suffix correctly. The main use case this would go
4599 // wrong in is for linker inputs if they happened to have an odd
4600 // suffix; really the only way to get this to happen is a command
4601 // like '-x foobar a.c' which will treat a.c like a linker input.
4602 //
4603 // FIXME: For the linker case specifically, can we safely convert
4604 // inputs into '-Wl,' options?
4605 for (InputInfoList::const_iterator
4606 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4607 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004608
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004609 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004610 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4611 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004612 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004613 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004614 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004615 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004616 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004617 else if (II.getType() == types::TY_ModuleFile)
4618 D.Diag(diag::err_drv_no_module_support)
4619 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004620
Daniel Dunbara3246a02009-03-18 08:07:30 +00004621 if (types::canTypeBeUserSpecified(II.getType())) {
4622 CmdArgs.push_back("-x");
4623 CmdArgs.push_back(types::getTypeName(II.getType()));
4624 }
4625
Daniel Dunbarb440f562010-08-02 02:38:21 +00004626 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004627 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004628 else {
4629 const Arg &A = II.getInputArg();
4630
4631 // Reverse translate some rewritten options.
4632 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4633 CmdArgs.push_back("-lstdc++");
4634 continue;
4635 }
4636
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004637 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004638 A.render(Args, CmdArgs);
4639 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004640 }
4641
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004642 const std::string customGCCName = D.getCCCGenericGCCName();
4643 const char *GCCName;
4644 if (!customGCCName.empty())
4645 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004646 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004647 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004648 } else
4649 GCCName = "gcc";
4650
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004651 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004652 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004653 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004654}
4655
Daniel Dunbar4e295052010-01-25 22:35:08 +00004656void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4657 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004658 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004659}
4660
Daniel Dunbar4e295052010-01-25 22:35:08 +00004661void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4662 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004663 const Driver &D = getToolChain().getDriver();
4664
Daniel Dunbar4e295052010-01-25 22:35:08 +00004665 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004666 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4667 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004668 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004669 else {
4670 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004671 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004672 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004673
Daniel Dunbar4e295052010-01-25 22:35:08 +00004674 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004675 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004676}
4677
Daniel Dunbar4e295052010-01-25 22:35:08 +00004678void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4679 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004680 // The types are (hopefully) good enough.
4681}
4682
Tony Linthicum76329bf2011-12-12 21:14:55 +00004683// Hexagon tools start.
4684void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4685 ArgStringList &CmdArgs) const {
4686
4687}
4688void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4689 const InputInfo &Output,
4690 const InputInfoList &Inputs,
4691 const ArgList &Args,
4692 const char *LinkingOutput) const {
4693
4694 const Driver &D = getToolChain().getDriver();
4695 ArgStringList CmdArgs;
4696
4697 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004698 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004699 CmdArgs.push_back(Args.MakeArgString(MarchString));
4700
4701 RenderExtraToolArgs(JA, CmdArgs);
4702
4703 if (Output.isFilename()) {
4704 CmdArgs.push_back("-o");
4705 CmdArgs.push_back(Output.getFilename());
4706 } else {
4707 assert(Output.isNothing() && "Unexpected output");
4708 CmdArgs.push_back("-fsyntax-only");
4709 }
4710
Matthew Curtise8f80a12012-12-06 17:49:03 +00004711 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4712 if (!SmallDataThreshold.empty())
4713 CmdArgs.push_back(
4714 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004715
Matthew Curtise5df3812012-12-07 17:23:04 +00004716 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4717 options::OPT_Xassembler);
4718
Tony Linthicum76329bf2011-12-12 21:14:55 +00004719 // Only pass -x if gcc will understand it; otherwise hope gcc
4720 // understands the suffix correctly. The main use case this would go
4721 // wrong in is for linker inputs if they happened to have an odd
4722 // suffix; really the only way to get this to happen is a command
4723 // like '-x foobar a.c' which will treat a.c like a linker input.
4724 //
4725 // FIXME: For the linker case specifically, can we safely convert
4726 // inputs into '-Wl,' options?
4727 for (InputInfoList::const_iterator
4728 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4729 const InputInfo &II = *it;
4730
4731 // Don't try to pass LLVM or AST inputs to a generic gcc.
4732 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4733 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4734 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4735 << getToolChain().getTripleString();
4736 else if (II.getType() == types::TY_AST)
4737 D.Diag(clang::diag::err_drv_no_ast_support)
4738 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004739 else if (II.getType() == types::TY_ModuleFile)
4740 D.Diag(diag::err_drv_no_module_support)
4741 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004742
4743 if (II.isFilename())
4744 CmdArgs.push_back(II.getFilename());
4745 else
4746 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4747 II.getInputArg().render(Args, CmdArgs);
4748 }
4749
4750 const char *GCCName = "hexagon-as";
4751 const char *Exec =
4752 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4753 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4754
4755}
4756void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4757 ArgStringList &CmdArgs) const {
4758 // The types are (hopefully) good enough.
4759}
4760
4761void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4762 const InputInfo &Output,
4763 const InputInfoList &Inputs,
4764 const ArgList &Args,
4765 const char *LinkingOutput) const {
4766
Matthew Curtise689b052012-12-06 15:46:07 +00004767 const toolchains::Hexagon_TC& ToolChain =
4768 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4769 const Driver &D = ToolChain.getDriver();
4770
Tony Linthicum76329bf2011-12-12 21:14:55 +00004771 ArgStringList CmdArgs;
4772
Matthew Curtise689b052012-12-06 15:46:07 +00004773 //----------------------------------------------------------------------------
4774 //
4775 //----------------------------------------------------------------------------
4776 bool hasStaticArg = Args.hasArg(options::OPT_static);
4777 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004778 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004779 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4780 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4781 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4782 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004783
Matthew Curtise689b052012-12-06 15:46:07 +00004784 //----------------------------------------------------------------------------
4785 // Silence warnings for various options
4786 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004787
Matthew Curtise689b052012-12-06 15:46:07 +00004788 Args.ClaimAllArgs(options::OPT_g_Group);
4789 Args.ClaimAllArgs(options::OPT_emit_llvm);
4790 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4791 // handled somewhere else.
4792 Args.ClaimAllArgs(options::OPT_static_libgcc);
4793
4794 //----------------------------------------------------------------------------
4795 //
4796 //----------------------------------------------------------------------------
4797 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4798 e = ToolChain.ExtraOpts.end();
4799 i != e; ++i)
4800 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004801
Matthew Curtisf10a5952012-12-06 14:16:43 +00004802 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4803 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004804
Matthew Curtise689b052012-12-06 15:46:07 +00004805 if (buildingLib) {
4806 CmdArgs.push_back("-shared");
4807 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4808 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004809 }
4810
Matthew Curtise689b052012-12-06 15:46:07 +00004811 if (hasStaticArg)
4812 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004813
Matthew Curtise8f80a12012-12-06 17:49:03 +00004814 if (buildPIE && !buildingLib)
4815 CmdArgs.push_back("-pie");
4816
4817 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4818 if (!SmallDataThreshold.empty()) {
4819 CmdArgs.push_back(
4820 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4821 }
4822
Matthew Curtise689b052012-12-06 15:46:07 +00004823 //----------------------------------------------------------------------------
4824 //
4825 //----------------------------------------------------------------------------
4826 CmdArgs.push_back("-o");
4827 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004828
Matthew Curtise689b052012-12-06 15:46:07 +00004829 const std::string MarchSuffix = "/" + MarchString;
4830 const std::string G0Suffix = "/G0";
4831 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4832 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4833 + "/";
4834 const std::string StartFilesDir = RootDir
4835 + "hexagon/lib"
4836 + (buildingLib
4837 ? MarchG0Suffix : MarchSuffix);
4838
4839 //----------------------------------------------------------------------------
4840 // moslib
4841 //----------------------------------------------------------------------------
4842 std::vector<std::string> oslibs;
4843 bool hasStandalone= false;
4844
4845 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4846 ie = Args.filtered_end(); it != ie; ++it) {
4847 (*it)->claim();
4848 oslibs.push_back((*it)->getValue());
4849 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004850 }
Matthew Curtise689b052012-12-06 15:46:07 +00004851 if (oslibs.empty()) {
4852 oslibs.push_back("standalone");
4853 hasStandalone = true;
4854 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004855
Matthew Curtise689b052012-12-06 15:46:07 +00004856 //----------------------------------------------------------------------------
4857 // Start Files
4858 //----------------------------------------------------------------------------
4859 if (incStdLib && incStartFiles) {
4860
4861 if (!buildingLib) {
4862 if (hasStandalone) {
4863 CmdArgs.push_back(
4864 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4865 }
4866 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4867 }
4868 std::string initObj = useShared ? "/initS.o" : "/init.o";
4869 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4870 }
4871
4872 //----------------------------------------------------------------------------
4873 // Library Search Paths
4874 //----------------------------------------------------------------------------
4875 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4876 for (ToolChain::path_list::const_iterator
4877 i = LibPaths.begin(),
4878 e = LibPaths.end();
4879 i != e;
4880 ++i)
4881 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4882
4883 //----------------------------------------------------------------------------
4884 //
4885 //----------------------------------------------------------------------------
4886 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4887 Args.AddAllArgs(CmdArgs, options::OPT_e);
4888 Args.AddAllArgs(CmdArgs, options::OPT_s);
4889 Args.AddAllArgs(CmdArgs, options::OPT_t);
4890 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4891
4892 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4893
4894 //----------------------------------------------------------------------------
4895 // Libraries
4896 //----------------------------------------------------------------------------
4897 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004898 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004899 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4900 CmdArgs.push_back("-lm");
4901 }
4902
4903 CmdArgs.push_back("--start-group");
4904
4905 if (!buildingLib) {
4906 for(std::vector<std::string>::iterator i = oslibs.begin(),
4907 e = oslibs.end(); i != e; ++i)
4908 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4909 CmdArgs.push_back("-lc");
4910 }
4911 CmdArgs.push_back("-lgcc");
4912
4913 CmdArgs.push_back("--end-group");
4914 }
4915
4916 //----------------------------------------------------------------------------
4917 // End files
4918 //----------------------------------------------------------------------------
4919 if (incStdLib && incStartFiles) {
4920 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4921 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4922 }
4923
4924 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004925 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004926}
4927// Hexagon tools end.
4928
Bernard Ogden31561762013-12-12 13:27:11 +00004929/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4930//
4931// FIXME: tblgen this.
4932const char *arm::getARMCPUForMArch(const ArgList &Args,
4933 const llvm::Triple &Triple) {
4934 StringRef MArch;
4935 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4936 // Otherwise, if we have -march= choose the base CPU for that arch.
4937 MArch = A->getValue();
4938 } else {
4939 // Otherwise, use the Arch from the triple.
4940 MArch = Triple.getArchName();
4941 }
4942
4943 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004944 if (MArch == "native") {
4945 std::string CPU = llvm::sys::getHostCPUName();
4946 if (CPU != "generic") {
4947 // Translate the native cpu into the architecture. The switch below will
4948 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004949 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004950 }
4951 }
4952
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004953 switch (Triple.getOS()) {
4954 case llvm::Triple::NetBSD:
Bernard Ogden31561762013-12-12 13:27:11 +00004955 if (MArch == "armv6")
4956 return "arm1176jzf-s";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004957 break;
4958 case llvm::Triple::Win32:
4959 // FIXME: this is invalid for WindowsCE
4960 return "cortex-a9";
4961 default:
4962 break;
Bernard Ogden31561762013-12-12 13:27:11 +00004963 }
4964
Christian Pirker918d1092014-05-05 08:48:18 +00004965 const char *result = nullptr;
4966 size_t offset = StringRef::npos;
4967 if (MArch.startswith("arm"))
4968 offset = 3;
4969 if (MArch.startswith("thumb"))
4970 offset = 5;
4971 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
4972 offset += 2;
4973 if (offset != StringRef::npos)
4974 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
4975 .Cases("v2", "v2a", "arm2")
4976 .Case("v3", "arm6")
4977 .Case("v3m", "arm7m")
4978 .Case("v4", "strongarm")
4979 .Case("v4t", "arm7tdmi")
4980 .Cases("v5", "v5t", "arm10tdmi")
4981 .Cases("v5e", "v5te", "arm1022e")
4982 .Case("v5tej", "arm926ej-s")
4983 .Cases("v6", "v6k", "arm1136jf-s")
4984 .Case("v6j", "arm1136j-s")
4985 .Cases("v6z", "v6zk", "arm1176jzf-s")
4986 .Case("v6t2", "arm1156t2-s")
4987 .Cases("v6m", "v6-m", "cortex-m0")
4988 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
4989 .Cases("v7s", "v7-s", "swift")
4990 .Cases("v7r", "v7-r", "cortex-r4")
4991 .Cases("v7m", "v7-m", "cortex-m3")
4992 .Cases("v7em", "v7e-m", "cortex-m4")
4993 .Cases("v8", "v8a", "v8-a", "cortex-a53")
4994 .Default(nullptr);
4995 else
4996 result = llvm::StringSwitch<const char *>(MArch)
4997 .Case("ep9312", "ep9312")
4998 .Case("iwmmxt", "iwmmxt")
4999 .Case("xscale", "xscale")
5000 .Default(nullptr);
Bernard Ogden31561762013-12-12 13:27:11 +00005001
5002 if (result)
5003 return result;
5004
Christian Pirker918d1092014-05-05 08:48:18 +00005005 // If all else failed, return the most base CPU with thumb interworking
5006 // supported by LLVM.
5007 // FIXME: Should warn once that we're falling back.
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00005008 switch (Triple.getOS()) {
5009 case llvm::Triple::NetBSD:
5010 switch (Triple.getEnvironment()) {
5011 case llvm::Triple::GNUEABIHF:
5012 case llvm::Triple::GNUEABI:
5013 case llvm::Triple::EABIHF:
5014 case llvm::Triple::EABI:
5015 return "arm926ej-s";
5016 default:
5017 return "strongarm";
5018 }
5019 default:
5020 switch (Triple.getEnvironment()) {
5021 case llvm::Triple::EABIHF:
5022 case llvm::Triple::GNUEABIHF:
5023 return "arm1176jzf-s";
5024 default:
5025 return "arm7tdmi";
5026 }
5027 }
Bernard Ogden31561762013-12-12 13:27:11 +00005028}
5029
5030/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005031StringRef arm::getARMTargetCPU(const ArgList &Args,
5032 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005033 // FIXME: Warn on inconsistent use of -mcpu and -march.
5034 // If we have -mcpu=, use that.
5035 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5036 StringRef MCPU = A->getValue();
5037 // Handle -mcpu=native.
5038 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005039 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005040 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005041 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005042 }
5043
5044 return getARMCPUForMArch(Args, Triple);
5045}
5046
5047/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5048/// CPU.
5049//
5050// FIXME: This is redundant with -mcpu, why does LLVM use this.
5051// FIXME: tblgen this, or kill it!
5052const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5053 return llvm::StringSwitch<const char *>(CPU)
5054 .Case("strongarm", "v4")
5055 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5056 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5057 .Cases("arm920", "arm920t", "arm922t", "v4t")
5058 .Cases("arm940t", "ep9312","v4t")
5059 .Cases("arm10tdmi", "arm1020t", "v5")
5060 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5061 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5062 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5063 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5064 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5065 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005066 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005067 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5068 .Cases("cortex-r4", "cortex-r5", "v7r")
5069 .Case("cortex-m0", "v6m")
5070 .Case("cortex-m3", "v7m")
5071 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005072 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005073 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005074 .Cases("cortex-a53", "cortex-a57", "v8")
5075 .Default("");
5076}
5077
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005078bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5079 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5080 return A && (A->getValue() == StringRef(Value));
5081}
5082
Tim Northover157d9112014-01-16 08:48:16 +00005083llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005084 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5085 // archs which Darwin doesn't use.
5086
5087 // The matching this routine does is fairly pointless, since it is neither the
5088 // complete architecture list, nor a reasonable subset. The problem is that
5089 // historically the driver driver accepts this and also ties its -march=
5090 // handling to the architecture name, so we need to be careful before removing
5091 // support for it.
5092
5093 // This code must be kept in sync with Clang's Darwin specific argument
5094 // translation.
5095
5096 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5097 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5098 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5099 .Case("ppc64", llvm::Triple::ppc64)
5100 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5101 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5102 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005103 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005104 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005105 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005106 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005107 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005108 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005109 .Case("r600", llvm::Triple::r600)
5110 .Case("nvptx", llvm::Triple::nvptx)
5111 .Case("nvptx64", llvm::Triple::nvptx64)
5112 .Case("amdil", llvm::Triple::amdil)
5113 .Case("spir", llvm::Triple::spir)
5114 .Default(llvm::Triple::UnknownArch);
5115}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005116
Tim Northover157d9112014-01-16 08:48:16 +00005117void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5118 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5119 T.setArch(Arch);
5120
5121 if (Str == "x86_64h")
5122 T.setArchName(Str);
5123 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5124 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005125 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005126 }
5127}
5128
Bob Wilsondecc03e2012-11-23 06:14:39 +00005129const char *Clang::getBaseInputName(const ArgList &Args,
5130 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005131 return Args.MakeArgString(
5132 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005133}
5134
Bob Wilsondecc03e2012-11-23 06:14:39 +00005135const char *Clang::getBaseInputStem(const ArgList &Args,
5136 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005137 const char *Str = getBaseInputName(Args, Inputs);
5138
Chris Lattner906bb902011-01-16 08:14:11 +00005139 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005140 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005141
5142 return Str;
5143}
5144
Bob Wilsondecc03e2012-11-23 06:14:39 +00005145const char *Clang::getDependencyFileName(const ArgList &Args,
5146 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005147 // FIXME: Think about this more.
5148 std::string Res;
5149
5150 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005151 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005152 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005153 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005154 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005155 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005156 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005157}
5158
Daniel Dunbarbe220842009-03-20 16:06:39 +00005159void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005160 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005161 const InputInfoList &Inputs,
5162 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005163 const char *LinkingOutput) const {
5164 ArgStringList CmdArgs;
5165
5166 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5167 const InputInfo &Input = Inputs[0];
5168
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005169 // Determine the original source input.
5170 const Action *SourceAction = &JA;
5171 while (SourceAction->getKind() != Action::InputClass) {
5172 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5173 SourceAction = SourceAction->getInputs()[0];
5174 }
5175
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005176 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005177 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005178 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5179 // FIXME: at run-time detect assembler capabilities or rely on version
5180 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005181 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005182 const llvm::Triple &T(getToolChain().getTriple());
5183 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005184 CmdArgs.push_back("-Q");
5185 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005186
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005187 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005188 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005189 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005190 if (Args.hasArg(options::OPT_gstabs))
5191 CmdArgs.push_back("--gstabs");
5192 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005193 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005194 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005195
Daniel Dunbarbe220842009-03-20 16:06:39 +00005196 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005197 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005198
Daniel Dunbar6d484762010-07-22 01:47:22 +00005199 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005200 if (getToolChain().getArch() == llvm::Triple::x86 ||
5201 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005202 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5203 CmdArgs.push_back("-force_cpusubtype_ALL");
5204
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005205 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005206 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005207 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005208 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005209 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005210 CmdArgs.push_back("-static");
5211
Daniel Dunbarbe220842009-03-20 16:06:39 +00005212 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5213 options::OPT_Xassembler);
5214
5215 assert(Output.isFilename() && "Unexpected lipo output.");
5216 CmdArgs.push_back("-o");
5217 CmdArgs.push_back(Output.getFilename());
5218
Daniel Dunbarb440f562010-08-02 02:38:21 +00005219 assert(Input.isFilename() && "Invalid input.");
5220 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005221
5222 // asm_final spec is empty.
5223
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005224 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005225 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005226 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005227}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005228
Tim Northover157d9112014-01-16 08:48:16 +00005229void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005230
Tim Northover157d9112014-01-16 08:48:16 +00005231void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5232 ArgStringList &CmdArgs) const {
5233 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005234
Daniel Dunbarc1964212009-03-26 16:23:12 +00005235 // Derived from darwin_arch spec.
5236 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005237 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005238
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005239 // FIXME: Is this needed anymore?
5240 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005241 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005242}
5243
Bill Wendling3b2000f2012-10-02 18:02:50 +00005244bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5245 // We only need to generate a temp path for LTO if we aren't compiling object
5246 // files. When compiling source files, we run 'dsymutil' after linking. We
5247 // don't run 'dsymutil' when compiling object files.
5248 for (InputInfoList::const_iterator
5249 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5250 if (it->getType() != types::TY_Object)
5251 return true;
5252
5253 return false;
5254}
5255
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005256void darwin::Link::AddLinkArgs(Compilation &C,
5257 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005258 ArgStringList &CmdArgs,
5259 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005260 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005261 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005262
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005263 unsigned Version[3] = { 0, 0, 0 };
5264 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5265 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005266 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005267 Version[1], Version[2], HadExtra) ||
5268 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005269 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005270 << A->getAsString(Args);
5271 }
5272
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005273 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005274 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005275 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5276 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005277
Bob Wilson3d27dad2013-08-02 22:25:34 +00005278 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5279 CmdArgs.push_back("-export_dynamic");
5280
Bill Wendling313b6bf2012-11-16 23:03:00 +00005281 // If we are using LTO, then automatically create a temporary file path for
5282 // the linker to use, so that it's lifetime will extend past a possible
5283 // dsymutil step.
5284 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5285 const char *TmpPath = C.getArgs().MakeArgString(
5286 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5287 C.addTempFile(TmpPath);
5288 CmdArgs.push_back("-object_path_lto");
5289 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005290 }
5291
Daniel Dunbarc1964212009-03-26 16:23:12 +00005292 // Derived from the "link" spec.
5293 Args.AddAllArgs(CmdArgs, options::OPT_static);
5294 if (!Args.hasArg(options::OPT_static))
5295 CmdArgs.push_back("-dynamic");
5296 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5297 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5298 // here. How do we wish to handle such things?
5299 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005300
Daniel Dunbarc1964212009-03-26 16:23:12 +00005301 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005302 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005303 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005304 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005305
5306 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5307 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5308 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5309
5310 Arg *A;
5311 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5312 (A = Args.getLastArg(options::OPT_current__version)) ||
5313 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005314 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005315 << A->getAsString(Args) << "-dynamiclib";
5316
5317 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5318 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5319 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5320 } else {
5321 CmdArgs.push_back("-dylib");
5322
5323 Arg *A;
5324 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5325 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5326 (A = Args.getLastArg(options::OPT_client__name)) ||
5327 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5328 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5329 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005330 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005331 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005332
Daniel Dunbarc1964212009-03-26 16:23:12 +00005333 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5334 "-dylib_compatibility_version");
5335 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5336 "-dylib_current_version");
5337
Tim Northover157d9112014-01-16 08:48:16 +00005338 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005339
5340 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5341 "-dylib_install_name");
5342 }
5343
5344 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5345 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5346 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005347 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005348 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005349 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5350 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5351 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5352 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5353 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5354 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005355 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005356 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5357 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5358 Args.AddAllArgs(CmdArgs, options::OPT_init);
5359
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005360 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005361 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005362
Daniel Dunbarc1964212009-03-26 16:23:12 +00005363 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5364 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5365 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5366 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5367 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005368
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005369 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5370 options::OPT_fno_pie,
5371 options::OPT_fno_PIE)) {
5372 if (A->getOption().matches(options::OPT_fpie) ||
5373 A->getOption().matches(options::OPT_fPIE))
5374 CmdArgs.push_back("-pie");
5375 else
5376 CmdArgs.push_back("-no_pie");
5377 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005378
5379 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5380 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5381 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5382 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5383 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5384 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5385 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5386 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5387 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5388 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5389 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5390 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5391 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5392 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5393 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5394 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005395
Daniel Dunbar84384642011-05-02 21:03:47 +00005396 // Give --sysroot= preference, over the Apple specific behavior to also use
5397 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005398 StringRef sysroot = C.getSysRoot();
5399 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005400 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005401 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005402 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5403 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005404 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005405 }
5406
Daniel Dunbarc1964212009-03-26 16:23:12 +00005407 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5408 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5409 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5410 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5411 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005412 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005413 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5414 Args.AddAllArgs(CmdArgs, options::OPT_y);
5415 Args.AddLastArg(CmdArgs, options::OPT_w);
5416 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5417 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5418 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5419 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5420 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5421 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5422 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5423 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5424 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5425 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5426 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5427 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5428}
5429
Alexey Bataev186b28a2014-03-06 05:43:53 +00005430enum LibOpenMP {
5431 LibUnknown,
5432 LibGOMP,
5433 LibIOMP5
5434};
5435
Daniel Dunbarc1964212009-03-26 16:23:12 +00005436void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005437 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005438 const InputInfoList &Inputs,
5439 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005440 const char *LinkingOutput) const {
5441 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005442
Daniel Dunbarc1964212009-03-26 16:23:12 +00005443 // The logic here is derived from gcc's behavior; most of which
5444 // comes from specs (starting with link_command). Consult gcc for
5445 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005446 ArgStringList CmdArgs;
5447
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005448 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5449 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5450 options::OPT_ccc_arcmt_migrate)) {
5451 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5452 (*I)->claim();
5453 const char *Exec =
5454 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5455 CmdArgs.push_back(Output.getFilename());
5456 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5457 return;
5458 }
5459
Daniel Dunbarc1964212009-03-26 16:23:12 +00005460 // I'm not sure why this particular decomposition exists in gcc, but
5461 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005462 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005463
Daniel Dunbarc1964212009-03-26 16:23:12 +00005464 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5465 Args.AddAllArgs(CmdArgs, options::OPT_s);
5466 Args.AddAllArgs(CmdArgs, options::OPT_t);
5467 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5468 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005469 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005470 Args.AddAllArgs(CmdArgs, options::OPT_r);
5471
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005472 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5473 // members of static archive libraries which implement Objective-C classes or
5474 // categories.
5475 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5476 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005477
Daniel Dunbarc1964212009-03-26 16:23:12 +00005478 CmdArgs.push_back("-o");
5479 CmdArgs.push_back(Output.getFilename());
5480
Chad Rosier06fd3c62012-05-16 23:45:12 +00005481 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005482 !Args.hasArg(options::OPT_nostartfiles))
5483 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005484
5485 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005486
Alexey Bataev186b28a2014-03-06 05:43:53 +00005487 LibOpenMP UsedOpenMPLib = LibUnknown;
5488 if (Args.hasArg(options::OPT_fopenmp)) {
5489 UsedOpenMPLib = LibGOMP;
5490 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5491 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5492 .Case("libgomp", LibGOMP)
5493 .Case("libiomp5", LibIOMP5)
5494 .Default(LibUnknown);
5495 if (UsedOpenMPLib == LibUnknown)
5496 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5497 << A->getOption().getName() << A->getValue();
5498 }
5499 switch (UsedOpenMPLib) {
5500 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005501 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005502 break;
5503 case LibIOMP5:
5504 CmdArgs.push_back("-liomp5");
5505 break;
5506 case LibUnknown:
5507 break;
5508 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005509
Douglas Gregor9295df02012-05-15 21:00:27 +00005510 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5511
Bob Wilson16d93952012-05-15 18:57:39 +00005512 if (isObjCRuntimeLinked(Args) &&
5513 !Args.hasArg(options::OPT_nostdlib) &&
5514 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005515 // We use arclite library for both ARC and subscripting support.
5516 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5517
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005518 CmdArgs.push_back("-framework");
5519 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005520 // Link libobj.
5521 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005522 }
John McCall31168b02011-06-15 23:02:42 +00005523
Daniel Dunbarc1964212009-03-26 16:23:12 +00005524 if (LinkingOutput) {
5525 CmdArgs.push_back("-arch_multiple");
5526 CmdArgs.push_back("-final_output");
5527 CmdArgs.push_back(LinkingOutput);
5528 }
5529
Daniel Dunbarc1964212009-03-26 16:23:12 +00005530 if (Args.hasArg(options::OPT_fnested_functions))
5531 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005532
Daniel Dunbarc1964212009-03-26 16:23:12 +00005533 if (!Args.hasArg(options::OPT_nostdlib) &&
5534 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005535 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005536 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005537
Daniel Dunbarc1964212009-03-26 16:23:12 +00005538 // link_ssp spec is empty.
5539
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005540 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005541 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005542 }
5543
Chad Rosier06fd3c62012-05-16 23:45:12 +00005544 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005545 !Args.hasArg(options::OPT_nostartfiles)) {
5546 // endfile_spec is empty.
5547 }
5548
5549 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5550 Args.AddAllArgs(CmdArgs, options::OPT_F);
5551
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005552 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005553 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005554 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005555}
5556
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005557void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005558 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005559 const InputInfoList &Inputs,
5560 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005561 const char *LinkingOutput) const {
5562 ArgStringList CmdArgs;
5563
5564 CmdArgs.push_back("-create");
5565 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005566
5567 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005568 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005569
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005570 for (InputInfoList::const_iterator
5571 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5572 const InputInfo &II = *it;
5573 assert(II.isFilename() && "Unexpected lipo input.");
5574 CmdArgs.push_back(II.getFilename());
5575 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005576 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005577 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005578 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005579}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005580
Daniel Dunbar88299622010-06-04 18:28:36 +00005581void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005582 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005583 const InputInfoList &Inputs,
5584 const ArgList &Args,
5585 const char *LinkingOutput) const {
5586 ArgStringList CmdArgs;
5587
Daniel Dunbareb86b042011-05-09 17:23:16 +00005588 CmdArgs.push_back("-o");
5589 CmdArgs.push_back(Output.getFilename());
5590
Daniel Dunbar88299622010-06-04 18:28:36 +00005591 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5592 const InputInfo &Input = Inputs[0];
5593 assert(Input.isFilename() && "Unexpected dsymutil input.");
5594 CmdArgs.push_back(Input.getFilename());
5595
Daniel Dunbar88299622010-06-04 18:28:36 +00005596 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005597 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005598 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005599}
5600
Eric Christopher551ef452011-08-23 17:56:55 +00005601void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005602 const InputInfo &Output,
5603 const InputInfoList &Inputs,
5604 const ArgList &Args,
5605 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005606 ArgStringList CmdArgs;
5607 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005608 CmdArgs.push_back("--debug-info");
5609 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005610 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005611
5612 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5613 const InputInfo &Input = Inputs[0];
5614 assert(Input.isFilename() && "Unexpected verify input");
5615
5616 // Grabbing the output of the earlier dsymutil run.
5617 CmdArgs.push_back(Input.getFilename());
5618
5619 const char *Exec =
5620 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5621 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5622}
5623
David Chisnallf571cde2012-02-15 13:39:01 +00005624void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5625 const InputInfo &Output,
5626 const InputInfoList &Inputs,
5627 const ArgList &Args,
5628 const char *LinkingOutput) const {
5629 ArgStringList CmdArgs;
5630
5631 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5632 options::OPT_Xassembler);
5633
5634 CmdArgs.push_back("-o");
5635 CmdArgs.push_back(Output.getFilename());
5636
5637 for (InputInfoList::const_iterator
5638 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5639 const InputInfo &II = *it;
5640 CmdArgs.push_back(II.getFilename());
5641 }
5642
5643 const char *Exec =
5644 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5645 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5646}
5647
5648
5649void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5650 const InputInfo &Output,
5651 const InputInfoList &Inputs,
5652 const ArgList &Args,
5653 const char *LinkingOutput) const {
5654 // FIXME: Find a real GCC, don't hard-code versions here
5655 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5656 const llvm::Triple &T = getToolChain().getTriple();
5657 std::string LibPath = "/usr/lib/";
5658 llvm::Triple::ArchType Arch = T.getArch();
5659 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005660 case llvm::Triple::x86:
5661 GCCLibPath +=
5662 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5663 break;
5664 case llvm::Triple::x86_64:
5665 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5666 GCCLibPath += "/4.5.2/amd64/";
5667 LibPath += "amd64/";
5668 break;
5669 default:
5670 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005671 }
5672
5673 ArgStringList CmdArgs;
5674
David Chisnall272a0712012-02-29 15:06:12 +00005675 // Demangle C++ names in errors
5676 CmdArgs.push_back("-C");
5677
David Chisnallf571cde2012-02-15 13:39:01 +00005678 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5679 (!Args.hasArg(options::OPT_shared))) {
5680 CmdArgs.push_back("-e");
5681 CmdArgs.push_back("_start");
5682 }
5683
5684 if (Args.hasArg(options::OPT_static)) {
5685 CmdArgs.push_back("-Bstatic");
5686 CmdArgs.push_back("-dn");
5687 } else {
5688 CmdArgs.push_back("-Bdynamic");
5689 if (Args.hasArg(options::OPT_shared)) {
5690 CmdArgs.push_back("-shared");
5691 } else {
5692 CmdArgs.push_back("--dynamic-linker");
5693 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5694 }
5695 }
5696
5697 if (Output.isFilename()) {
5698 CmdArgs.push_back("-o");
5699 CmdArgs.push_back(Output.getFilename());
5700 } else {
5701 assert(Output.isNothing() && "Invalid output.");
5702 }
5703
5704 if (!Args.hasArg(options::OPT_nostdlib) &&
5705 !Args.hasArg(options::OPT_nostartfiles)) {
5706 if (!Args.hasArg(options::OPT_shared)) {
5707 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5708 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005709 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005710 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5711 } else {
5712 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005713 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5714 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005715 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005716 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005717 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005718 }
5719
5720 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5721
5722 Args.AddAllArgs(CmdArgs, options::OPT_L);
5723 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5724 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005725 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005726
5727 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5728
5729 if (!Args.hasArg(options::OPT_nostdlib) &&
5730 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005731 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005732 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005733 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005734 if (!Args.hasArg(options::OPT_shared)) {
5735 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005736 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005737 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005738 }
David Chisnallf571cde2012-02-15 13:39:01 +00005739 }
5740
5741 if (!Args.hasArg(options::OPT_nostdlib) &&
5742 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005743 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005744 }
David Chisnall96de9932012-02-16 16:00:47 +00005745 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005746
Alexey Samsonov7811d192014-02-20 13:57:37 +00005747 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005748
5749 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005750 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005751 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5752}
5753
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005754void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005755 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005756 const InputInfoList &Inputs,
5757 const ArgList &Args,
5758 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005759 ArgStringList CmdArgs;
5760
5761 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5762 options::OPT_Xassembler);
5763
5764 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005765 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005766
5767 for (InputInfoList::const_iterator
5768 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5769 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005770 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005771 }
5772
5773 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005774 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005775 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005776}
5777
5778void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005779 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005780 const InputInfoList &Inputs,
5781 const ArgList &Args,
5782 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005783 ArgStringList CmdArgs;
5784
5785 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005786 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005787 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005788 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005789 }
5790
5791 if (Args.hasArg(options::OPT_static)) {
5792 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005793 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005794 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005795// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005796 CmdArgs.push_back("-Bdynamic");
5797 if (Args.hasArg(options::OPT_shared)) {
5798 CmdArgs.push_back("-shared");
5799 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005800 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005801 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5802 }
5803 }
5804
Daniel Dunbarb440f562010-08-02 02:38:21 +00005805 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005806 CmdArgs.push_back("-o");
5807 CmdArgs.push_back(Output.getFilename());
5808 } else {
5809 assert(Output.isNothing() && "Invalid output.");
5810 }
5811
5812 if (!Args.hasArg(options::OPT_nostdlib) &&
5813 !Args.hasArg(options::OPT_nostartfiles)) {
5814 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005815 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005816 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005817 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005818 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005819 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005820 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005821 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005822 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005823 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005824 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005825 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005826 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005827 }
5828
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005829 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5830 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005831 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005832
5833 Args.AddAllArgs(CmdArgs, options::OPT_L);
5834 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5835 Args.AddAllArgs(CmdArgs, options::OPT_e);
5836
Daniel Dunbar54423b22010-09-17 00:24:54 +00005837 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005838
5839 if (!Args.hasArg(options::OPT_nostdlib) &&
5840 !Args.hasArg(options::OPT_nodefaultlibs)) {
5841 // FIXME: For some reason GCC passes -lgcc before adding
5842 // the default system libraries. Just mimic this for now.
5843 CmdArgs.push_back("-lgcc");
5844
5845 if (Args.hasArg(options::OPT_pthread))
5846 CmdArgs.push_back("-pthread");
5847 if (!Args.hasArg(options::OPT_shared))
5848 CmdArgs.push_back("-lc");
5849 CmdArgs.push_back("-lgcc");
5850 }
5851
5852 if (!Args.hasArg(options::OPT_nostdlib) &&
5853 !Args.hasArg(options::OPT_nostartfiles)) {
5854 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005855 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005856 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005857 }
5858
Alexey Samsonov7811d192014-02-20 13:57:37 +00005859 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005860
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005861 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005862 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005863 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005864}
5865
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005866void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005867 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005868 const InputInfoList &Inputs,
5869 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005870 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005871 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005872 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005873
Rafael Espindolacc126272014-02-28 01:55:21 +00005874 switch (getToolChain().getArch()) {
5875 case llvm::Triple::x86:
5876 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5877 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005878 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005879 break;
5880
5881 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005882 CmdArgs.push_back("-mppc");
5883 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005884 break;
5885
5886 case llvm::Triple::sparc:
5887 CmdArgs.push_back("-32");
5888 NeedsKPIC = true;
5889 break;
5890
5891 case llvm::Triple::sparcv9:
5892 CmdArgs.push_back("-64");
5893 CmdArgs.push_back("-Av9a");
5894 NeedsKPIC = true;
5895 break;
5896
5897 case llvm::Triple::mips64:
5898 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005899 StringRef CPUName;
5900 StringRef ABIName;
5901 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5902
5903 CmdArgs.push_back("-mabi");
5904 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5905
5906 if (getToolChain().getArch() == llvm::Triple::mips64)
5907 CmdArgs.push_back("-EB");
5908 else
5909 CmdArgs.push_back("-EL");
5910
Rafael Espindolacc126272014-02-28 01:55:21 +00005911 NeedsKPIC = true;
5912 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005913 }
5914
Rafael Espindolacc126272014-02-28 01:55:21 +00005915 default:
5916 break;
5917 }
5918
5919 if (NeedsKPIC)
5920 addAssemblerKPIC(Args, CmdArgs);
5921
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005922 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5923 options::OPT_Xassembler);
5924
5925 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005926 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005927
5928 for (InputInfoList::const_iterator
5929 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5930 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005931 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005932 }
5933
5934 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005935 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005936 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005937}
5938
5939void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005940 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005941 const InputInfoList &Inputs,
5942 const ArgList &Args,
5943 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005944 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005945 ArgStringList CmdArgs;
5946
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005947 // Silence warning for "clang -g foo.o -o foo"
5948 Args.ClaimAllArgs(options::OPT_g_Group);
5949 // and "clang -emit-llvm foo.o -o foo"
5950 Args.ClaimAllArgs(options::OPT_emit_llvm);
5951 // and for "clang -w foo.o -o foo". Other warning options are already
5952 // handled somewhere else.
5953 Args.ClaimAllArgs(options::OPT_w);
5954
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005955 if (getToolChain().getArch() == llvm::Triple::mips64)
5956 CmdArgs.push_back("-EB");
5957 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5958 CmdArgs.push_back("-EL");
5959
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005960 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005961 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005962 CmdArgs.push_back("-e");
5963 CmdArgs.push_back("__start");
5964 }
5965
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005966 if (Args.hasArg(options::OPT_static)) {
5967 CmdArgs.push_back("-Bstatic");
5968 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005969 if (Args.hasArg(options::OPT_rdynamic))
5970 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005971 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005972 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005973 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005974 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005975 } else {
5976 CmdArgs.push_back("-dynamic-linker");
5977 CmdArgs.push_back("/usr/libexec/ld.so");
5978 }
5979 }
5980
Rafael Espindola044f7832013-06-05 04:28:55 +00005981 if (Args.hasArg(options::OPT_nopie))
5982 CmdArgs.push_back("-nopie");
5983
Daniel Dunbarb440f562010-08-02 02:38:21 +00005984 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005985 CmdArgs.push_back("-o");
5986 CmdArgs.push_back(Output.getFilename());
5987 } else {
5988 assert(Output.isNothing() && "Invalid output.");
5989 }
5990
5991 if (!Args.hasArg(options::OPT_nostdlib) &&
5992 !Args.hasArg(options::OPT_nostartfiles)) {
5993 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00005994 if (Args.hasArg(options::OPT_pg))
5995 CmdArgs.push_back(Args.MakeArgString(
5996 getToolChain().GetFilePath("gcrt0.o")));
5997 else
5998 CmdArgs.push_back(Args.MakeArgString(
5999 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006000 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006001 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006002 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006003 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006004 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006005 }
6006 }
6007
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006008 std::string Triple = getToolChain().getTripleString();
6009 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006010 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006011 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006012 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006013
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006014 Args.AddAllArgs(CmdArgs, options::OPT_L);
6015 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6016 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006017 Args.AddAllArgs(CmdArgs, options::OPT_s);
6018 Args.AddAllArgs(CmdArgs, options::OPT_t);
6019 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6020 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006021
Daniel Dunbar54423b22010-09-17 00:24:54 +00006022 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006023
6024 if (!Args.hasArg(options::OPT_nostdlib) &&
6025 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006026 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006027 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006028 if (Args.hasArg(options::OPT_pg))
6029 CmdArgs.push_back("-lm_p");
6030 else
6031 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006032 }
6033
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006034 // FIXME: For some reason GCC passes -lgcc before adding
6035 // the default system libraries. Just mimic this for now.
6036 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006037
Eric Christopher17674ec2012-09-13 06:32:34 +00006038 if (Args.hasArg(options::OPT_pthread)) {
6039 if (!Args.hasArg(options::OPT_shared) &&
6040 Args.hasArg(options::OPT_pg))
6041 CmdArgs.push_back("-lpthread_p");
6042 else
6043 CmdArgs.push_back("-lpthread");
6044 }
6045
Chandler Carruth45661652011-12-17 22:32:42 +00006046 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006047 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006048 CmdArgs.push_back("-lc_p");
6049 else
6050 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006051 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006052
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006053 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006054 }
6055
6056 if (!Args.hasArg(options::OPT_nostdlib) &&
6057 !Args.hasArg(options::OPT_nostartfiles)) {
6058 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006059 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006060 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006061 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006062 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006063 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006064 }
6065
6066 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006067 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006068 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006069}
Ed Schoutene33194b2009-04-02 19:13:12 +00006070
Eli Friedman9fa28852012-08-08 23:57:20 +00006071void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6072 const InputInfo &Output,
6073 const InputInfoList &Inputs,
6074 const ArgList &Args,
6075 const char *LinkingOutput) const {
6076 ArgStringList CmdArgs;
6077
6078 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6079 options::OPT_Xassembler);
6080
6081 CmdArgs.push_back("-o");
6082 CmdArgs.push_back(Output.getFilename());
6083
6084 for (InputInfoList::const_iterator
6085 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6086 const InputInfo &II = *it;
6087 CmdArgs.push_back(II.getFilename());
6088 }
6089
6090 const char *Exec =
6091 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6092 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6093}
6094
6095void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6096 const InputInfo &Output,
6097 const InputInfoList &Inputs,
6098 const ArgList &Args,
6099 const char *LinkingOutput) const {
6100 const Driver &D = getToolChain().getDriver();
6101 ArgStringList CmdArgs;
6102
6103 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6104 (!Args.hasArg(options::OPT_shared))) {
6105 CmdArgs.push_back("-e");
6106 CmdArgs.push_back("__start");
6107 }
6108
6109 if (Args.hasArg(options::OPT_static)) {
6110 CmdArgs.push_back("-Bstatic");
6111 } else {
6112 if (Args.hasArg(options::OPT_rdynamic))
6113 CmdArgs.push_back("-export-dynamic");
6114 CmdArgs.push_back("--eh-frame-hdr");
6115 CmdArgs.push_back("-Bdynamic");
6116 if (Args.hasArg(options::OPT_shared)) {
6117 CmdArgs.push_back("-shared");
6118 } else {
6119 CmdArgs.push_back("-dynamic-linker");
6120 CmdArgs.push_back("/usr/libexec/ld.so");
6121 }
6122 }
6123
6124 if (Output.isFilename()) {
6125 CmdArgs.push_back("-o");
6126 CmdArgs.push_back(Output.getFilename());
6127 } else {
6128 assert(Output.isNothing() && "Invalid output.");
6129 }
6130
6131 if (!Args.hasArg(options::OPT_nostdlib) &&
6132 !Args.hasArg(options::OPT_nostartfiles)) {
6133 if (!Args.hasArg(options::OPT_shared)) {
6134 if (Args.hasArg(options::OPT_pg))
6135 CmdArgs.push_back(Args.MakeArgString(
6136 getToolChain().GetFilePath("gcrt0.o")));
6137 else
6138 CmdArgs.push_back(Args.MakeArgString(
6139 getToolChain().GetFilePath("crt0.o")));
6140 CmdArgs.push_back(Args.MakeArgString(
6141 getToolChain().GetFilePath("crtbegin.o")));
6142 } else {
6143 CmdArgs.push_back(Args.MakeArgString(
6144 getToolChain().GetFilePath("crtbeginS.o")));
6145 }
6146 }
6147
6148 Args.AddAllArgs(CmdArgs, options::OPT_L);
6149 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6150 Args.AddAllArgs(CmdArgs, options::OPT_e);
6151
6152 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6153
6154 if (!Args.hasArg(options::OPT_nostdlib) &&
6155 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006156 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006157 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6158 if (Args.hasArg(options::OPT_pg))
6159 CmdArgs.push_back("-lm_p");
6160 else
6161 CmdArgs.push_back("-lm");
6162 }
6163
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006164 if (Args.hasArg(options::OPT_pthread)) {
6165 if (!Args.hasArg(options::OPT_shared) &&
6166 Args.hasArg(options::OPT_pg))
6167 CmdArgs.push_back("-lpthread_p");
6168 else
6169 CmdArgs.push_back("-lpthread");
6170 }
6171
Eli Friedman9fa28852012-08-08 23:57:20 +00006172 if (!Args.hasArg(options::OPT_shared)) {
6173 if (Args.hasArg(options::OPT_pg))
6174 CmdArgs.push_back("-lc_p");
6175 else
6176 CmdArgs.push_back("-lc");
6177 }
6178
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006179 StringRef MyArch;
6180 switch (getToolChain().getTriple().getArch()) {
6181 case llvm::Triple::arm:
6182 MyArch = "arm";
6183 break;
6184 case llvm::Triple::x86:
6185 MyArch = "i386";
6186 break;
6187 case llvm::Triple::x86_64:
6188 MyArch = "amd64";
6189 break;
6190 default:
6191 llvm_unreachable("Unsupported architecture");
6192 }
6193 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006194 }
6195
6196 if (!Args.hasArg(options::OPT_nostdlib) &&
6197 !Args.hasArg(options::OPT_nostartfiles)) {
6198 if (!Args.hasArg(options::OPT_shared))
6199 CmdArgs.push_back(Args.MakeArgString(
6200 getToolChain().GetFilePath("crtend.o")));
6201 else
6202 CmdArgs.push_back(Args.MakeArgString(
6203 getToolChain().GetFilePath("crtendS.o")));
6204 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006205
6206 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006207 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006208 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006209}
6210
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006211void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006212 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006213 const InputInfoList &Inputs,
6214 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006215 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006216 ArgStringList CmdArgs;
6217
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006218 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6219 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006220 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006221 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006222 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006223 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006224 else if (getToolChain().getArch() == llvm::Triple::mips ||
6225 getToolChain().getArch() == llvm::Triple::mipsel ||
6226 getToolChain().getArch() == llvm::Triple::mips64 ||
6227 getToolChain().getArch() == llvm::Triple::mips64el) {
6228 StringRef CPUName;
6229 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006230 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006231
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006232 CmdArgs.push_back("-march");
6233 CmdArgs.push_back(CPUName.data());
6234
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006235 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006236 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006237
6238 if (getToolChain().getArch() == llvm::Triple::mips ||
6239 getToolChain().getArch() == llvm::Triple::mips64)
6240 CmdArgs.push_back("-EB");
6241 else
6242 CmdArgs.push_back("-EL");
6243
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006244 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006245 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006246 getToolChain().getArch() == llvm::Triple::armeb ||
6247 getToolChain().getArch() == llvm::Triple::thumb ||
6248 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006249 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006250 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006251 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6252
6253 if (FloatABI == "hard") {
6254 CmdArgs.push_back("-mfpu=vfp");
6255 } else {
6256 CmdArgs.push_back("-mfpu=softvfp");
6257 }
6258
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006259 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006260 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006261 case llvm::Triple::GNUEABI:
6262 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006263 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006264 break;
6265
6266 default:
6267 CmdArgs.push_back("-matpcs");
6268 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006269 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006270 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006271 if (getToolChain().getArch() == llvm::Triple::sparc)
6272 CmdArgs.push_back("-Av8plusa");
6273 else
6274 CmdArgs.push_back("-Av9a");
6275
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006276 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006277 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006278
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006279 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6280 options::OPT_Xassembler);
6281
6282 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006283 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006284
6285 for (InputInfoList::const_iterator
6286 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6287 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006288 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006289 }
6290
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006291 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006292 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006293 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006294}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006295
6296void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006297 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006298 const InputInfoList &Inputs,
6299 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006300 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006301 const toolchains::FreeBSD& ToolChain =
6302 static_cast<const toolchains::FreeBSD&>(getToolChain());
6303 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006304 const bool IsPIE =
6305 !Args.hasArg(options::OPT_shared) &&
6306 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006307 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006308
6309 // Silence warning for "clang -g foo.o -o foo"
6310 Args.ClaimAllArgs(options::OPT_g_Group);
6311 // and "clang -emit-llvm foo.o -o foo"
6312 Args.ClaimAllArgs(options::OPT_emit_llvm);
6313 // and for "clang -w foo.o -o foo". Other warning options are already
6314 // handled somewhere else.
6315 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006316
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006317 if (!D.SysRoot.empty())
6318 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6319
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006320 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006321 CmdArgs.push_back("-pie");
6322
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006323 if (Args.hasArg(options::OPT_static)) {
6324 CmdArgs.push_back("-Bstatic");
6325 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006326 if (Args.hasArg(options::OPT_rdynamic))
6327 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006328 CmdArgs.push_back("--eh-frame-hdr");
6329 if (Args.hasArg(options::OPT_shared)) {
6330 CmdArgs.push_back("-Bshareable");
6331 } else {
6332 CmdArgs.push_back("-dynamic-linker");
6333 CmdArgs.push_back("/libexec/ld-elf.so.1");
6334 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006335 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6336 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006337 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6338 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6339 CmdArgs.push_back("--hash-style=both");
6340 }
6341 }
6342 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006343 }
6344
6345 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6346 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006347 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006348 CmdArgs.push_back("-m");
6349 CmdArgs.push_back("elf_i386_fbsd");
6350 }
6351
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006352 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006353 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006354 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006355 }
6356
Daniel Dunbarb440f562010-08-02 02:38:21 +00006357 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006358 CmdArgs.push_back("-o");
6359 CmdArgs.push_back(Output.getFilename());
6360 } else {
6361 assert(Output.isNothing() && "Invalid output.");
6362 }
6363
6364 if (!Args.hasArg(options::OPT_nostdlib) &&
6365 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006366 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006367 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006368 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006369 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006370 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006371 crt1 = "Scrt1.o";
6372 else
6373 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006374 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006375 if (crt1)
6376 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6377
6378 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6379
Craig Topper92fc2df2014-05-17 16:56:41 +00006380 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006381 if (Args.hasArg(options::OPT_static))
6382 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006383 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006384 crtbegin = "crtbeginS.o";
6385 else
6386 crtbegin = "crtbegin.o";
6387
6388 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006389 }
6390
6391 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006392 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006393 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6394 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006395 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006396 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6397 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006398 Args.AddAllArgs(CmdArgs, options::OPT_s);
6399 Args.AddAllArgs(CmdArgs, options::OPT_t);
6400 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6401 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006402
Alp Tokerce365ca2013-12-02 12:43:03 +00006403 if (D.IsUsingLTO(Args))
6404 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006405
Roman Divackyafe2f232012-08-28 15:09:03 +00006406 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006407
6408 if (!Args.hasArg(options::OPT_nostdlib) &&
6409 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006410 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006411 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006412 if (Args.hasArg(options::OPT_pg))
6413 CmdArgs.push_back("-lm_p");
6414 else
6415 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006416 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006417 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6418 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006419 if (Args.hasArg(options::OPT_pg))
6420 CmdArgs.push_back("-lgcc_p");
6421 else
6422 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006423 if (Args.hasArg(options::OPT_static)) {
6424 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006425 } else if (Args.hasArg(options::OPT_pg)) {
6426 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006427 } else {
6428 CmdArgs.push_back("--as-needed");
6429 CmdArgs.push_back("-lgcc_s");
6430 CmdArgs.push_back("--no-as-needed");
6431 }
6432
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006433 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006434 if (Args.hasArg(options::OPT_pg))
6435 CmdArgs.push_back("-lpthread_p");
6436 else
6437 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006438 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006439
Roman Divacky66f22762011-02-10 16:59:40 +00006440 if (Args.hasArg(options::OPT_pg)) {
6441 if (Args.hasArg(options::OPT_shared))
6442 CmdArgs.push_back("-lc");
6443 else
6444 CmdArgs.push_back("-lc_p");
6445 CmdArgs.push_back("-lgcc_p");
6446 } else {
6447 CmdArgs.push_back("-lc");
6448 CmdArgs.push_back("-lgcc");
6449 }
6450
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006451 if (Args.hasArg(options::OPT_static)) {
6452 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006453 } else if (Args.hasArg(options::OPT_pg)) {
6454 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006455 } else {
6456 CmdArgs.push_back("--as-needed");
6457 CmdArgs.push_back("-lgcc_s");
6458 CmdArgs.push_back("--no-as-needed");
6459 }
6460 }
6461
6462 if (!Args.hasArg(options::OPT_nostdlib) &&
6463 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006464 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006465 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006466 else
6467 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006468 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006469 }
6470
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006471 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6472
Alexey Samsonov7811d192014-02-20 13:57:37 +00006473 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006474
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006475 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006476 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006477 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006478}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006479
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006480void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6481 const InputInfo &Output,
6482 const InputInfoList &Inputs,
6483 const ArgList &Args,
6484 const char *LinkingOutput) const {
6485 ArgStringList CmdArgs;
6486
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006487 // GNU as needs different flags for creating the correct output format
6488 // on architectures with different ABIs or optional feature sets.
6489 switch (getToolChain().getArch()) {
6490 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006491 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006492 break;
6493 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006494 case llvm::Triple::armeb:
6495 case llvm::Triple::thumb:
6496 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006497 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006498 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006499 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006500 }
6501
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006502 case llvm::Triple::mips:
6503 case llvm::Triple::mipsel:
6504 case llvm::Triple::mips64:
6505 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006506 StringRef CPUName;
6507 StringRef ABIName;
6508 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6509
6510 CmdArgs.push_back("-march");
6511 CmdArgs.push_back(CPUName.data());
6512
6513 CmdArgs.push_back("-mabi");
6514 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6515
6516 if (getToolChain().getArch() == llvm::Triple::mips ||
6517 getToolChain().getArch() == llvm::Triple::mips64)
6518 CmdArgs.push_back("-EB");
6519 else
6520 CmdArgs.push_back("-EL");
6521
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006522 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006523 break;
6524 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006525
6526 case llvm::Triple::sparc:
6527 CmdArgs.push_back("-32");
6528 addAssemblerKPIC(Args, CmdArgs);
6529 break;
6530
6531 case llvm::Triple::sparcv9:
6532 CmdArgs.push_back("-64");
6533 CmdArgs.push_back("-Av9");
6534 addAssemblerKPIC(Args, CmdArgs);
6535 break;
6536
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006537 default:
6538 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006539 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006540
6541 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6542 options::OPT_Xassembler);
6543
6544 CmdArgs.push_back("-o");
6545 CmdArgs.push_back(Output.getFilename());
6546
6547 for (InputInfoList::const_iterator
6548 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6549 const InputInfo &II = *it;
6550 CmdArgs.push_back(II.getFilename());
6551 }
6552
David Chisnallddbd68f2011-09-27 22:03:18 +00006553 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006554 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6555}
6556
6557void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6558 const InputInfo &Output,
6559 const InputInfoList &Inputs,
6560 const ArgList &Args,
6561 const char *LinkingOutput) const {
6562 const Driver &D = getToolChain().getDriver();
6563 ArgStringList CmdArgs;
6564
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006565 if (!D.SysRoot.empty())
6566 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6567
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006568 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006569 if (Args.hasArg(options::OPT_static)) {
6570 CmdArgs.push_back("-Bstatic");
6571 } else {
6572 if (Args.hasArg(options::OPT_rdynamic))
6573 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006574 if (Args.hasArg(options::OPT_shared)) {
6575 CmdArgs.push_back("-Bshareable");
6576 } else {
6577 CmdArgs.push_back("-dynamic-linker");
6578 CmdArgs.push_back("/libexec/ld.elf_so");
6579 }
6580 }
6581
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006582 // Many NetBSD architectures support more than one ABI.
6583 // Determine the correct emulation for ld.
6584 switch (getToolChain().getArch()) {
6585 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006586 CmdArgs.push_back("-m");
6587 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006588 break;
6589 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006590 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006591 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006592 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006593 CmdArgs.push_back("-m");
6594 switch (getToolChain().getTriple().getEnvironment()) {
6595 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006596 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006597 CmdArgs.push_back("armelf_nbsd_eabi");
6598 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006599 case llvm::Triple::EABIHF:
6600 case llvm::Triple::GNUEABIHF:
6601 CmdArgs.push_back("armelf_nbsd_eabihf");
6602 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006603 default:
6604 CmdArgs.push_back("armelf_nbsd");
6605 break;
6606 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006607 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006608 case llvm::Triple::mips64:
6609 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006610 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006611 CmdArgs.push_back("-m");
6612 if (getToolChain().getArch() == llvm::Triple::mips64)
6613 CmdArgs.push_back("elf32btsmip");
6614 else
6615 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006616 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006617 CmdArgs.push_back("-m");
6618 if (getToolChain().getArch() == llvm::Triple::mips64)
6619 CmdArgs.push_back("elf64btsmip");
6620 else
6621 CmdArgs.push_back("elf64ltsmip");
6622 }
6623 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006624
6625 case llvm::Triple::sparc:
6626 CmdArgs.push_back("-m");
6627 CmdArgs.push_back("elf32_sparc");
6628 break;
6629
6630 case llvm::Triple::sparcv9:
6631 CmdArgs.push_back("-m");
6632 CmdArgs.push_back("elf64_sparc");
6633 break;
6634
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006635 default:
6636 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006637 }
6638
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006639 if (Output.isFilename()) {
6640 CmdArgs.push_back("-o");
6641 CmdArgs.push_back(Output.getFilename());
6642 } else {
6643 assert(Output.isNothing() && "Invalid output.");
6644 }
6645
6646 if (!Args.hasArg(options::OPT_nostdlib) &&
6647 !Args.hasArg(options::OPT_nostartfiles)) {
6648 if (!Args.hasArg(options::OPT_shared)) {
6649 CmdArgs.push_back(Args.MakeArgString(
6650 getToolChain().GetFilePath("crt0.o")));
6651 CmdArgs.push_back(Args.MakeArgString(
6652 getToolChain().GetFilePath("crti.o")));
6653 CmdArgs.push_back(Args.MakeArgString(
6654 getToolChain().GetFilePath("crtbegin.o")));
6655 } else {
6656 CmdArgs.push_back(Args.MakeArgString(
6657 getToolChain().GetFilePath("crti.o")));
6658 CmdArgs.push_back(Args.MakeArgString(
6659 getToolChain().GetFilePath("crtbeginS.o")));
6660 }
6661 }
6662
6663 Args.AddAllArgs(CmdArgs, options::OPT_L);
6664 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6665 Args.AddAllArgs(CmdArgs, options::OPT_e);
6666 Args.AddAllArgs(CmdArgs, options::OPT_s);
6667 Args.AddAllArgs(CmdArgs, options::OPT_t);
6668 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6669 Args.AddAllArgs(CmdArgs, options::OPT_r);
6670
6671 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6672
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006673 unsigned Major, Minor, Micro;
6674 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6675 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006676 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006677 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006678 case llvm::Triple::arm:
6679 case llvm::Triple::armeb:
6680 case llvm::Triple::thumb:
6681 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006682 case llvm::Triple::x86:
6683 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006684 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006685 break;
6686 default:
6687 break;
6688 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006689 }
6690
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006691 if (!Args.hasArg(options::OPT_nostdlib) &&
6692 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006693 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006694 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6695 CmdArgs.push_back("-lm");
6696 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006697 if (Args.hasArg(options::OPT_pthread))
6698 CmdArgs.push_back("-lpthread");
6699 CmdArgs.push_back("-lc");
6700
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006701 if (useLibgcc) {
6702 if (Args.hasArg(options::OPT_static)) {
6703 // libgcc_eh depends on libc, so resolve as much as possible,
6704 // pull in any new requirements from libc and then get the rest
6705 // of libgcc.
6706 CmdArgs.push_back("-lgcc_eh");
6707 CmdArgs.push_back("-lc");
6708 CmdArgs.push_back("-lgcc");
6709 } else {
6710 CmdArgs.push_back("-lgcc");
6711 CmdArgs.push_back("--as-needed");
6712 CmdArgs.push_back("-lgcc_s");
6713 CmdArgs.push_back("--no-as-needed");
6714 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006715 }
6716 }
6717
6718 if (!Args.hasArg(options::OPT_nostdlib) &&
6719 !Args.hasArg(options::OPT_nostartfiles)) {
6720 if (!Args.hasArg(options::OPT_shared))
6721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6722 "crtend.o")));
6723 else
6724 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6725 "crtendS.o")));
6726 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6727 "crtn.o")));
6728 }
6729
Alexey Samsonov7811d192014-02-20 13:57:37 +00006730 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006731
Rafael Espindola236db462013-11-09 20:07:19 +00006732 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006733 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6734}
6735
Thomas Schwinge4e555262013-03-28 19:04:25 +00006736void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6737 const InputInfo &Output,
6738 const InputInfoList &Inputs,
6739 const ArgList &Args,
6740 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006741 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006742 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006743
6744 // Add --32/--64 to make sure we get the format we want.
6745 // This is incomplete
6746 if (getToolChain().getArch() == llvm::Triple::x86) {
6747 CmdArgs.push_back("--32");
6748 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6749 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006750 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6751 CmdArgs.push_back("-a32");
6752 CmdArgs.push_back("-mppc");
6753 CmdArgs.push_back("-many");
6754 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6755 CmdArgs.push_back("-a64");
6756 CmdArgs.push_back("-mppc64");
6757 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006758 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6759 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006760 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006761 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006762 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006763 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6764 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006765 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006766 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006767 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6768 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006769 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006770 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006771 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6772 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006773 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006774 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6775 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006776 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6777 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006778 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006779
Tim Northover9c7e0352013-12-12 11:55:52 +00006780 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6781 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006782 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006783
6784 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006785
6786 // FIXME: remove krait check when GNU tools support krait cpu
6787 // for now replace it with -march=armv7-a to avoid a lower
6788 // march from being picked in the absence of a cpu flag.
6789 Arg *A;
6790 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6791 StringRef(A->getValue()) == "krait")
6792 CmdArgs.push_back("-march=armv7-a");
6793 else
6794 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006795 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006796 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6797 getToolChain().getArch() == llvm::Triple::mipsel ||
6798 getToolChain().getArch() == llvm::Triple::mips64 ||
6799 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006800 StringRef CPUName;
6801 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006802 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006803
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006804 CmdArgs.push_back("-march");
6805 CmdArgs.push_back(CPUName.data());
6806
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006807 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006808 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006809
6810 if (getToolChain().getArch() == llvm::Triple::mips ||
6811 getToolChain().getArch() == llvm::Triple::mips64)
6812 CmdArgs.push_back("-EB");
6813 else
6814 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006815
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006816 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6817 if (StringRef(A->getValue()) == "2008")
6818 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6819 }
6820
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006821 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006822 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6823 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6824 options::OPT_mno_micromips);
6825 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6826 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6827
Simon Atanasyanbd986632013-11-26 11:58:04 +00006828 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6829 // Do not use AddLastArg because not all versions of MIPS assembler
6830 // support -mmsa / -mno-msa options.
6831 if (A->getOption().matches(options::OPT_mmsa))
6832 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6833 }
6834
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006835 NeedsKPIC = true;
6836 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6837 // Always pass an -march option, since our default of z10 is later
6838 // than the GNU assembler's default.
6839 StringRef CPUName = getSystemZTargetCPU(Args);
6840 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6841 }
6842
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006843 if (NeedsKPIC)
6844 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006845
6846 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6847 options::OPT_Xassembler);
6848
6849 CmdArgs.push_back("-o");
6850 CmdArgs.push_back(Output.getFilename());
6851
6852 for (InputInfoList::const_iterator
6853 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6854 const InputInfo &II = *it;
6855 CmdArgs.push_back(II.getFilename());
6856 }
6857
6858 const char *Exec =
6859 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6860 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006861
6862 // Handle the debug info splitting at object creation time if we're
6863 // creating an object.
6864 // TODO: Currently only works on linux with newer objcopy.
6865 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006866 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006867 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6868 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006869}
6870
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006871static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006872 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006873 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006874 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6875 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006876 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006877 CmdArgs.push_back("-lgcc");
6878
Logan Chien3d3373c2012-11-19 12:04:11 +00006879 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006880 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006881 CmdArgs.push_back("-lgcc");
6882 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006883 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006884 CmdArgs.push_back("--as-needed");
6885 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006886 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006887 CmdArgs.push_back("--no-as-needed");
6888 }
6889
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006890 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006891 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006892 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006893 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006894
6895 // According to Android ABI, we have to link with libdl if we are
6896 // linking with non-static libgcc.
6897 //
6898 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6899 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6900 if (isAndroid && !StaticLibgcc)
6901 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006902}
6903
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006904static StringRef getLinuxDynamicLinker(const ArgList &Args,
6905 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006906 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6907 if (ToolChain.getTriple().isArch64Bit())
6908 return "/system/bin/linker64";
6909 else
6910 return "/system/bin/linker";
6911 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6912 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006913 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00006914 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
6915 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006916 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00006917 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
6918 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00006919 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006920 else if (ToolChain.getArch() == llvm::Triple::arm ||
6921 ToolChain.getArch() == llvm::Triple::thumb) {
6922 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6923 return "/lib/ld-linux-armhf.so.3";
6924 else
6925 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006926 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
6927 ToolChain.getArch() == llvm::Triple::thumbeb) {
6928 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6929 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
6930 else
6931 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006932 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6933 ToolChain.getArch() == llvm::Triple::mipsel)
6934 return "/lib/ld.so.1";
6935 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6936 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006937 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006938 return "/lib32/ld.so.1";
6939 else
6940 return "/lib64/ld.so.1";
6941 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6942 return "/lib/ld.so.1";
6943 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006944 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006945 ToolChain.getArch() == llvm::Triple::systemz)
6946 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006947 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6948 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006949 else
6950 return "/lib64/ld-linux-x86-64.so.2";
6951}
6952
Renato Golinc4b49242014-02-13 10:01:16 +00006953static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6954 ArgStringList &CmdArgs, const ArgList &Args) {
6955 // Make use of compiler-rt if --rtlib option is used
6956 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6957
6958 switch(RLT) {
6959 case ToolChain::RLT_CompilerRT:
6960 addClangRTLinux(TC, Args, CmdArgs);
6961 break;
6962 case ToolChain::RLT_Libgcc:
6963 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6964 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006965 }
6966}
6967
Thomas Schwinge4e555262013-03-28 19:04:25 +00006968void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6969 const InputInfo &Output,
6970 const InputInfoList &Inputs,
6971 const ArgList &Args,
6972 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006973 const toolchains::Linux& ToolChain =
6974 static_cast<const toolchains::Linux&>(getToolChain());
6975 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006976 const bool isAndroid =
6977 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006978 const bool IsPIE =
6979 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00006980 !Args.hasArg(options::OPT_static) &&
6981 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
6982 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00006983 // Cannot use isPIEDefault here since otherwise
6984 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00006985 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006986
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006987 ArgStringList CmdArgs;
6988
Rafael Espindolad1002f62010-11-15 18:28:16 +00006989 // Silence warning for "clang -g foo.o -o foo"
6990 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006991 // and "clang -emit-llvm foo.o -o foo"
6992 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006993 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006994 // handled somewhere else.
6995 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006996
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006997 if (!D.SysRoot.empty())
6998 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006999
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007000 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007001 CmdArgs.push_back("-pie");
7002
Rafael Espindola1c76c592010-11-07 22:57:16 +00007003 if (Args.hasArg(options::OPT_rdynamic))
7004 CmdArgs.push_back("-export-dynamic");
7005
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007006 if (Args.hasArg(options::OPT_s))
7007 CmdArgs.push_back("-s");
7008
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007009 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
7010 e = ToolChain.ExtraOpts.end();
7011 i != e; ++i)
7012 CmdArgs.push_back(i->c_str());
7013
7014 if (!Args.hasArg(options::OPT_static)) {
7015 CmdArgs.push_back("--eh-frame-hdr");
7016 }
7017
7018 CmdArgs.push_back("-m");
7019 if (ToolChain.getArch() == llvm::Triple::x86)
7020 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007021 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7022 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007023 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007024 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7025 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007026 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007027 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007028 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007029 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007030 else if (ToolChain.getArch() == llvm::Triple::armeb
7031 || ToolChain.getArch() == llvm::Triple::thumbeb)
7032 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007033 else if (ToolChain.getArch() == llvm::Triple::ppc)
7034 CmdArgs.push_back("elf32ppclinux");
7035 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7036 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007037 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7038 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007039 else if (ToolChain.getArch() == llvm::Triple::sparc)
7040 CmdArgs.push_back("elf32_sparc");
7041 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7042 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007043 else if (ToolChain.getArch() == llvm::Triple::mips)
7044 CmdArgs.push_back("elf32btsmip");
7045 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7046 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007047 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007048 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007049 CmdArgs.push_back("elf32btsmipn32");
7050 else
7051 CmdArgs.push_back("elf64btsmip");
7052 }
7053 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007054 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007055 CmdArgs.push_back("elf32ltsmipn32");
7056 else
7057 CmdArgs.push_back("elf64ltsmip");
7058 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007059 else if (ToolChain.getArch() == llvm::Triple::systemz)
7060 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007061 else
7062 CmdArgs.push_back("elf_x86_64");
7063
7064 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007065 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007066 ToolChain.getArch() == llvm::Triple::armeb ||
7067 ToolChain.getArch() == llvm::Triple::thumb ||
7068 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007069 CmdArgs.push_back("-Bstatic");
7070 else
7071 CmdArgs.push_back("-static");
7072 } else if (Args.hasArg(options::OPT_shared)) {
7073 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00007074 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007075 CmdArgs.push_back("-Bsymbolic");
7076 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007077 }
7078
7079 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007080 ToolChain.getArch() == llvm::Triple::armeb ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00007081 ToolChain.getArch() == llvm::Triple::thumb ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007082 ToolChain.getArch() == llvm::Triple::thumbeb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007083 (!Args.hasArg(options::OPT_static) &&
7084 !Args.hasArg(options::OPT_shared))) {
7085 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007086 CmdArgs.push_back(Args.MakeArgString(
7087 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007088 }
7089
7090 CmdArgs.push_back("-o");
7091 CmdArgs.push_back(Output.getFilename());
7092
Rafael Espindola81937ec2010-12-01 01:52:43 +00007093 if (!Args.hasArg(options::OPT_nostdlib) &&
7094 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007095 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007096 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007097 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007098 if (Args.hasArg(options::OPT_pg))
7099 crt1 = "gcrt1.o";
7100 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007101 crt1 = "Scrt1.o";
7102 else
7103 crt1 = "crt1.o";
7104 }
7105 if (crt1)
7106 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007107
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007108 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7109 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007110
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007111 const char *crtbegin;
7112 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007113 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007114 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007115 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007116 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007117 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007118 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007119 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007120 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007121
7122 // Add crtfastmath.o if available and fast math is enabled.
7123 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007124 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007125
7126 Args.AddAllArgs(CmdArgs, options::OPT_L);
7127
7128 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7129
Roman Divackyee8188a2011-03-01 17:53:14 +00007130 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
7131 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007132 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007133
Alp Tokerce365ca2013-12-02 12:43:03 +00007134 if (D.IsUsingLTO(Args))
7135 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007136
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007137 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7138 CmdArgs.push_back("--no-demangle");
7139
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007140 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7141
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007142 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007143 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007144 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007145
Hans Wennborg70850d82013-07-18 20:29:38 +00007146 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007147 !Args.hasArg(options::OPT_nostdlib) &&
7148 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007149 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7150 !Args.hasArg(options::OPT_static);
7151 if (OnlyLibstdcxxStatic)
7152 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007153 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007154 if (OnlyLibstdcxxStatic)
7155 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007156 CmdArgs.push_back("-lm");
7157 }
7158
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007159 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007160 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7161 if (Args.hasArg(options::OPT_static))
7162 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007163
Alexey Bataev186b28a2014-03-06 05:43:53 +00007164 LibOpenMP UsedOpenMPLib = LibUnknown;
7165 if (Args.hasArg(options::OPT_fopenmp)) {
7166 UsedOpenMPLib = LibGOMP;
7167 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7168 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7169 .Case("libgomp", LibGOMP)
7170 .Case("libiomp5", LibIOMP5)
7171 .Default(LibUnknown);
7172 if (UsedOpenMPLib == LibUnknown)
7173 D.Diag(diag::err_drv_unsupported_option_argument)
7174 << A->getOption().getName() << A->getValue();
7175 }
7176 switch (UsedOpenMPLib) {
7177 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007178 CmdArgs.push_back("-lgomp");
7179
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007180 // FIXME: Exclude this for platforms with libgomp that don't require
7181 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007182 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007183 break;
7184 case LibIOMP5:
7185 CmdArgs.push_back("-liomp5");
7186 break;
7187 case LibUnknown:
7188 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007189 }
Renato Golinc4b49242014-02-13 10:01:16 +00007190 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007191
Evgeniy Stepanov152b0232014-05-28 12:53:34 +00007192 if (!isAndroid &&
7193 (Args.hasArg(options::OPT_pthread) ||
7194 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown))
Chandler Carruth94a32012012-05-14 18:31:18 +00007195 CmdArgs.push_back("-lpthread");
7196
7197 CmdArgs.push_back("-lc");
7198
7199 if (Args.hasArg(options::OPT_static))
7200 CmdArgs.push_back("--end-group");
7201 else
Renato Golinc4b49242014-02-13 10:01:16 +00007202 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007203 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007204
Rafael Espindola81937ec2010-12-01 01:52:43 +00007205 if (!Args.hasArg(options::OPT_nostartfiles)) {
7206 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007207 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007208 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007209 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007210 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007211 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007212 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007213
Rafael Espindola81937ec2010-12-01 01:52:43 +00007214 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007215 if (!isAndroid)
7216 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007217 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007218 }
7219
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007220 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
7221}
Rafael Espindola92b00932010-08-10 00:25:48 +00007222
Chris Lattner3e2ee142010-07-07 16:01:42 +00007223void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007224 const InputInfo &Output,
7225 const InputInfoList &Inputs,
7226 const ArgList &Args,
7227 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007228 ArgStringList CmdArgs;
7229
7230 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7231 options::OPT_Xassembler);
7232
7233 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007234 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007235
7236 for (InputInfoList::const_iterator
7237 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7238 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007239 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007240 }
7241
7242 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00007243 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007244 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007245}
7246
7247void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007248 const InputInfo &Output,
7249 const InputInfoList &Inputs,
7250 const ArgList &Args,
7251 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007252 const Driver &D = getToolChain().getDriver();
7253 ArgStringList CmdArgs;
7254
Daniel Dunbarb440f562010-08-02 02:38:21 +00007255 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007256 CmdArgs.push_back("-o");
7257 CmdArgs.push_back(Output.getFilename());
7258 } else {
7259 assert(Output.isNothing() && "Invalid output.");
7260 }
7261
7262 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007263 !Args.hasArg(options::OPT_nostartfiles)) {
7264 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7265 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7266 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7267 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7268 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007269
7270 Args.AddAllArgs(CmdArgs, options::OPT_L);
7271 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7272 Args.AddAllArgs(CmdArgs, options::OPT_e);
7273
Daniel Dunbar54423b22010-09-17 00:24:54 +00007274 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007275
Alexey Samsonov7811d192014-02-20 13:57:37 +00007276 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007277
Chris Lattner3e2ee142010-07-07 16:01:42 +00007278 if (!Args.hasArg(options::OPT_nostdlib) &&
7279 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007280 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007281 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007282 CmdArgs.push_back("-lm");
7283 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007284 }
7285
7286 if (!Args.hasArg(options::OPT_nostdlib) &&
7287 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007288 if (Args.hasArg(options::OPT_pthread))
7289 CmdArgs.push_back("-lpthread");
7290 CmdArgs.push_back("-lc");
7291 CmdArgs.push_back("-lCompilerRT-Generic");
7292 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7293 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007294 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007295 }
7296
Rafael Espindola236db462013-11-09 20:07:19 +00007297 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007298 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007299}
7300
Daniel Dunbarcc912342009-05-02 18:28:39 +00007301/// DragonFly Tools
7302
7303// For now, DragonFly Assemble does just about the same as for
7304// FreeBSD, but this may change soon.
7305void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007306 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007307 const InputInfoList &Inputs,
7308 const ArgList &Args,
7309 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007310 ArgStringList CmdArgs;
7311
7312 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7313 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007314 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007315 CmdArgs.push_back("--32");
7316
7317 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7318 options::OPT_Xassembler);
7319
7320 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007321 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007322
7323 for (InputInfoList::const_iterator
7324 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7325 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007326 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007327 }
7328
7329 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007330 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007331 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007332}
7333
7334void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007335 const InputInfo &Output,
7336 const InputInfoList &Inputs,
7337 const ArgList &Args,
7338 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007339 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007340 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007341 ArgStringList CmdArgs;
7342
John McCall65b8da02013-04-11 22:55:55 +00007343 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7344 UseGCC47 = false;
7345
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007346 if (!D.SysRoot.empty())
7347 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7348
John McCall65b8da02013-04-11 22:55:55 +00007349 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007350 if (Args.hasArg(options::OPT_static)) {
7351 CmdArgs.push_back("-Bstatic");
7352 } else {
John McCall65b8da02013-04-11 22:55:55 +00007353 if (Args.hasArg(options::OPT_rdynamic))
7354 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007355 if (Args.hasArg(options::OPT_shared))
7356 CmdArgs.push_back("-Bshareable");
7357 else {
7358 CmdArgs.push_back("-dynamic-linker");
7359 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7360 }
John McCall65b8da02013-04-11 22:55:55 +00007361 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007362 }
7363
7364 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7365 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007366 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007367 CmdArgs.push_back("-m");
7368 CmdArgs.push_back("elf_i386");
7369 }
7370
Daniel Dunbarb440f562010-08-02 02:38:21 +00007371 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007372 CmdArgs.push_back("-o");
7373 CmdArgs.push_back(Output.getFilename());
7374 } else {
7375 assert(Output.isNothing() && "Invalid output.");
7376 }
7377
7378 if (!Args.hasArg(options::OPT_nostdlib) &&
7379 !Args.hasArg(options::OPT_nostartfiles)) {
7380 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007381 if (Args.hasArg(options::OPT_pg))
7382 CmdArgs.push_back(Args.MakeArgString(
7383 getToolChain().GetFilePath("gcrt1.o")));
7384 else {
7385 if (Args.hasArg(options::OPT_pie))
7386 CmdArgs.push_back(Args.MakeArgString(
7387 getToolChain().GetFilePath("Scrt1.o")));
7388 else
7389 CmdArgs.push_back(Args.MakeArgString(
7390 getToolChain().GetFilePath("crt1.o")));
7391 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007392 }
John McCall65b8da02013-04-11 22:55:55 +00007393 CmdArgs.push_back(Args.MakeArgString(
7394 getToolChain().GetFilePath("crti.o")));
7395 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7396 CmdArgs.push_back(Args.MakeArgString(
7397 getToolChain().GetFilePath("crtbeginS.o")));
7398 else
7399 CmdArgs.push_back(Args.MakeArgString(
7400 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007401 }
7402
7403 Args.AddAllArgs(CmdArgs, options::OPT_L);
7404 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7405 Args.AddAllArgs(CmdArgs, options::OPT_e);
7406
Daniel Dunbar54423b22010-09-17 00:24:54 +00007407 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007408
7409 if (!Args.hasArg(options::OPT_nostdlib) &&
7410 !Args.hasArg(options::OPT_nodefaultlibs)) {
7411 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7412 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007413 if (UseGCC47)
7414 CmdArgs.push_back("-L/usr/lib/gcc47");
7415 else
7416 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007417
7418 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007419 if (UseGCC47) {
7420 CmdArgs.push_back("-rpath");
7421 CmdArgs.push_back("/usr/lib/gcc47");
7422 } else {
7423 CmdArgs.push_back("-rpath");
7424 CmdArgs.push_back("/usr/lib/gcc44");
7425 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007426 }
7427
Hans Wennborg70850d82013-07-18 20:29:38 +00007428 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007429 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007430 CmdArgs.push_back("-lm");
7431 }
7432
Daniel Dunbarcc912342009-05-02 18:28:39 +00007433 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007434 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007435
7436 if (!Args.hasArg(options::OPT_nolibc)) {
7437 CmdArgs.push_back("-lc");
7438 }
7439
John McCall65b8da02013-04-11 22:55:55 +00007440 if (UseGCC47) {
7441 if (Args.hasArg(options::OPT_static) ||
7442 Args.hasArg(options::OPT_static_libgcc)) {
7443 CmdArgs.push_back("-lgcc");
7444 CmdArgs.push_back("-lgcc_eh");
7445 } else {
7446 if (Args.hasArg(options::OPT_shared_libgcc)) {
7447 CmdArgs.push_back("-lgcc_pic");
7448 if (!Args.hasArg(options::OPT_shared))
7449 CmdArgs.push_back("-lgcc");
7450 } else {
7451 CmdArgs.push_back("-lgcc");
7452 CmdArgs.push_back("--as-needed");
7453 CmdArgs.push_back("-lgcc_pic");
7454 CmdArgs.push_back("--no-as-needed");
7455 }
7456 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007457 } else {
John McCall65b8da02013-04-11 22:55:55 +00007458 if (Args.hasArg(options::OPT_shared)) {
7459 CmdArgs.push_back("-lgcc_pic");
7460 } else {
7461 CmdArgs.push_back("-lgcc");
7462 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007463 }
7464 }
7465
7466 if (!Args.hasArg(options::OPT_nostdlib) &&
7467 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007468 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007469 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007470 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007471 else
7472 CmdArgs.push_back(Args.MakeArgString(
7473 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007474 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007475 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007476 }
7477
Alexey Samsonov7811d192014-02-20 13:57:37 +00007478 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007479
Daniel Dunbarcc912342009-05-02 18:28:39 +00007480 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007481 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007482 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007483}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007484
Alexey Samsonov6424e022014-05-12 20:20:20 +00007485static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7486 ArgStringList &CmdArgs,
7487 const StringRef RTName) {
7488 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7489 llvm::sys::path::append(LibSanitizer,
7490 Twine("clang_rt.") + RTName + ".lib");
7491 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7492}
7493
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007494void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7495 const InputInfo &Output,
7496 const InputInfoList &Inputs,
7497 const ArgList &Args,
7498 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007499 ArgStringList CmdArgs;
7500
7501 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007502 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7503 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007504 } else {
7505 assert(Output.isNothing() && "Invalid output.");
7506 }
7507
7508 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007509 !Args.hasArg(options::OPT_nostartfiles) &&
7510 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007511 CmdArgs.push_back("-defaultlib:libcmt");
7512 }
7513
7514 CmdArgs.push_back("-nologo");
7515
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007516 if (Args.hasArg(options::OPT_g_Group)) {
7517 CmdArgs.push_back("-debug");
7518 }
7519
Hans Wennborgf1a74252013-09-10 20:18:04 +00007520 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7521
7522 if (DLL) {
7523 CmdArgs.push_back(Args.MakeArgString("-dll"));
7524
7525 SmallString<128> ImplibName(Output.getFilename());
7526 llvm::sys::path::replace_extension(ImplibName, "lib");
7527 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7528 ImplibName.str()));
7529 }
7530
Peter Collingbourne32701642013-11-01 18:16:25 +00007531 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007532 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007533 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007534 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007535 if (DLL) {
7536 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7537 "asan_dll_thunk-i386");
7538 } else {
7539 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7540 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7541 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007542 }
7543
Michael J. Spencere2f49362012-06-18 16:56:04 +00007544 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007545 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007546
7547 // Add filenames immediately.
7548 for (InputInfoList::const_iterator
7549 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7550 if (it->isFilename())
7551 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007552 else
7553 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007554 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007555
7556 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007557 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007558 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7559}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007560
7561void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7562 const InputInfo &Output,
7563 const InputInfoList &Inputs,
7564 const ArgList &Args,
7565 const char *LinkingOutput) const {
7566 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7567}
7568
Hans Wennborg188382e2013-09-20 18:16:35 +00007569// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7570// If one cannot be found, return FallbackName.
7571// We do this special search to prevent clang-cl from falling back onto itself
7572// if it's available as cl.exe on the path.
7573static std::string FindFallback(const char *FallbackName,
7574 const char *ClangProgramPath) {
7575 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7576 if (!OptPath.hasValue())
7577 return FallbackName;
7578
7579#ifdef LLVM_ON_WIN32
7580 const StringRef PathSeparators = ";";
7581#else
7582 const StringRef PathSeparators = ":";
7583#endif
7584
7585 SmallVector<StringRef, 8> PathSegments;
7586 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7587
7588 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7589 const StringRef &PathSegment = PathSegments[i];
7590 if (PathSegment.empty())
7591 continue;
7592
7593 SmallString<128> FilePath(PathSegment);
7594 llvm::sys::path::append(FilePath, FallbackName);
7595 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7596 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7597 return FilePath.str();
7598 }
7599
7600 return FallbackName;
7601}
7602
Hans Wennborg87cfa712013-09-19 20:32:16 +00007603Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7604 const InputInfo &Output,
7605 const InputInfoList &Inputs,
7606 const ArgList &Args,
7607 const char *LinkingOutput) const {
7608 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007609 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007610 CmdArgs.push_back("/c"); // Compile only.
7611 CmdArgs.push_back("/W0"); // No warnings.
7612
7613 // The goal is to be able to invoke this tool correctly based on
7614 // any flag accepted by clang-cl.
7615
7616 // These are spelled the same way in clang and cl.exe,.
7617 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7618 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007619
7620 // Optimization level.
7621 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7622 if (A->getOption().getID() == options::OPT_O0) {
7623 CmdArgs.push_back("/Od");
7624 } else {
7625 StringRef OptLevel = A->getValue();
7626 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7627 A->render(Args, CmdArgs);
7628 else if (OptLevel == "3")
7629 CmdArgs.push_back("/Ox");
7630 }
7631 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007632
7633 // Flags for which clang-cl have an alias.
7634 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7635
7636 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7637 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7638 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007639 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7640 options::OPT_fno_function_sections))
7641 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7642 ? "/Gy"
7643 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007644 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7645 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007646 CmdArgs.push_back(
7647 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007648 if (Args.hasArg(options::OPT_fsyntax_only))
7649 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007650 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7651 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007652
Hans Wennborg260ff402013-09-27 17:54:18 +00007653 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7654 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7655 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7656
Hans Wennborg87cfa712013-09-19 20:32:16 +00007657 // Flags that can simply be passed through.
7658 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7659 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7660
7661 // The order of these flags is relevant, so pick the last one.
7662 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7663 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7664 A->render(Args, CmdArgs);
7665
7666
7667 // Input filename.
7668 assert(Inputs.size() == 1);
7669 const InputInfo &II = Inputs[0];
7670 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7671 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7672 if (II.isFilename())
7673 CmdArgs.push_back(II.getFilename());
7674 else
7675 II.getInputArg().renderAsInput(Args, CmdArgs);
7676
7677 // Output filename.
7678 assert(Output.getType() == types::TY_Object);
7679 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7680 Output.getFilename());
7681 CmdArgs.push_back(Fo);
7682
Hans Wennborg188382e2013-09-20 18:16:35 +00007683 const Driver &D = getToolChain().getDriver();
7684 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007685
Hans Wennborg188382e2013-09-20 18:16:35 +00007686 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007687}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007688
7689
7690/// XCore Tools
7691// We pass assemble and link construction to the xcc tool.
7692
7693void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7694 const InputInfo &Output,
7695 const InputInfoList &Inputs,
7696 const ArgList &Args,
7697 const char *LinkingOutput) const {
7698 ArgStringList CmdArgs;
7699
7700 CmdArgs.push_back("-o");
7701 CmdArgs.push_back(Output.getFilename());
7702
7703 CmdArgs.push_back("-c");
7704
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007705 if (Args.hasArg(options::OPT_v))
7706 CmdArgs.push_back("-v");
7707
Robert Lytton894d25c2014-05-02 09:33:25 +00007708 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7709 if (!A->getOption().matches(options::OPT_g0))
7710 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007711
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007712 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7713 false))
7714 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007715
7716 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7717 options::OPT_Xassembler);
7718
7719 for (InputInfoList::const_iterator
7720 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7721 const InputInfo &II = *it;
7722 CmdArgs.push_back(II.getFilename());
7723 }
7724
7725 const char *Exec =
7726 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7727 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7728}
7729
7730void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7731 const InputInfo &Output,
7732 const InputInfoList &Inputs,
7733 const ArgList &Args,
7734 const char *LinkingOutput) const {
7735 ArgStringList CmdArgs;
7736
7737 if (Output.isFilename()) {
7738 CmdArgs.push_back("-o");
7739 CmdArgs.push_back(Output.getFilename());
7740 } else {
7741 assert(Output.isNothing() && "Invalid output.");
7742 }
7743
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007744 if (Args.hasArg(options::OPT_v))
7745 CmdArgs.push_back("-v");
7746
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007747 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7748 if (EH.ShouldUseExceptionTables)
7749 CmdArgs.push_back("-fexceptions");
7750
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007751 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7752
7753 const char *Exec =
7754 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7755 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7756}