blob: dfbc280c55c4f2e228587fd414a33107e18c2cda [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
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002520 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2521 StringRef v = A->getValue();
2522 CmdArgs.push_back("-mllvm");
2523 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2524 A->claim();
2525 }
2526
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002527 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2528 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002529 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002530 }
2531
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002532 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2533 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002534 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002535 D.Diag(diag::err_drv_unsupported_opt_for_target)
2536 << A->getSpelling() << getToolChain().getTriple().str();
2537 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2538 CmdArgs.push_back("-fpcc-struct-return");
2539 } else {
2540 assert(A->getOption().matches(options::OPT_freg_struct_return));
2541 CmdArgs.push_back("-freg-struct-return");
2542 }
2543 }
2544
Roman Divacky65b88cd2011-03-01 17:40:53 +00002545 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2546 CmdArgs.push_back("-mrtd");
2547
Rafael Espindola224dd632011-12-14 21:02:23 +00002548 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002549 CmdArgs.push_back("-mdisable-fp-elim");
2550 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2551 options::OPT_fno_zero_initialized_in_bss))
2552 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002553
2554 bool OFastEnabled = isOptimizationLevelFast(Args);
2555 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2556 // enabled. This alias option is being used to simplify the hasFlag logic.
2557 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2558 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002559 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2560 // doesn't do any TBAA.
2561 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002562 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002563 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002564 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002565 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2566 options::OPT_fno_struct_path_tbaa))
2567 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002568 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2569 false))
2570 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002571 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2572 options::OPT_fno_optimize_sibling_calls))
2573 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002574
Eric Christopher006208c2013-04-04 06:29:47 +00002575 // Handle segmented stacks.
2576 if (Args.hasArg(options::OPT_fsplit_stack))
2577 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002578
2579 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2580 // This alias option is being used to simplify the getLastArg logic.
2581 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2582 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002583
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002584 // Handle various floating point optimization flags, mapping them to the
2585 // appropriate LLVM code generation flags. The pattern for all of these is to
2586 // default off the codegen optimizations, and if any flag enables them and no
2587 // flag disables them after the flag enabling them, enable the codegen
2588 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002589 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002590 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002591 options::OPT_ffinite_math_only,
2592 options::OPT_fno_finite_math_only,
2593 options::OPT_fhonor_infinities,
2594 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002595 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2596 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002597 A->getOption().getID() != options::OPT_fhonor_infinities)
2598 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002599 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002600 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002601 options::OPT_ffinite_math_only,
2602 options::OPT_fno_finite_math_only,
2603 options::OPT_fhonor_nans,
2604 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002605 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2606 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002607 A->getOption().getID() != options::OPT_fhonor_nans)
2608 CmdArgs.push_back("-menable-no-nans");
2609
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002610 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2611 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002612 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002613 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002614 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002615 options::OPT_fno_math_errno)) {
2616 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2617 // However, turning *off* -ffast_math merely restores the toolchain default
2618 // (which may be false).
2619 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2620 A->getOption().getID() == options::OPT_ffast_math ||
2621 A->getOption().getID() == options::OPT_Ofast)
2622 MathErrno = false;
2623 else if (A->getOption().getID() == options::OPT_fmath_errno)
2624 MathErrno = true;
2625 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002626 if (MathErrno)
2627 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002628
2629 // There are several flags which require disabling very specific
2630 // optimizations. Any of these being disabled forces us to turn off the
2631 // entire set of LLVM optimizations, so collect them through all the flag
2632 // madness.
2633 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002634 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002635 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002636 options::OPT_funsafe_math_optimizations,
2637 options::OPT_fno_unsafe_math_optimizations,
2638 options::OPT_fassociative_math,
2639 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002640 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2641 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002642 A->getOption().getID() != options::OPT_fno_associative_math)
2643 AssociativeMath = true;
2644 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002645 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002646 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002647 options::OPT_funsafe_math_optimizations,
2648 options::OPT_fno_unsafe_math_optimizations,
2649 options::OPT_freciprocal_math,
2650 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002651 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2652 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002653 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2654 ReciprocalMath = true;
2655 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002656 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002657 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002658 options::OPT_funsafe_math_optimizations,
2659 options::OPT_fno_unsafe_math_optimizations,
2660 options::OPT_fsigned_zeros,
2661 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002662 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2663 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002664 A->getOption().getID() != options::OPT_fsigned_zeros)
2665 SignedZeros = false;
2666 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002667 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002668 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002669 options::OPT_funsafe_math_optimizations,
2670 options::OPT_fno_unsafe_math_optimizations,
2671 options::OPT_ftrapping_math,
2672 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002673 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2674 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002675 A->getOption().getID() != options::OPT_ftrapping_math)
2676 TrappingMath = false;
2677 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2678 !TrappingMath)
2679 CmdArgs.push_back("-menable-unsafe-fp-math");
2680
Lang Hamesaa53b932012-07-06 00:59:19 +00002681
2682 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002683 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002684 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002685 options::OPT_ffp_contract)) {
2686 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002687 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002688 if (Val == "fast" || Val == "on" || Val == "off") {
2689 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2690 } else {
2691 D.Diag(diag::err_drv_unsupported_option_argument)
2692 << A->getOption().getName() << Val;
2693 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002694 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2695 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002696 // If fast-math is set then set the fp-contract mode to fast.
2697 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2698 }
2699 }
2700
Bob Wilson6a039162012-07-19 03:52:53 +00002701 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2702 // and if we find them, tell the frontend to provide the appropriate
2703 // preprocessor macros. This is distinct from enabling any optimizations as
2704 // these options induce language changes which must survive serialization
2705 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002706 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2707 options::OPT_fno_fast_math))
2708 if (!A->getOption().matches(options::OPT_fno_fast_math))
2709 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002710 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2711 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002712 if (A->getOption().matches(options::OPT_ffinite_math_only))
2713 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002714
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002715 // Decide whether to use verbose asm. Verbose assembly is the default on
2716 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002717 bool IsIntegratedAssemblerDefault =
2718 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002719 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002720 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002721 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002722 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002723
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002724 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002725 IsIntegratedAssemblerDefault))
2726 CmdArgs.push_back("-no-integrated-as");
2727
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002728 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2729 CmdArgs.push_back("-mdebug-pass");
2730 CmdArgs.push_back("Structure");
2731 }
2732 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2733 CmdArgs.push_back("-mdebug-pass");
2734 CmdArgs.push_back("Arguments");
2735 }
2736
John McCall8517abc2010-02-19 02:45:38 +00002737 // Enable -mconstructor-aliases except on darwin, where we have to
2738 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002739 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002740 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002741
John McCall7ef5cb32011-03-18 02:56:14 +00002742 // Darwin's kernel doesn't support guard variables; just die if we
2743 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002744 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002745 CmdArgs.push_back("-fforbid-guard-variables");
2746
Douglas Gregordbe39272011-02-01 15:15:22 +00002747 if (Args.hasArg(options::OPT_mms_bitfields)) {
2748 CmdArgs.push_back("-mms-bitfields");
2749 }
John McCall8517abc2010-02-19 02:45:38 +00002750
Daniel Dunbar306945d2009-09-16 06:17:29 +00002751 // This is a coarse approximation of what llvm-gcc actually does, both
2752 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2753 // complicated ways.
2754 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002755 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2756 options::OPT_fno_asynchronous_unwind_tables,
2757 (getToolChain().IsUnwindTablesDefault() ||
2758 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2759 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002760 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2761 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002762 CmdArgs.push_back("-munwind-tables");
2763
Chandler Carruth05fb5852012-11-21 23:40:23 +00002764 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002765
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002766 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2767 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002768 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002769 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002770
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002771 // FIXME: Handle -mtune=.
2772 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002773
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002774 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002775 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002776 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002777 }
2778
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002779 // Add the target cpu
2780 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2781 llvm::Triple ETriple(ETripleStr);
2782 std::string CPU = getCPUName(Args, ETriple);
2783 if (!CPU.empty()) {
2784 CmdArgs.push_back("-target-cpu");
2785 CmdArgs.push_back(Args.MakeArgString(CPU));
2786 }
2787
Rafael Espindolaeb265472013-08-21 21:59:03 +00002788 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2789 CmdArgs.push_back("-mfpmath");
2790 CmdArgs.push_back(A->getValue());
2791 }
2792
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002793 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002794 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002795
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002796 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002797 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002798 default:
2799 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002800
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002801 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002802 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002803 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002804 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002805 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002806 break;
2807
Tim Northover573cbee2014-05-24 12:52:07 +00002808 case llvm::Triple::aarch64:
2809 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002810 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002811 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002812 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002813 break;
2814
Eric Christopher0b26a612010-03-02 02:41:08 +00002815 case llvm::Triple::mips:
2816 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002817 case llvm::Triple::mips64:
2818 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002819 AddMIPSTargetArgs(Args, CmdArgs);
2820 break;
2821
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002822 case llvm::Triple::sparc:
2823 AddSparcTargetArgs(Args, CmdArgs);
2824 break;
2825
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002826 case llvm::Triple::x86:
2827 case llvm::Triple::x86_64:
2828 AddX86TargetArgs(Args, CmdArgs);
2829 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002830
2831 case llvm::Triple::hexagon:
2832 AddHexagonTargetArgs(Args, CmdArgs);
2833 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002834 }
2835
Hans Wennborg75958c42013-08-08 00:17:41 +00002836 // Add clang-cl arguments.
2837 if (getToolChain().getDriver().IsCLMode())
2838 AddClangCLArgs(Args, CmdArgs);
2839
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002840 // Pass the linker version in use.
2841 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2842 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002843 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002844 }
2845
Eric Christopherb7d97e92013-04-03 01:58:53 +00002846 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002847 CmdArgs.push_back("-momit-leaf-frame-pointer");
2848
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002849 // Explicitly error on some things we know we don't support and can't just
2850 // ignore.
2851 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002852 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2853 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002854 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002855 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002856 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002857 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2858 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002859 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002860 << Unsupported->getOption().getName();
2861 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002862 }
2863
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002864 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002865 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002866 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002867 CmdArgs.push_back("-header-include-file");
2868 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2869 D.CCPrintHeadersFilename : "-");
2870 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002871 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002872 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002873
Chad Rosierbe10f982011-08-02 17:58:04 +00002874 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002875 CmdArgs.push_back("-diagnostic-log-file");
2876 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2877 D.CCLogDiagnosticsFilename : "-");
2878 }
2879
Manman Ren17bdb0f2013-11-20 20:22:14 +00002880 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2881 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002882 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002883 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002884 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002885 // FIXME: we should support specifying dwarf version with
2886 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002887 CmdArgs.push_back("-gline-tables-only");
Adrian Prantl549c5142014-02-17 17:40:52 +00002888 // Default is dwarf-2 for darwin.
2889 if (getToolChain().getTriple().isOSDarwin())
2890 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002891 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002892 CmdArgs.push_back("-gdwarf-2");
2893 else if (A->getOption().matches(options::OPT_gdwarf_3))
2894 CmdArgs.push_back("-gdwarf-3");
2895 else if (A->getOption().matches(options::OPT_gdwarf_4))
2896 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002897 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002898 !A->getOption().matches(options::OPT_ggdb0)) {
2899 // Default is dwarf-2 for darwin.
2900 if (getToolChain().getTriple().isOSDarwin())
2901 CmdArgs.push_back("-gdwarf-2");
2902 else
2903 CmdArgs.push_back("-g");
2904 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002905 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002906
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002907 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2908 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002909 if (Args.hasArg(options::OPT_gcolumn_info))
2910 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002911
Eric Christopher138c32b2013-09-13 22:37:55 +00002912 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002913 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2914 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002915 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002916 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002917 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002918 CmdArgs.push_back("-g");
2919 CmdArgs.push_back("-backend-option");
2920 CmdArgs.push_back("-split-dwarf=Enable");
2921 }
2922
Eric Christopher138c32b2013-09-13 22:37:55 +00002923 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2924 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2925 CmdArgs.push_back("-backend-option");
2926 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2927 }
Eric Christophereec89c22013-06-18 00:03:50 +00002928
Eric Christopher0d403d22014-02-14 01:27:03 +00002929 // -gdwarf-aranges turns on the emission of the aranges section in the
2930 // backend.
2931 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2932 CmdArgs.push_back("-backend-option");
2933 CmdArgs.push_back("-generate-arange-section");
2934 }
2935
David Blaikief36d9ba2014-01-27 18:52:43 +00002936 if (Args.hasFlag(options::OPT_fdebug_types_section,
2937 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002938 CmdArgs.push_back("-backend-option");
2939 CmdArgs.push_back("-generate-type-units");
2940 }
Eric Christophereec89c22013-06-18 00:03:50 +00002941
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002942 if (Args.hasFlag(options::OPT_ffunction_sections,
2943 options::OPT_fno_function_sections, false)) {
2944 CmdArgs.push_back("-ffunction-sections");
2945 }
2946
2947 if (Args.hasFlag(options::OPT_fdata_sections,
2948 options::OPT_fno_data_sections, false)) {
2949 CmdArgs.push_back("-fdata-sections");
2950 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002951
Chris Lattner3c77a352010-06-22 00:03:40 +00002952 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2953
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002954 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2955 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2956 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2957 D.Diag(diag::err_drv_argument_not_allowed_with)
2958 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2959
2960 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2961
2962 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2963 A->render(Args, CmdArgs);
2964 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2965 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2966
Nick Lewycky207bce32011-04-21 23:44:07 +00002967 if (Args.hasArg(options::OPT_ftest_coverage) ||
2968 Args.hasArg(options::OPT_coverage))
2969 CmdArgs.push_back("-femit-coverage-notes");
2970 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2971 Args.hasArg(options::OPT_coverage))
2972 CmdArgs.push_back("-femit-coverage-data");
2973
Nick Lewycky480cb992011-05-04 20:46:58 +00002974 if (C.getArgs().hasArg(options::OPT_c) ||
2975 C.getArgs().hasArg(options::OPT_S)) {
2976 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002977 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002978 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002979 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002980 SmallString<128> Pwd;
2981 if (!llvm::sys::fs::current_path(Pwd)) {
2982 llvm::sys::path::append(Pwd, CoverageFilename.str());
2983 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002984 }
2985 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002986 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002987 }
2988 }
2989
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002990 // Pass options for controlling the default header search paths.
2991 if (Args.hasArg(options::OPT_nostdinc)) {
2992 CmdArgs.push_back("-nostdsysteminc");
2993 CmdArgs.push_back("-nobuiltininc");
2994 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00002995 if (Args.hasArg(options::OPT_nostdlibinc))
2996 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002997 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2998 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2999 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003000
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003001 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003002 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003003 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003004
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003005 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3006
Ted Kremenekf7639e12012-03-06 20:06:33 +00003007 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003008 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003009 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003010 options::OPT_ccc_arcmt_modify,
3011 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003012 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003013 switch (A->getOption().getID()) {
3014 default:
3015 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003016 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003017 CmdArgs.push_back("-arcmt-check");
3018 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003019 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003020 CmdArgs.push_back("-arcmt-modify");
3021 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003022 case options::OPT_ccc_arcmt_migrate:
3023 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003024 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003025 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003026
3027 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3028 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003029 break;
John McCalld70fb982011-06-15 23:25:17 +00003030 }
3031 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003032 } else {
3033 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3034 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3035 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003036 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003037
Ted Kremenekf7639e12012-03-06 20:06:33 +00003038 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3039 if (ARCMTEnabled) {
3040 D.Diag(diag::err_drv_argument_not_allowed_with)
3041 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3042 }
3043 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003044 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003045
3046 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003047 options::OPT_objcmt_migrate_subscripting,
3048 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003049 // None specified, means enable them all.
3050 CmdArgs.push_back("-objcmt-migrate-literals");
3051 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003052 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003053 } else {
3054 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3055 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003056 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003057 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003058 } else {
3059 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3060 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3061 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3062 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3063 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3064 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3065 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3066 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3067 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3068 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3069 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3070 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3071 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003072 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003073 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003074 }
3075
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003076 // Add preprocessing options like -I, -D, etc. if we are using the
3077 // preprocessor.
3078 //
3079 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003080 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003081 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003082
Rafael Espindolaa7431922011-07-21 23:40:37 +00003083 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3084 // that "The compiler can only warn and ignore the option if not recognized".
3085 // When building with ccache, it will pass -D options to clang even on
3086 // preprocessed inputs and configure concludes that -fPIC is not supported.
3087 Args.ClaimAllArgs(options::OPT_D);
3088
Alp Toker7874bdc2013-11-15 20:40:58 +00003089 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003090 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3091 if (A->getOption().matches(options::OPT_O4)) {
3092 CmdArgs.push_back("-O3");
3093 D.Diag(diag::warn_O4_is_O3);
3094 } else {
3095 A->render(Args, CmdArgs);
3096 }
3097 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003098
Chad Rosier86b82082012-12-12 20:06:31 +00003099 // Don't warn about unused -flto. This can happen when we're preprocessing or
3100 // precompiling.
3101 Args.ClaimAllArgs(options::OPT_flto);
3102
Daniel Dunbar945577c2009-10-29 02:24:45 +00003103 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003104 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3105 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003106 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003107 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003108
3109 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003110 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003111 //
3112 // If a std is supplied, only add -trigraphs if it follows the
3113 // option.
3114 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3115 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003116 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003117 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003118 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003119 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003120 else
3121 Std->render(Args, CmdArgs);
3122
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003123 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3124 options::OPT_trigraphs))
3125 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003126 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003127 } else {
3128 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003129 //
3130 // FIXME: Clang doesn't correctly handle -std= when the input language
3131 // doesn't match. For the time being just ignore this for C++ inputs;
3132 // eventually we want to do all the standard defaulting here instead of
3133 // splitting it between the driver and clang -cc1.
3134 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003135 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3136 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003137 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003138 CmdArgs.push_back("-std=c++11");
3139
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003140 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003141 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003142
Richard Smith282b4492013-09-04 22:50:31 +00003143 // GCC's behavior for -Wwrite-strings is a bit strange:
3144 // * In C, this "warning flag" changes the types of string literals from
3145 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3146 // for the discarded qualifier.
3147 // * In C++, this is just a normal warning flag.
3148 //
3149 // Implementing this warning correctly in C is hard, so we follow GCC's
3150 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3151 // a non-const char* in C, rather than using this crude hack.
3152 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003153 // FIXME: This should behave just like a warning flag, and thus should also
3154 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3155 Arg *WriteStrings =
3156 Args.getLastArg(options::OPT_Wwrite_strings,
3157 options::OPT_Wno_write_strings, options::OPT_w);
3158 if (WriteStrings &&
3159 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003160 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003161 }
3162
Chandler Carruth61fbf622011-04-23 09:27:53 +00003163 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003164 // during C++ compilation, which it is by default. GCC keeps this define even
3165 // in the presence of '-w', match this behavior bug-for-bug.
3166 if (types::isCXX(InputType) &&
3167 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3168 true)) {
3169 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003170 }
3171
Chandler Carruthe0391482010-05-22 02:21:53 +00003172 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3173 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3174 if (Asm->getOption().matches(options::OPT_fasm))
3175 CmdArgs.push_back("-fgnu-keywords");
3176 else
3177 CmdArgs.push_back("-fno-gnu-keywords");
3178 }
3179
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003180 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3181 CmdArgs.push_back("-fno-dwarf-directory-asm");
3182
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003183 if (ShouldDisableAutolink(Args, getToolChain()))
3184 CmdArgs.push_back("-fno-autolink");
3185
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003186 // Add in -fdebug-compilation-dir if necessary.
3187 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003188
Richard Smith9a568822011-11-21 19:36:32 +00003189 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3190 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003191 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003192 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003193 }
3194
Richard Smith79c927b2013-11-06 19:31:51 +00003195 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3196 CmdArgs.push_back("-foperator-arrow-depth");
3197 CmdArgs.push_back(A->getValue());
3198 }
3199
Richard Smith9a568822011-11-21 19:36:32 +00003200 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3201 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003202 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003203 }
3204
Richard Smitha3d3bd22013-05-08 02:12:03 +00003205 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3206 CmdArgs.push_back("-fconstexpr-steps");
3207 CmdArgs.push_back(A->getValue());
3208 }
3209
Richard Smithb3a14522013-02-22 01:59:51 +00003210 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3211 CmdArgs.push_back("-fbracket-depth");
3212 CmdArgs.push_back(A->getValue());
3213 }
3214
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003215 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3216 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003217 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003218 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003219 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3220 } else
3221 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003222 }
3223
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003224
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003225 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003226 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003227
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003228 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3229 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003230 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003231 }
David Chisnall5778fce2009-08-31 16:41:57 +00003232
Chris Lattnere23003d2010-01-09 21:54:33 +00003233 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3234 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003235 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003236 }
3237
Chris Lattnerb35583d2010-04-07 20:49:23 +00003238 CmdArgs.push_back("-ferror-limit");
3239 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003240 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003241 else
3242 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003243
Chandler Carrutha77a7272010-05-06 04:55:18 +00003244 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3245 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003246 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003247 }
3248
3249 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3250 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003251 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003252 }
3253
Richard Smithf6f003a2011-12-16 19:06:07 +00003254 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3255 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003256 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003257 }
3258
Daniel Dunbar2c978472009-11-04 06:24:47 +00003259 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003260 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003261 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003262 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003263 } else {
3264 // If -fmessage-length=N was not specified, determine whether this is a
3265 // terminal and, if so, implicitly define -fmessage-length appropriately.
3266 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003267 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003268 }
3269
John McCallb4a99d32013-02-19 01:57:35 +00003270 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3271 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3272 options::OPT_fvisibility_ms_compat)) {
3273 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3274 CmdArgs.push_back("-fvisibility");
3275 CmdArgs.push_back(A->getValue());
3276 } else {
3277 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3278 CmdArgs.push_back("-fvisibility");
3279 CmdArgs.push_back("hidden");
3280 CmdArgs.push_back("-ftype-visibility");
3281 CmdArgs.push_back("default");
3282 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003283 }
3284
Douglas Gregor08329632010-06-15 17:05:35 +00003285 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003286
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003287 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3288
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003289 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003290 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3291 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003292 CmdArgs.push_back("-ffreestanding");
3293
Daniel Dunbare357d562009-12-03 18:42:11 +00003294 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003295 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003296 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003297 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3298 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003299 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003300 // AltiVec language extensions aren't relevant for assembling.
3301 if (!isa<PreprocessJobAction>(JA) ||
3302 Output.getType() != types::TY_PP_Asm)
3303 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003304 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3305 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003306
Peter Collingbourne32701642013-11-01 18:16:25 +00003307 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3308 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003309
Will Dietz3676d562012-12-30 20:53:28 +00003310 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3311 options::OPT_fno_sanitize_recover,
3312 true))
3313 CmdArgs.push_back("-fno-sanitize-recover");
3314
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003315 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003316 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3317 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3318
Eric Christopher459d2712013-02-19 06:16:53 +00003319 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003320 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003321 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003322 getToolChain().getArch() == llvm::Triple::ppc64 ||
3323 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003324 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003325 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003326
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003327 if (getToolChain().SupportsProfiling())
3328 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003329
3330 // -flax-vector-conversions is default.
3331 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3332 options::OPT_fno_lax_vector_conversions))
3333 CmdArgs.push_back("-fno-lax-vector-conversions");
3334
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003335 if (Args.getLastArg(options::OPT_fapple_kext))
3336 CmdArgs.push_back("-fapple-kext");
3337
David Blaikie690f21e2012-06-14 18:55:27 +00003338 if (Args.hasFlag(options::OPT_frewrite_includes,
3339 options::OPT_fno_rewrite_includes, false))
3340 CmdArgs.push_back("-frewrite-includes");
3341
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003342 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003343 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003344 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003345 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3346 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003347
3348 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3349 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003350 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003351 }
3352
Bob Wilson14adb362012-02-03 06:27:22 +00003353 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003354
Chandler Carruth6e501032011-03-27 00:04:55 +00003355 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3356 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3357 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3358 options::OPT_fno_wrapv)) {
3359 if (A->getOption().matches(options::OPT_fwrapv))
3360 CmdArgs.push_back("-fwrapv");
3361 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3362 options::OPT_fno_strict_overflow)) {
3363 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3364 CmdArgs.push_back("-fwrapv");
3365 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003366
3367 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3368 options::OPT_fno_reroll_loops))
3369 if (A->getOption().matches(options::OPT_freroll_loops))
3370 CmdArgs.push_back("-freroll-loops");
3371
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003372 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003373 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3374 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003375
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003376 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3377
Mahesha S6a682be42012-10-27 07:47:56 +00003378
Daniel Dunbar4930e332009-11-17 08:07:36 +00003379 // -stack-protector=0 is default.
3380 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003381 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3382 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003383 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003384 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003385 if (A->getOption().matches(options::OPT_fstack_protector)) {
3386 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3387 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3388 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003389 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003390 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003391 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003392 } else {
3393 StackProtectorLevel =
3394 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3395 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003396 if (StackProtectorLevel) {
3397 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003398 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003399 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003400
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003401 // --param ssp-buffer-size=
3402 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3403 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003404 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003405 if (Str.startswith("ssp-buffer-size=")) {
3406 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003407 CmdArgs.push_back("-stack-protector-buffer-size");
3408 // FIXME: Verify the argument is a valid integer.
3409 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003410 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003411 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003412 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003413 }
3414
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003415 // Translate -mstackrealign
3416 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3417 false)) {
3418 CmdArgs.push_back("-backend-option");
3419 CmdArgs.push_back("-force-align-stack");
3420 }
3421 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3422 false)) {
3423 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3424 }
3425
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003426 if (Args.hasArg(options::OPT_mstack_alignment)) {
3427 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3428 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003429 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003430 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003431 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003432 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3433 options::OPT_munaligned_access)) {
3434 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3435 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003436 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3437 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3438 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003439 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003440 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003441 else
3442 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003443 } else {
3444 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003445 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3446 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3447 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003448 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003449 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003450 else
3451 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003452 }
Renato Golina146a482013-08-24 14:44:41 +00003453 }
Chad Rosier60027022012-11-09 17:29:19 +00003454 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003455
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003456 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3457 options::OPT_mno_restrict_it)) {
3458 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3459 CmdArgs.push_back("-backend-option");
3460 CmdArgs.push_back("-arm-restrict-it");
3461 } else {
3462 CmdArgs.push_back("-backend-option");
3463 CmdArgs.push_back("-arm-no-restrict-it");
3464 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003465 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3466 TT.getArch() == llvm::Triple::thumb)) {
3467 // Windows on ARM expects restricted IT blocks
3468 CmdArgs.push_back("-backend-option");
3469 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003470 }
3471
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003472 if (TT.getArch() == llvm::Triple::arm ||
3473 TT.getArch() == llvm::Triple::thumb) {
3474 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3475 options::OPT_mno_long_calls)) {
3476 if (A->getOption().matches(options::OPT_mlong_calls)) {
3477 CmdArgs.push_back("-backend-option");
3478 CmdArgs.push_back("-enable-arm-long-calls");
3479 }
3480 }
3481 }
3482
Daniel Dunbard18049a2009-04-07 21:16:11 +00003483 // Forward -f options with positive and negative forms; we translate
3484 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003485 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3486 StringRef fname = A->getValue();
3487 if (!llvm::sys::fs::exists(fname))
3488 D.Diag(diag::err_drv_no_such_file) << fname;
3489 else
3490 A->render(Args, CmdArgs);
3491 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003492
Diego Novillo829b1702014-04-16 16:54:24 +00003493 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3494 A->render(Args, CmdArgs);
3495
Diego Novillod23ec942014-05-29 19:55:06 +00003496 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3497 A->render(Args, CmdArgs);
3498
3499 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3500 A->render(Args, CmdArgs);
3501
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003502 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003503 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003504 CmdArgs.push_back("-fapple-kext");
3505 if (!Args.hasArg(options::OPT_fbuiltin))
3506 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003507 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003508 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003509 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003510 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003511 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003512
Nuno Lopes13c88c72009-12-16 16:59:22 +00003513 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3514 options::OPT_fno_assume_sane_operator_new))
3515 CmdArgs.push_back("-fno-assume-sane-operator-new");
3516
Daniel Dunbar4930e332009-11-17 08:07:36 +00003517 // -fblocks=0 is default.
3518 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003519 getToolChain().IsBlocksDefault()) ||
3520 (Args.hasArg(options::OPT_fgnu_runtime) &&
3521 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3522 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003523 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003524
3525 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3526 !getToolChain().hasBlocksRuntime())
3527 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003528 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003529
Douglas Gregor226173a2012-01-18 15:19:58 +00003530 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3531 // users must also pass -fcxx-modules. The latter flag will disappear once the
3532 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003533 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003534 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3535 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3536 options::OPT_fno_cxx_modules,
3537 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003538 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003539 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003540 HaveModules = true;
3541 }
3542 }
3543
Daniel Jasper07e6c402013-08-05 20:26:17 +00003544 // -fmodule-maps enables module map processing (off by default) for header
3545 // checking. It is implied by -fmodules.
3546 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3547 false)) {
3548 CmdArgs.push_back("-fmodule-maps");
3549 }
3550
Daniel Jasperac42b752013-10-21 06:34:34 +00003551 // -fmodules-decluse checks that modules used are declared so (off by
3552 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003553 if (Args.hasFlag(options::OPT_fmodules_decluse,
3554 options::OPT_fno_modules_decluse,
3555 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003556 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003557 }
3558
Daniel Jasper962b38e2014-04-11 11:47:45 +00003559 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3560 // all #included headers are part of modules.
3561 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3562 options::OPT_fno_modules_strict_decluse,
3563 false)) {
3564 CmdArgs.push_back("-fmodules-strict-decluse");
3565 }
3566
Daniel Jasperac42b752013-10-21 06:34:34 +00003567 // -fmodule-name specifies the module that is currently being built (or
3568 // used for header checking by -fmodule-maps).
3569 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3570 A->claim();
3571 A->render(Args, CmdArgs);
3572 }
3573
3574 // -fmodule-map-file can be used to specify a file containing module
3575 // definitions.
3576 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3577 A->claim();
3578 A->render(Args, CmdArgs);
3579 }
3580
Douglas Gregor35b04d62013-02-07 19:01:24 +00003581 // If a module path was provided, pass it along. Otherwise, use a temporary
3582 // directory.
3583 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3584 A->claim();
3585 if (HaveModules) {
3586 A->render(Args, CmdArgs);
3587 }
3588 } else if (HaveModules) {
3589 SmallString<128> DefaultModuleCache;
3590 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3591 DefaultModuleCache);
Douglas Gregor23c7d672013-03-21 21:48:48 +00003592 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3593 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor4bedb492013-02-07 22:59:12 +00003594 const char Arg[] = "-fmodules-cache-path=";
3595 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3596 Arg, Arg + strlen(Arg));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003597 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3598 }
3599
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003600 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path)) {
3601 A->claim();
3602 if (HaveModules) {
3603 A->render(Args, CmdArgs);
3604 }
3605 }
3606
Douglas Gregor35b04d62013-02-07 19:01:24 +00003607 // Pass through all -fmodules-ignore-macro arguments.
3608 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003609 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3610 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003611
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003612 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3613
3614 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3615 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3616 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3617
3618 Args.AddLastArg(CmdArgs,
3619 options::OPT_fmodules_validate_once_per_build_session);
3620 }
3621
Ben Langmuirdcf73862014-03-12 00:06:17 +00003622 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3623
John McCalldfea9982010-04-09 19:12:06 +00003624 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003625 if (Args.hasFlag(options::OPT_fno_access_control,
3626 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003627 false))
John McCall3155f572010-04-09 19:03:51 +00003628 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003629
Anders Carlssond470fef2010-11-21 00:09:52 +00003630 // -felide-constructors is the default.
3631 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3632 options::OPT_felide_constructors,
3633 false))
3634 CmdArgs.push_back("-fno-elide-constructors");
3635
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003636 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003637 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003638 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003639 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003640
Richard Smith52be6192012-11-05 22:04:41 +00003641 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003642 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003643 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003644 Args.getLastArg(options::OPT_mkernel,
3645 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003646 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003647 D.Diag(diag::err_drv_argument_not_allowed_with)
3648 << "-fsanitize=vptr" << NoRttiArg;
3649 }
3650 }
3651
Tony Linthicum76329bf2011-12-12 21:14:55 +00003652 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003653 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003654 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003655 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003656 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003657 CmdArgs.push_back("-fshort-enums");
3658
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003659 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003660 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003661 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003662 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003663
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003664 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003665 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003666 options::OPT_fno_threadsafe_statics))
3667 CmdArgs.push_back("-fno-threadsafe-statics");
3668
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003669 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003670 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3671 options::OPT_fno_use_cxa_atexit,
3672 !IsWindowsCygnus && !IsWindowsGNU &&
3673 getToolChain().getArch() != llvm::Triple::hexagon &&
3674 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003675 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003676 CmdArgs.push_back("-fno-use-cxa-atexit");
3677
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003678 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003679 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003680 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003681 CmdArgs.push_back("-fms-extensions");
3682
Francois Pichet1b4f1632011-09-17 04:32:15 +00003683 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003684 if (Args.hasFlag(options::OPT_fms_compatibility,
3685 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003686 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3687 options::OPT_fno_ms_extensions,
3688 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003689 CmdArgs.push_back("-fms-compatibility");
3690
Reid Klecknerc106fda2013-09-18 00:33:59 +00003691 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003692 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003693 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003694 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003695 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003696 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003697 else
3698 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3699 }
3700
3701
Eric Christopher5ecce122013-02-18 00:38:31 +00003702 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003703 if (Args.hasFlag(options::OPT_fborland_extensions,
3704 options::OPT_fno_borland_extensions, false))
3705 CmdArgs.push_back("-fborland-extensions");
3706
Francois Pichet02744872011-09-01 16:38:08 +00003707 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3708 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003709 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003710 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003711 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003712
Chandler Carruthe03aa552010-04-17 20:17:31 +00003713 // -fgnu-keywords default varies depending on language; only pass if
3714 // specified.
3715 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003716 options::OPT_fno_gnu_keywords))
3717 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003718
Rafael Espindola922a6242011-06-02 17:30:53 +00003719 if (Args.hasFlag(options::OPT_fgnu89_inline,
3720 options::OPT_fno_gnu89_inline,
3721 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003722 CmdArgs.push_back("-fgnu89-inline");
3723
Chad Rosier9c76d242012-03-15 22:31:42 +00003724 if (Args.hasArg(options::OPT_fno_inline))
3725 CmdArgs.push_back("-fno-inline");
3726
Chad Rosier64d6be92012-03-06 21:17:19 +00003727 if (Args.hasArg(options::OPT_fno_inline_functions))
3728 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003729
John McCall5fb5df92012-06-20 06:18:46 +00003730 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003731
John McCall5fb5df92012-06-20 06:18:46 +00003732 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003733 // legacy is the default. Except for deployment taget of 10.5,
3734 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3735 // gets ignored silently.
3736 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003737 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3738 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003739 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003740 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003741 if (getToolChain().UseObjCMixedDispatch())
3742 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3743 else
3744 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3745 }
3746 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003747
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003748 // When ObjectiveC legacy runtime is in effect on MacOSX,
3749 // turn on the option to do Array/Dictionary subscripting
3750 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003751 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3752 getToolChain().getTriple().isMacOSX() &&
3753 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3754 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003755 objcRuntime.isNeXTFamily())
3756 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3757
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003758 // -fencode-extended-block-signature=1 is default.
3759 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3760 CmdArgs.push_back("-fencode-extended-block-signature");
3761 }
3762
John McCall24fc0de2011-07-06 00:26:06 +00003763 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3764 // NOTE: This logic is duplicated in ToolChains.cpp.
3765 bool ARC = isObjCAutoRefCount(Args);
3766 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003767 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003768
John McCall24fc0de2011-07-06 00:26:06 +00003769 CmdArgs.push_back("-fobjc-arc");
3770
Chandler Carruth491db322011-11-04 07:34:47 +00003771 // FIXME: It seems like this entire block, and several around it should be
3772 // wrapped in isObjC, but for now we just use it here as this is where it
3773 // was being used previously.
3774 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3775 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3776 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3777 else
3778 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3779 }
3780
John McCall24fc0de2011-07-06 00:26:06 +00003781 // Allow the user to enable full exceptions code emission.
3782 // We define off for Objective-CC, on for Objective-C++.
3783 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3784 options::OPT_fno_objc_arc_exceptions,
3785 /*default*/ types::isCXX(InputType)))
3786 CmdArgs.push_back("-fobjc-arc-exceptions");
3787 }
3788
3789 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3790 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003791 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003792 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003793
John McCall24fc0de2011-07-06 00:26:06 +00003794 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3795 // takes precedence.
3796 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3797 if (!GCArg)
3798 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3799 if (GCArg) {
3800 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003801 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003802 << GCArg->getAsString(Args);
3803 } else if (getToolChain().SupportsObjCGC()) {
3804 GCArg->render(Args, CmdArgs);
3805 } else {
3806 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003807 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003808 << GCArg->getAsString(Args);
3809 }
3810 }
3811
John McCallb5f652e2011-06-22 00:53:57 +00003812 // Add exception args.
3813 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003814 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003815
3816 if (getToolChain().UseSjLjExceptions())
3817 CmdArgs.push_back("-fsjlj-exceptions");
3818
3819 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003820 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3821 options::OPT_fno_assume_sane_operator_new))
3822 CmdArgs.push_back("-fno-assume-sane-operator-new");
3823
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003824 // -fconstant-cfstrings is default, and may be subject to argument translation
3825 // on Darwin.
3826 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3827 options::OPT_fno_constant_cfstrings) ||
3828 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3829 options::OPT_mno_constant_cfstrings))
3830 CmdArgs.push_back("-fno-constant-cfstrings");
3831
John Thompsoned4e2952009-11-05 20:14:16 +00003832 // -fshort-wchar default varies depending on platform; only
3833 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003834 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3835 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003836 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003837
Hans Wennborg28c96312013-07-31 23:39:13 +00003838 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003839 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003840 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003841 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003842 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003843
Daniel Dunbar096ed292011-10-05 21:04:55 +00003844 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3845 // -fno-pack-struct doesn't apply to -fpack-struct=.
3846 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003847 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003848 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003849 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003850 } else if (Args.hasFlag(options::OPT_fpack_struct,
3851 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003852 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003853 }
3854
Robert Lytton0e076492013-08-13 09:43:10 +00003855 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003856 if (!Args.hasArg(options::OPT_fcommon))
3857 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003858 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003859 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003860
Daniel Dunbard18049a2009-04-07 21:16:11 +00003861 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003862 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003863 CmdArgs.push_back("-fno-common");
3864
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003865 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003866 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003867 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003868 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003869 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003870 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3871
Daniel Dunbar6358d682010-10-15 22:30:42 +00003872 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3873 if (!Args.hasFlag(options::OPT_ffor_scope,
3874 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003875 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003876 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3877
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003878 // -fcaret-diagnostics is default.
3879 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3880 options::OPT_fno_caret_diagnostics, true))
3881 CmdArgs.push_back("-fno-caret-diagnostics");
3882
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003883 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003884 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003885 options::OPT_fno_diagnostics_fixit_info))
3886 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003887
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003888 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003889 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003890 options::OPT_fno_diagnostics_show_option))
3891 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003892
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003893 if (const Arg *A =
3894 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3895 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003896 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003897 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003898
Douglas Gregor643c9222011-05-21 17:07:29 +00003899 if (const Arg *A =
3900 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3901 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003902 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003903 }
3904
Chandler Carruthb6766f02011-03-27 01:50:55 +00003905 if (Arg *A = Args.getLastArg(
3906 options::OPT_fdiagnostics_show_note_include_stack,
3907 options::OPT_fno_diagnostics_show_note_include_stack)) {
3908 if (A->getOption().matches(
3909 options::OPT_fdiagnostics_show_note_include_stack))
3910 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3911 else
3912 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3913 }
3914
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003915 // Color diagnostics are the default, unless the terminal doesn't support
3916 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003917 // Support both clang's -f[no-]color-diagnostics and gcc's
3918 // -f[no-]diagnostics-colors[=never|always|auto].
3919 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3920 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3921 it != ie; ++it) {
3922 const Option &O = (*it)->getOption();
3923 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3924 !O.matches(options::OPT_fdiagnostics_color) &&
3925 !O.matches(options::OPT_fno_color_diagnostics) &&
3926 !O.matches(options::OPT_fno_diagnostics_color) &&
3927 !O.matches(options::OPT_fdiagnostics_color_EQ))
3928 continue;
3929
3930 (*it)->claim();
3931 if (O.matches(options::OPT_fcolor_diagnostics) ||
3932 O.matches(options::OPT_fdiagnostics_color)) {
3933 ShowColors = Colors_On;
3934 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3935 O.matches(options::OPT_fno_diagnostics_color)) {
3936 ShowColors = Colors_Off;
3937 } else {
3938 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3939 StringRef value((*it)->getValue());
3940 if (value == "always")
3941 ShowColors = Colors_On;
3942 else if (value == "never")
3943 ShowColors = Colors_Off;
3944 else if (value == "auto")
3945 ShowColors = Colors_Auto;
3946 else
3947 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3948 << ("-fdiagnostics-color=" + value).str();
3949 }
3950 }
3951 if (ShowColors == Colors_On ||
3952 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003953 CmdArgs.push_back("-fcolor-diagnostics");
3954
Nico Rieck7857d462013-09-11 00:38:02 +00003955 if (Args.hasArg(options::OPT_fansi_escape_codes))
3956 CmdArgs.push_back("-fansi-escape-codes");
3957
Daniel Dunbardb097022009-06-08 21:13:54 +00003958 if (!Args.hasFlag(options::OPT_fshow_source_location,
3959 options::OPT_fno_show_source_location))
3960 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003961
Douglas Gregor643c9222011-05-21 17:07:29 +00003962 if (!Args.hasFlag(options::OPT_fshow_column,
3963 options::OPT_fno_show_column,
3964 true))
3965 CmdArgs.push_back("-fno-show-column");
3966
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003967 if (!Args.hasFlag(options::OPT_fspell_checking,
3968 options::OPT_fno_spell_checking))
3969 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003970
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003971
Chad Rosierc8e56e82012-12-05 21:08:21 +00003972 // -fno-asm-blocks is default.
3973 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3974 false))
3975 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003976
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003977 // Enable vectorization per default according to the optimization level
3978 // selected. For optimization levels that want vectorization we use the alias
3979 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003980 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003981 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003982 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003983 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003984 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003985 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003986
Chad Rosier136d67d2014-04-28 19:30:57 +00003987 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003988 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
3989 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00003990 options::OPT_fslp_vectorize;
3991 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003992 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00003993 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00003994
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003995 // -fno-slp-vectorize-aggressive is default.
3996 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003997 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003998 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00003999
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004000 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4001 A->render(Args, CmdArgs);
4002
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004003 // -fdollars-in-identifiers default varies depending on platform and
4004 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004005 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004006 options::OPT_fno_dollars_in_identifiers)) {
4007 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004008 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004009 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004010 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004011 }
4012
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004013 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4014 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004015 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004016 options::OPT_fno_unit_at_a_time)) {
4017 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004018 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004019 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004020
Eli Friedman055c9702011-11-02 01:53:16 +00004021 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4022 options::OPT_fno_apple_pragma_pack, false))
4023 CmdArgs.push_back("-fapple-pragma-pack");
4024
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004025 // le32-specific flags:
4026 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4027 // by default.
4028 if (getToolChain().getArch() == llvm::Triple::le32) {
4029 CmdArgs.push_back("-fno-math-builtin");
4030 }
4031
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004032 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004033 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004034 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004035#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004036 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004037 (getToolChain().getArch() == llvm::Triple::arm ||
4038 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004039 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4040 CmdArgs.push_back("-fno-builtin-strcat");
4041 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4042 CmdArgs.push_back("-fno-builtin-strcpy");
4043 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004044#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004045
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004046 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004047 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004048 options::OPT_traditional_cpp)) {
4049 if (isa<PreprocessJobAction>(JA))
4050 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004051 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004052 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004053 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004054
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004055 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004056 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004057
4058 // Handle serialized diagnostics.
4059 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4060 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004061 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004062 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004063
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004064 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4065 CmdArgs.push_back("-fretain-comments-from-system-headers");
4066
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004067 // Forward -fcomment-block-commands to -cc1.
4068 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004069 // Forward -fparse-all-comments to -cc1.
4070 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004071
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004072 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4073 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004074 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004075 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4076 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004077 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004078
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004079 // We translate this by hand to the -cc1 argument, since nightly test uses
4080 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004081 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004082 CmdArgs.push_back("-disable-llvm-optzns");
4083 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004084 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004085 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004086
Daniel Dunbard67a3222009-03-30 06:36:42 +00004087 if (Output.getType() == types::TY_Dependencies) {
4088 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004089 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004090 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004091 CmdArgs.push_back(Output.getFilename());
4092 } else {
4093 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004094 }
4095
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004096 for (InputInfoList::const_iterator
4097 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4098 const InputInfo &II = *it;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004099
4100 addDashXForInput(Args, II, CmdArgs);
4101
Daniel Dunbarb440f562010-08-02 02:38:21 +00004102 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004103 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004104 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004105 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004106 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004107
Chris Lattnere9d7d782009-11-03 19:50:27 +00004108 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4109
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004110 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004111
4112 // Optionally embed the -cc1 level arguments into the debug info, for build
4113 // analysis.
4114 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004115 ArgStringList OriginalArgs;
4116 for (ArgList::const_iterator it = Args.begin(),
4117 ie = Args.end(); it != ie; ++it)
4118 (*it)->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004119
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004120 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004121 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004122 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004123 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004124 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004125 }
4126 CmdArgs.push_back("-dwarf-debug-flags");
4127 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4128 }
4129
Eric Christopherd3804002013-02-22 20:12:52 +00004130 // Add the split debug info name to the command lines here so we
4131 // can propagate it to the backend.
4132 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004133 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004134 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004135 const char *SplitDwarfOut;
4136 if (SplitDwarf) {
4137 CmdArgs.push_back("-split-dwarf-file");
4138 SplitDwarfOut = SplitDebugName(Args, Inputs);
4139 CmdArgs.push_back(SplitDwarfOut);
4140 }
4141
4142 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004143 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004144 Output.getType() == types::TY_Object &&
4145 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00004146 tools::visualstudio::Compile CL(getToolChain());
4147 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
4148 LinkingOutput);
Reid Kleckner47c2f842014-05-14 16:03:05 +00004149 // RTTI support in clang-cl is a work in progress. Fall back to MSVC early
4150 // if we are using 'clang-cl /fallback /GR'.
4151 // FIXME: Remove this when RTTI is finished.
4152 if (Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti, false)) {
4153 D.Diag(diag::warn_drv_rtti_fallback) << CLCommand->getExecutable();
4154 C.addCommand(CLCommand);
4155 } else {
4156 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
4157 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00004158 } else {
4159 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4160 }
4161
Daniel Dunbar17731772009-03-23 19:03:36 +00004162
Eric Christopherf1545832013-02-22 23:50:16 +00004163 // Handle the debug info splitting at object creation time if we're
4164 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004165 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004166 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004167 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004168
Roman Divacky178e01602011-02-10 16:52:03 +00004169 if (Arg *A = Args.getLastArg(options::OPT_pg))
4170 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004171 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004172 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004173
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004174 // Claim some arguments which clang supports automatically.
4175
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004176 // -fpch-preprocess is used with gcc to add a special marker in the output to
4177 // include the PCH file. Clang's PTH solution is completely transparent, so we
4178 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004179 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004180
Daniel Dunbar17731772009-03-23 19:03:36 +00004181 // Claim some arguments which clang doesn't support, but we don't
4182 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004183 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4184 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004185
Rafael Espindolab0092d72013-09-04 19:37:35 +00004186 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004187 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004188}
4189
John McCall5fb5df92012-06-20 06:18:46 +00004190/// Add options related to the Objective-C runtime/ABI.
4191///
4192/// Returns true if the runtime is non-fragile.
4193ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4194 ArgStringList &cmdArgs,
4195 RewriteKind rewriteKind) const {
4196 // Look for the controlling runtime option.
4197 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4198 options::OPT_fgnu_runtime,
4199 options::OPT_fobjc_runtime_EQ);
4200
4201 // Just forward -fobjc-runtime= to the frontend. This supercedes
4202 // options about fragility.
4203 if (runtimeArg &&
4204 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4205 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004206 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004207 if (runtime.tryParse(value)) {
4208 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4209 << value;
4210 }
4211
4212 runtimeArg->render(args, cmdArgs);
4213 return runtime;
4214 }
4215
4216 // Otherwise, we'll need the ABI "version". Version numbers are
4217 // slightly confusing for historical reasons:
4218 // 1 - Traditional "fragile" ABI
4219 // 2 - Non-fragile ABI, version 1
4220 // 3 - Non-fragile ABI, version 2
4221 unsigned objcABIVersion = 1;
4222 // If -fobjc-abi-version= is present, use that to set the version.
4223 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004224 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004225 if (value == "1")
4226 objcABIVersion = 1;
4227 else if (value == "2")
4228 objcABIVersion = 2;
4229 else if (value == "3")
4230 objcABIVersion = 3;
4231 else
4232 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4233 << value;
4234 } else {
4235 // Otherwise, determine if we are using the non-fragile ABI.
4236 bool nonFragileABIIsDefault =
4237 (rewriteKind == RK_NonFragile ||
4238 (rewriteKind == RK_None &&
4239 getToolChain().IsObjCNonFragileABIDefault()));
4240 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4241 options::OPT_fno_objc_nonfragile_abi,
4242 nonFragileABIIsDefault)) {
4243 // Determine the non-fragile ABI version to use.
4244#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4245 unsigned nonFragileABIVersion = 1;
4246#else
4247 unsigned nonFragileABIVersion = 2;
4248#endif
4249
4250 if (Arg *abiArg = args.getLastArg(
4251 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004252 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004253 if (value == "1")
4254 nonFragileABIVersion = 1;
4255 else if (value == "2")
4256 nonFragileABIVersion = 2;
4257 else
4258 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4259 << value;
4260 }
4261
4262 objcABIVersion = 1 + nonFragileABIVersion;
4263 } else {
4264 objcABIVersion = 1;
4265 }
4266 }
4267
4268 // We don't actually care about the ABI version other than whether
4269 // it's non-fragile.
4270 bool isNonFragile = objcABIVersion != 1;
4271
4272 // If we have no runtime argument, ask the toolchain for its default runtime.
4273 // However, the rewriter only really supports the Mac runtime, so assume that.
4274 ObjCRuntime runtime;
4275 if (!runtimeArg) {
4276 switch (rewriteKind) {
4277 case RK_None:
4278 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4279 break;
4280 case RK_Fragile:
4281 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4282 break;
4283 case RK_NonFragile:
4284 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4285 break;
4286 }
4287
4288 // -fnext-runtime
4289 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4290 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004291 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004292 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4293
4294 // Otherwise, build for a generic macosx port.
4295 } else {
4296 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4297 }
4298
4299 // -fgnu-runtime
4300 } else {
4301 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004302 // Legacy behaviour is to target the gnustep runtime if we are i
4303 // non-fragile mode or the GCC runtime in fragile mode.
4304 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004305 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004306 else
4307 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004308 }
4309
4310 cmdArgs.push_back(args.MakeArgString(
4311 "-fobjc-runtime=" + runtime.getAsString()));
4312 return runtime;
4313}
4314
Hans Wennborg75958c42013-08-08 00:17:41 +00004315void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4316 unsigned RTOptionID = options::OPT__SLASH_MT;
4317
Hans Wennborgf1a74252013-09-10 20:18:04 +00004318 if (Args.hasArg(options::OPT__SLASH_LDd))
4319 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4320 // but defining _DEBUG is sticky.
4321 RTOptionID = options::OPT__SLASH_MTd;
4322
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004323 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004324 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004325
Hans Wennborg75958c42013-08-08 00:17:41 +00004326 switch(RTOptionID) {
4327 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004328 if (Args.hasArg(options::OPT__SLASH_LDd))
4329 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004330 CmdArgs.push_back("-D_MT");
4331 CmdArgs.push_back("-D_DLL");
4332 CmdArgs.push_back("--dependent-lib=msvcrt");
4333 break;
4334 case options::OPT__SLASH_MDd:
4335 CmdArgs.push_back("-D_DEBUG");
4336 CmdArgs.push_back("-D_MT");
4337 CmdArgs.push_back("-D_DLL");
4338 CmdArgs.push_back("--dependent-lib=msvcrtd");
4339 break;
4340 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004341 if (Args.hasArg(options::OPT__SLASH_LDd))
4342 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004343 CmdArgs.push_back("-D_MT");
4344 CmdArgs.push_back("--dependent-lib=libcmt");
4345 break;
4346 case options::OPT__SLASH_MTd:
4347 CmdArgs.push_back("-D_DEBUG");
4348 CmdArgs.push_back("-D_MT");
4349 CmdArgs.push_back("--dependent-lib=libcmtd");
4350 break;
4351 default:
4352 llvm_unreachable("Unexpected option ID.");
4353 }
4354
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004355 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4356 // users want. The /Za flag to cl.exe turns this off, but it's not
4357 // implemented in clang.
4358 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004359
Hans Wennborg0fd62072013-08-09 00:32:23 +00004360 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4361 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004362
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004363 // RTTI is currently not supported, so disable it by default.
4364 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4365 CmdArgs.push_back("-fno-rtti");
4366
David Majnemer86c318f2014-02-11 21:05:00 +00004367 const Driver &D = getToolChain().getDriver();
4368 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4369 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4370 if (MostGeneralArg && BestCaseArg)
4371 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4372 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4373
4374 if (MostGeneralArg) {
4375 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4376 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4377 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4378
4379 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4380 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4381 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4382 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4383 << FirstConflict->getAsString(Args)
4384 << SecondConflict->getAsString(Args);
4385
4386 if (SingleArg)
4387 CmdArgs.push_back("-fms-memptr-rep=single");
4388 else if (MultipleArg)
4389 CmdArgs.push_back("-fms-memptr-rep=multiple");
4390 else
4391 CmdArgs.push_back("-fms-memptr-rep=virtual");
4392 }
4393
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004394 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4395 A->render(Args, CmdArgs);
4396
Hans Wennborg81f74482013-09-10 01:07:07 +00004397 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4398 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004399 if (Args.hasArg(options::OPT__SLASH_fallback))
4400 CmdArgs.push_back("msvc-fallback");
4401 else
4402 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004403 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004404}
4405
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004406void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004407 const InputInfo &Output,
4408 const InputInfoList &Inputs,
4409 const ArgList &Args,
4410 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004411 ArgStringList CmdArgs;
4412
4413 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4414 const InputInfo &Input = Inputs[0];
4415
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004416 // Don't warn about "clang -w -c foo.s"
4417 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004418 // and "clang -emit-llvm -c foo.s"
4419 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004420
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004421 // Invoke ourselves in -cc1as mode.
4422 //
4423 // FIXME: Implement custom jobs for internal actions.
4424 CmdArgs.push_back("-cc1as");
4425
4426 // Add the "effective" target triple.
4427 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004428 std::string TripleStr =
4429 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004430 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4431
4432 // Set the output mode, we currently only expect to be used as a real
4433 // assembler.
4434 CmdArgs.push_back("-filetype");
4435 CmdArgs.push_back("obj");
4436
Eric Christopher45f2e712012-12-18 00:31:10 +00004437 // Set the main file name, so that debug info works even with
4438 // -save-temps or preprocessed assembly.
4439 CmdArgs.push_back("-main-file-name");
4440 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4441
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004442 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004443 const llvm::Triple &Triple = getToolChain().getTriple();
4444 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004445 if (!CPU.empty()) {
4446 CmdArgs.push_back("-target-cpu");
4447 CmdArgs.push_back(Args.MakeArgString(CPU));
4448 }
4449
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004450 // Add the target features
4451 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004452 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004453
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004454 // Ignore explicit -force_cpusubtype_ALL option.
4455 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004456
Eric Christopherfc3ee562012-01-10 00:38:01 +00004457 // Determine the original source input.
4458 const Action *SourceAction = &JA;
4459 while (SourceAction->getKind() != Action::InputClass) {
4460 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4461 SourceAction = SourceAction->getInputs()[0];
4462 }
4463
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004464 // Forward -g and handle debug info related flags, assuming we are dealing
4465 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004466 if (SourceAction->getType() == types::TY_Asm ||
4467 SourceAction->getType() == types::TY_PP_Asm) {
4468 Args.ClaimAllArgs(options::OPT_g_Group);
4469 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4470 if (!A->getOption().matches(options::OPT_g0))
4471 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004472
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004473 if (Args.hasArg(options::OPT_gdwarf_2))
4474 CmdArgs.push_back("-gdwarf-2");
4475 if (Args.hasArg(options::OPT_gdwarf_3))
4476 CmdArgs.push_back("-gdwarf-3");
4477 if (Args.hasArg(options::OPT_gdwarf_4))
4478 CmdArgs.push_back("-gdwarf-4");
4479
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004480 // Add the -fdebug-compilation-dir flag if needed.
4481 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004482
4483 // Set the AT_producer to the clang version when using the integrated
4484 // assembler on assembly source files.
4485 CmdArgs.push_back("-dwarf-debug-producer");
4486 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004487 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004488
4489 // Optionally embed the -cc1as level arguments into the debug info, for build
4490 // analysis.
4491 if (getToolChain().UseDwarfDebugFlags()) {
4492 ArgStringList OriginalArgs;
4493 for (ArgList::const_iterator it = Args.begin(),
4494 ie = Args.end(); it != ie; ++it)
4495 (*it)->render(Args, OriginalArgs);
4496
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004497 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004498 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4499 Flags += Exec;
4500 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4501 Flags += " ";
4502 Flags += OriginalArgs[i];
4503 }
4504 CmdArgs.push_back("-dwarf-debug-flags");
4505 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4506 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004507
4508 // FIXME: Add -static support, once we have it.
4509
David Blaikie372d9502014-01-17 03:17:40 +00004510 // Consume all the warning flags. Usually this would be handled more
4511 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4512 // doesn't handle that so rather than warning about unused flags that are
4513 // actually used, we'll lie by omission instead.
4514 // FIXME: Stop lying and consume only the appropriate driver flags
4515 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4516 ie = Args.filtered_end();
4517 it != ie; ++it)
4518 (*it)->claim();
4519
David Blaikie9260ed62013-07-25 21:19:01 +00004520 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4521 getToolChain().getDriver());
4522
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004523 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004524
4525 assert(Output.isFilename() && "Unexpected lipo output.");
4526 CmdArgs.push_back("-o");
4527 CmdArgs.push_back(Output.getFilename());
4528
Daniel Dunbarb440f562010-08-02 02:38:21 +00004529 assert(Input.isFilename() && "Invalid input.");
4530 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004531
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004532 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004533 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004534
4535 // Handle the debug info splitting at object creation time if we're
4536 // creating an object.
4537 // TODO: Currently only works on linux with newer objcopy.
4538 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004539 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004540 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4541 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004542}
4543
Daniel Dunbara3246a02009-03-18 08:07:30 +00004544void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004545 const InputInfo &Output,
4546 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004547 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004548 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004549 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004550 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004551
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004552 for (ArgList::const_iterator
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004553 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004554 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004555 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004556 // Don't forward any -g arguments to assembly steps.
4557 if (isa<AssembleJobAction>(JA) &&
4558 A->getOption().matches(options::OPT_g_Group))
4559 continue;
4560
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004561 // Don't forward any -W arguments to assembly and link steps.
4562 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4563 A->getOption().matches(options::OPT_W_Group))
4564 continue;
4565
Daniel Dunbar2da02722009-03-19 07:55:12 +00004566 // It is unfortunate that we have to claim here, as this means
4567 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004568 // platforms using a generic gcc, even if we are just using gcc
4569 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004570 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004571 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004572 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004573 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004574
Daniel Dunbar4e295052010-01-25 22:35:08 +00004575 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004576
4577 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004578 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004579 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004580 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004581
4582 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004583 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004584 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004585 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004586 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004587 else if (Arch == llvm::Triple::ppc64le)
4588 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004589 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004590 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004591 }
4592
Daniel Dunbar5716d872009-05-02 21:41:52 +00004593 // Try to force gcc to match the tool chain we want, if we recognize
4594 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004595 //
4596 // FIXME: The triple class should directly provide the information we want
4597 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004598 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004599 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004600 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4601 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004602 CmdArgs.push_back("-m64");
4603
Daniel Dunbarb440f562010-08-02 02:38:21 +00004604 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004605 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004606 CmdArgs.push_back(Output.getFilename());
4607 } else {
4608 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004609 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004610 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004611
Tony Linthicum76329bf2011-12-12 21:14:55 +00004612 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4613 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004614
4615 // Only pass -x if gcc will understand it; otherwise hope gcc
4616 // understands the suffix correctly. The main use case this would go
4617 // wrong in is for linker inputs if they happened to have an odd
4618 // suffix; really the only way to get this to happen is a command
4619 // like '-x foobar a.c' which will treat a.c like a linker input.
4620 //
4621 // FIXME: For the linker case specifically, can we safely convert
4622 // inputs into '-Wl,' options?
4623 for (InputInfoList::const_iterator
4624 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4625 const InputInfo &II = *it;
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004626
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004627 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004628 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4629 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004630 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004631 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004632 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004633 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004634 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004635 else if (II.getType() == types::TY_ModuleFile)
4636 D.Diag(diag::err_drv_no_module_support)
4637 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004638
Daniel Dunbara3246a02009-03-18 08:07:30 +00004639 if (types::canTypeBeUserSpecified(II.getType())) {
4640 CmdArgs.push_back("-x");
4641 CmdArgs.push_back(types::getTypeName(II.getType()));
4642 }
4643
Daniel Dunbarb440f562010-08-02 02:38:21 +00004644 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004645 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004646 else {
4647 const Arg &A = II.getInputArg();
4648
4649 // Reverse translate some rewritten options.
4650 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4651 CmdArgs.push_back("-lstdc++");
4652 continue;
4653 }
4654
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004655 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004656 A.render(Args, CmdArgs);
4657 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004658 }
4659
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004660 const std::string customGCCName = D.getCCCGenericGCCName();
4661 const char *GCCName;
4662 if (!customGCCName.empty())
4663 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004664 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004665 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004666 } else
4667 GCCName = "gcc";
4668
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004669 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004670 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004671 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004672}
4673
Daniel Dunbar4e295052010-01-25 22:35:08 +00004674void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4675 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004676 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004677}
4678
Daniel Dunbar4e295052010-01-25 22:35:08 +00004679void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4680 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004681 const Driver &D = getToolChain().getDriver();
4682
Daniel Dunbar4e295052010-01-25 22:35:08 +00004683 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004684 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4685 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004686 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004687 else {
4688 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004689 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004690 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004691
Daniel Dunbar4e295052010-01-25 22:35:08 +00004692 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004693 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004694}
4695
Daniel Dunbar4e295052010-01-25 22:35:08 +00004696void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4697 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004698 // The types are (hopefully) good enough.
4699}
4700
Tony Linthicum76329bf2011-12-12 21:14:55 +00004701// Hexagon tools start.
4702void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4703 ArgStringList &CmdArgs) const {
4704
4705}
4706void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4707 const InputInfo &Output,
4708 const InputInfoList &Inputs,
4709 const ArgList &Args,
4710 const char *LinkingOutput) const {
4711
4712 const Driver &D = getToolChain().getDriver();
4713 ArgStringList CmdArgs;
4714
4715 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004716 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004717 CmdArgs.push_back(Args.MakeArgString(MarchString));
4718
4719 RenderExtraToolArgs(JA, CmdArgs);
4720
4721 if (Output.isFilename()) {
4722 CmdArgs.push_back("-o");
4723 CmdArgs.push_back(Output.getFilename());
4724 } else {
4725 assert(Output.isNothing() && "Unexpected output");
4726 CmdArgs.push_back("-fsyntax-only");
4727 }
4728
Matthew Curtise8f80a12012-12-06 17:49:03 +00004729 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4730 if (!SmallDataThreshold.empty())
4731 CmdArgs.push_back(
4732 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004733
Matthew Curtise5df3812012-12-07 17:23:04 +00004734 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4735 options::OPT_Xassembler);
4736
Tony Linthicum76329bf2011-12-12 21:14:55 +00004737 // Only pass -x if gcc will understand it; otherwise hope gcc
4738 // understands the suffix correctly. The main use case this would go
4739 // wrong in is for linker inputs if they happened to have an odd
4740 // suffix; really the only way to get this to happen is a command
4741 // like '-x foobar a.c' which will treat a.c like a linker input.
4742 //
4743 // FIXME: For the linker case specifically, can we safely convert
4744 // inputs into '-Wl,' options?
4745 for (InputInfoList::const_iterator
4746 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4747 const InputInfo &II = *it;
4748
4749 // Don't try to pass LLVM or AST inputs to a generic gcc.
4750 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4751 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4752 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4753 << getToolChain().getTripleString();
4754 else if (II.getType() == types::TY_AST)
4755 D.Diag(clang::diag::err_drv_no_ast_support)
4756 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004757 else if (II.getType() == types::TY_ModuleFile)
4758 D.Diag(diag::err_drv_no_module_support)
4759 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004760
4761 if (II.isFilename())
4762 CmdArgs.push_back(II.getFilename());
4763 else
4764 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4765 II.getInputArg().render(Args, CmdArgs);
4766 }
4767
4768 const char *GCCName = "hexagon-as";
4769 const char *Exec =
4770 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4771 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4772
4773}
4774void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4775 ArgStringList &CmdArgs) const {
4776 // The types are (hopefully) good enough.
4777}
4778
4779void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4780 const InputInfo &Output,
4781 const InputInfoList &Inputs,
4782 const ArgList &Args,
4783 const char *LinkingOutput) const {
4784
Matthew Curtise689b052012-12-06 15:46:07 +00004785 const toolchains::Hexagon_TC& ToolChain =
4786 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4787 const Driver &D = ToolChain.getDriver();
4788
Tony Linthicum76329bf2011-12-12 21:14:55 +00004789 ArgStringList CmdArgs;
4790
Matthew Curtise689b052012-12-06 15:46:07 +00004791 //----------------------------------------------------------------------------
4792 //
4793 //----------------------------------------------------------------------------
4794 bool hasStaticArg = Args.hasArg(options::OPT_static);
4795 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004796 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004797 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4798 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4799 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4800 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004801
Matthew Curtise689b052012-12-06 15:46:07 +00004802 //----------------------------------------------------------------------------
4803 // Silence warnings for various options
4804 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004805
Matthew Curtise689b052012-12-06 15:46:07 +00004806 Args.ClaimAllArgs(options::OPT_g_Group);
4807 Args.ClaimAllArgs(options::OPT_emit_llvm);
4808 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4809 // handled somewhere else.
4810 Args.ClaimAllArgs(options::OPT_static_libgcc);
4811
4812 //----------------------------------------------------------------------------
4813 //
4814 //----------------------------------------------------------------------------
4815 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4816 e = ToolChain.ExtraOpts.end();
4817 i != e; ++i)
4818 CmdArgs.push_back(i->c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004819
Matthew Curtisf10a5952012-12-06 14:16:43 +00004820 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4821 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004822
Matthew Curtise689b052012-12-06 15:46:07 +00004823 if (buildingLib) {
4824 CmdArgs.push_back("-shared");
4825 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4826 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004827 }
4828
Matthew Curtise689b052012-12-06 15:46:07 +00004829 if (hasStaticArg)
4830 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004831
Matthew Curtise8f80a12012-12-06 17:49:03 +00004832 if (buildPIE && !buildingLib)
4833 CmdArgs.push_back("-pie");
4834
4835 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4836 if (!SmallDataThreshold.empty()) {
4837 CmdArgs.push_back(
4838 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4839 }
4840
Matthew Curtise689b052012-12-06 15:46:07 +00004841 //----------------------------------------------------------------------------
4842 //
4843 //----------------------------------------------------------------------------
4844 CmdArgs.push_back("-o");
4845 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004846
Matthew Curtise689b052012-12-06 15:46:07 +00004847 const std::string MarchSuffix = "/" + MarchString;
4848 const std::string G0Suffix = "/G0";
4849 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4850 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4851 + "/";
4852 const std::string StartFilesDir = RootDir
4853 + "hexagon/lib"
4854 + (buildingLib
4855 ? MarchG0Suffix : MarchSuffix);
4856
4857 //----------------------------------------------------------------------------
4858 // moslib
4859 //----------------------------------------------------------------------------
4860 std::vector<std::string> oslibs;
4861 bool hasStandalone= false;
4862
4863 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4864 ie = Args.filtered_end(); it != ie; ++it) {
4865 (*it)->claim();
4866 oslibs.push_back((*it)->getValue());
4867 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004868 }
Matthew Curtise689b052012-12-06 15:46:07 +00004869 if (oslibs.empty()) {
4870 oslibs.push_back("standalone");
4871 hasStandalone = true;
4872 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004873
Matthew Curtise689b052012-12-06 15:46:07 +00004874 //----------------------------------------------------------------------------
4875 // Start Files
4876 //----------------------------------------------------------------------------
4877 if (incStdLib && incStartFiles) {
4878
4879 if (!buildingLib) {
4880 if (hasStandalone) {
4881 CmdArgs.push_back(
4882 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4883 }
4884 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4885 }
4886 std::string initObj = useShared ? "/initS.o" : "/init.o";
4887 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4888 }
4889
4890 //----------------------------------------------------------------------------
4891 // Library Search Paths
4892 //----------------------------------------------------------------------------
4893 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4894 for (ToolChain::path_list::const_iterator
4895 i = LibPaths.begin(),
4896 e = LibPaths.end();
4897 i != e;
4898 ++i)
4899 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4900
4901 //----------------------------------------------------------------------------
4902 //
4903 //----------------------------------------------------------------------------
4904 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4905 Args.AddAllArgs(CmdArgs, options::OPT_e);
4906 Args.AddAllArgs(CmdArgs, options::OPT_s);
4907 Args.AddAllArgs(CmdArgs, options::OPT_t);
4908 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4909
4910 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4911
4912 //----------------------------------------------------------------------------
4913 // Libraries
4914 //----------------------------------------------------------------------------
4915 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004916 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004917 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4918 CmdArgs.push_back("-lm");
4919 }
4920
4921 CmdArgs.push_back("--start-group");
4922
4923 if (!buildingLib) {
4924 for(std::vector<std::string>::iterator i = oslibs.begin(),
4925 e = oslibs.end(); i != e; ++i)
4926 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4927 CmdArgs.push_back("-lc");
4928 }
4929 CmdArgs.push_back("-lgcc");
4930
4931 CmdArgs.push_back("--end-group");
4932 }
4933
4934 //----------------------------------------------------------------------------
4935 // End files
4936 //----------------------------------------------------------------------------
4937 if (incStdLib && incStartFiles) {
4938 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4939 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4940 }
4941
4942 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004943 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004944}
4945// Hexagon tools end.
4946
Bernard Ogden31561762013-12-12 13:27:11 +00004947/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4948//
4949// FIXME: tblgen this.
4950const char *arm::getARMCPUForMArch(const ArgList &Args,
4951 const llvm::Triple &Triple) {
4952 StringRef MArch;
4953 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4954 // Otherwise, if we have -march= choose the base CPU for that arch.
4955 MArch = A->getValue();
4956 } else {
4957 // Otherwise, use the Arch from the triple.
4958 MArch = Triple.getArchName();
4959 }
4960
4961 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004962 if (MArch == "native") {
4963 std::string CPU = llvm::sys::getHostCPUName();
4964 if (CPU != "generic") {
4965 // Translate the native cpu into the architecture. The switch below will
4966 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004967 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004968 }
4969 }
4970
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004971 switch (Triple.getOS()) {
4972 case llvm::Triple::NetBSD:
Bernard Ogden31561762013-12-12 13:27:11 +00004973 if (MArch == "armv6")
4974 return "arm1176jzf-s";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004975 break;
4976 case llvm::Triple::Win32:
4977 // FIXME: this is invalid for WindowsCE
4978 return "cortex-a9";
4979 default:
4980 break;
Bernard Ogden31561762013-12-12 13:27:11 +00004981 }
4982
Christian Pirker918d1092014-05-05 08:48:18 +00004983 const char *result = nullptr;
4984 size_t offset = StringRef::npos;
4985 if (MArch.startswith("arm"))
4986 offset = 3;
4987 if (MArch.startswith("thumb"))
4988 offset = 5;
4989 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
4990 offset += 2;
4991 if (offset != StringRef::npos)
4992 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
4993 .Cases("v2", "v2a", "arm2")
4994 .Case("v3", "arm6")
4995 .Case("v3m", "arm7m")
4996 .Case("v4", "strongarm")
4997 .Case("v4t", "arm7tdmi")
4998 .Cases("v5", "v5t", "arm10tdmi")
4999 .Cases("v5e", "v5te", "arm1022e")
5000 .Case("v5tej", "arm926ej-s")
5001 .Cases("v6", "v6k", "arm1136jf-s")
5002 .Case("v6j", "arm1136j-s")
5003 .Cases("v6z", "v6zk", "arm1176jzf-s")
5004 .Case("v6t2", "arm1156t2-s")
5005 .Cases("v6m", "v6-m", "cortex-m0")
5006 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
5007 .Cases("v7s", "v7-s", "swift")
5008 .Cases("v7r", "v7-r", "cortex-r4")
5009 .Cases("v7m", "v7-m", "cortex-m3")
5010 .Cases("v7em", "v7e-m", "cortex-m4")
5011 .Cases("v8", "v8a", "v8-a", "cortex-a53")
5012 .Default(nullptr);
5013 else
5014 result = llvm::StringSwitch<const char *>(MArch)
5015 .Case("ep9312", "ep9312")
5016 .Case("iwmmxt", "iwmmxt")
5017 .Case("xscale", "xscale")
5018 .Default(nullptr);
Bernard Ogden31561762013-12-12 13:27:11 +00005019
5020 if (result)
5021 return result;
5022
Christian Pirker918d1092014-05-05 08:48:18 +00005023 // If all else failed, return the most base CPU with thumb interworking
5024 // supported by LLVM.
5025 // FIXME: Should warn once that we're falling back.
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00005026 switch (Triple.getOS()) {
5027 case llvm::Triple::NetBSD:
5028 switch (Triple.getEnvironment()) {
5029 case llvm::Triple::GNUEABIHF:
5030 case llvm::Triple::GNUEABI:
5031 case llvm::Triple::EABIHF:
5032 case llvm::Triple::EABI:
5033 return "arm926ej-s";
5034 default:
5035 return "strongarm";
5036 }
5037 default:
5038 switch (Triple.getEnvironment()) {
5039 case llvm::Triple::EABIHF:
5040 case llvm::Triple::GNUEABIHF:
5041 return "arm1176jzf-s";
5042 default:
5043 return "arm7tdmi";
5044 }
5045 }
Bernard Ogden31561762013-12-12 13:27:11 +00005046}
5047
5048/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005049StringRef arm::getARMTargetCPU(const ArgList &Args,
5050 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005051 // FIXME: Warn on inconsistent use of -mcpu and -march.
5052 // If we have -mcpu=, use that.
5053 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5054 StringRef MCPU = A->getValue();
5055 // Handle -mcpu=native.
5056 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005057 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005058 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005059 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005060 }
5061
5062 return getARMCPUForMArch(Args, Triple);
5063}
5064
5065/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5066/// CPU.
5067//
5068// FIXME: This is redundant with -mcpu, why does LLVM use this.
5069// FIXME: tblgen this, or kill it!
5070const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5071 return llvm::StringSwitch<const char *>(CPU)
5072 .Case("strongarm", "v4")
5073 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5074 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5075 .Cases("arm920", "arm920t", "arm922t", "v4t")
5076 .Cases("arm940t", "ep9312","v4t")
5077 .Cases("arm10tdmi", "arm1020t", "v5")
5078 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5079 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5080 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5081 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5082 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5083 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005084 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005085 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5086 .Cases("cortex-r4", "cortex-r5", "v7r")
5087 .Case("cortex-m0", "v6m")
5088 .Case("cortex-m3", "v7m")
5089 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005090 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005091 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005092 .Cases("cortex-a53", "cortex-a57", "v8")
5093 .Default("");
5094}
5095
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005096bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5097 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5098 return A && (A->getValue() == StringRef(Value));
5099}
5100
Tim Northover157d9112014-01-16 08:48:16 +00005101llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005102 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5103 // archs which Darwin doesn't use.
5104
5105 // The matching this routine does is fairly pointless, since it is neither the
5106 // complete architecture list, nor a reasonable subset. The problem is that
5107 // historically the driver driver accepts this and also ties its -march=
5108 // handling to the architecture name, so we need to be careful before removing
5109 // support for it.
5110
5111 // This code must be kept in sync with Clang's Darwin specific argument
5112 // translation.
5113
5114 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5115 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5116 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5117 .Case("ppc64", llvm::Triple::ppc64)
5118 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5119 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5120 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005121 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005122 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005123 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005124 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005125 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005126 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005127 .Case("r600", llvm::Triple::r600)
5128 .Case("nvptx", llvm::Triple::nvptx)
5129 .Case("nvptx64", llvm::Triple::nvptx64)
5130 .Case("amdil", llvm::Triple::amdil)
5131 .Case("spir", llvm::Triple::spir)
5132 .Default(llvm::Triple::UnknownArch);
5133}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005134
Tim Northover157d9112014-01-16 08:48:16 +00005135void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5136 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5137 T.setArch(Arch);
5138
5139 if (Str == "x86_64h")
5140 T.setArchName(Str);
5141 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5142 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005143 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005144 }
5145}
5146
Bob Wilsondecc03e2012-11-23 06:14:39 +00005147const char *Clang::getBaseInputName(const ArgList &Args,
5148 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005149 return Args.MakeArgString(
5150 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005151}
5152
Bob Wilsondecc03e2012-11-23 06:14:39 +00005153const char *Clang::getBaseInputStem(const ArgList &Args,
5154 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005155 const char *Str = getBaseInputName(Args, Inputs);
5156
Chris Lattner906bb902011-01-16 08:14:11 +00005157 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005158 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005159
5160 return Str;
5161}
5162
Bob Wilsondecc03e2012-11-23 06:14:39 +00005163const char *Clang::getDependencyFileName(const ArgList &Args,
5164 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005165 // FIXME: Think about this more.
5166 std::string Res;
5167
5168 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005169 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005170 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005171 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005172 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005173 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005174 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005175}
5176
Daniel Dunbarbe220842009-03-20 16:06:39 +00005177void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005178 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005179 const InputInfoList &Inputs,
5180 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005181 const char *LinkingOutput) const {
5182 ArgStringList CmdArgs;
5183
5184 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5185 const InputInfo &Input = Inputs[0];
5186
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005187 // Determine the original source input.
5188 const Action *SourceAction = &JA;
5189 while (SourceAction->getKind() != Action::InputClass) {
5190 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5191 SourceAction = SourceAction->getInputs()[0];
5192 }
5193
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005194 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005195 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005196 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5197 // FIXME: at run-time detect assembler capabilities or rely on version
5198 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005199 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005200 const llvm::Triple &T(getToolChain().getTriple());
5201 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005202 CmdArgs.push_back("-Q");
5203 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005204
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005205 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005206 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005207 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005208 if (Args.hasArg(options::OPT_gstabs))
5209 CmdArgs.push_back("--gstabs");
5210 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005211 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005212 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005213
Daniel Dunbarbe220842009-03-20 16:06:39 +00005214 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005215 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005216
Daniel Dunbar6d484762010-07-22 01:47:22 +00005217 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005218 if (getToolChain().getArch() == llvm::Triple::x86 ||
5219 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005220 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5221 CmdArgs.push_back("-force_cpusubtype_ALL");
5222
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005223 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005224 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005225 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005226 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005227 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005228 CmdArgs.push_back("-static");
5229
Daniel Dunbarbe220842009-03-20 16:06:39 +00005230 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5231 options::OPT_Xassembler);
5232
5233 assert(Output.isFilename() && "Unexpected lipo output.");
5234 CmdArgs.push_back("-o");
5235 CmdArgs.push_back(Output.getFilename());
5236
Daniel Dunbarb440f562010-08-02 02:38:21 +00005237 assert(Input.isFilename() && "Invalid input.");
5238 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005239
5240 // asm_final spec is empty.
5241
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005242 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005243 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005244 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005245}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005246
Tim Northover157d9112014-01-16 08:48:16 +00005247void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005248
Tim Northover157d9112014-01-16 08:48:16 +00005249void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5250 ArgStringList &CmdArgs) const {
5251 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005252
Daniel Dunbarc1964212009-03-26 16:23:12 +00005253 // Derived from darwin_arch spec.
5254 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005255 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005256
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005257 // FIXME: Is this needed anymore?
5258 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005259 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005260}
5261
Bill Wendling3b2000f2012-10-02 18:02:50 +00005262bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5263 // We only need to generate a temp path for LTO if we aren't compiling object
5264 // files. When compiling source files, we run 'dsymutil' after linking. We
5265 // don't run 'dsymutil' when compiling object files.
5266 for (InputInfoList::const_iterator
5267 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
5268 if (it->getType() != types::TY_Object)
5269 return true;
5270
5271 return false;
5272}
5273
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005274void darwin::Link::AddLinkArgs(Compilation &C,
5275 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005276 ArgStringList &CmdArgs,
5277 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005278 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005279 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005280
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005281 unsigned Version[3] = { 0, 0, 0 };
5282 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5283 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005284 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005285 Version[1], Version[2], HadExtra) ||
5286 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005287 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005288 << A->getAsString(Args);
5289 }
5290
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005291 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005292 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005293 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5294 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005295
Bob Wilson3d27dad2013-08-02 22:25:34 +00005296 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5297 CmdArgs.push_back("-export_dynamic");
5298
Bill Wendling313b6bf2012-11-16 23:03:00 +00005299 // If we are using LTO, then automatically create a temporary file path for
5300 // the linker to use, so that it's lifetime will extend past a possible
5301 // dsymutil step.
5302 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5303 const char *TmpPath = C.getArgs().MakeArgString(
5304 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5305 C.addTempFile(TmpPath);
5306 CmdArgs.push_back("-object_path_lto");
5307 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005308 }
5309
Daniel Dunbarc1964212009-03-26 16:23:12 +00005310 // Derived from the "link" spec.
5311 Args.AddAllArgs(CmdArgs, options::OPT_static);
5312 if (!Args.hasArg(options::OPT_static))
5313 CmdArgs.push_back("-dynamic");
5314 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5315 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5316 // here. How do we wish to handle such things?
5317 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005318
Daniel Dunbarc1964212009-03-26 16:23:12 +00005319 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005320 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005321 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005322 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005323
5324 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5325 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5326 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5327
5328 Arg *A;
5329 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5330 (A = Args.getLastArg(options::OPT_current__version)) ||
5331 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005332 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005333 << A->getAsString(Args) << "-dynamiclib";
5334
5335 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5336 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5337 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5338 } else {
5339 CmdArgs.push_back("-dylib");
5340
5341 Arg *A;
5342 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5343 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5344 (A = Args.getLastArg(options::OPT_client__name)) ||
5345 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5346 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5347 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005348 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005349 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005350
Daniel Dunbarc1964212009-03-26 16:23:12 +00005351 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5352 "-dylib_compatibility_version");
5353 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5354 "-dylib_current_version");
5355
Tim Northover157d9112014-01-16 08:48:16 +00005356 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005357
5358 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5359 "-dylib_install_name");
5360 }
5361
5362 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5363 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5364 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005365 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005366 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005367 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5368 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5369 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5370 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5371 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5372 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005373 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005374 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5375 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5376 Args.AddAllArgs(CmdArgs, options::OPT_init);
5377
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005378 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005379 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005380
Daniel Dunbarc1964212009-03-26 16:23:12 +00005381 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5382 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5383 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5384 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5385 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005386
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005387 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5388 options::OPT_fno_pie,
5389 options::OPT_fno_PIE)) {
5390 if (A->getOption().matches(options::OPT_fpie) ||
5391 A->getOption().matches(options::OPT_fPIE))
5392 CmdArgs.push_back("-pie");
5393 else
5394 CmdArgs.push_back("-no_pie");
5395 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005396
5397 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5398 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5399 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5400 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5401 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5402 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5403 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5404 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5405 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5406 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5407 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5408 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5409 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5410 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5411 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5412 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005413
Daniel Dunbar84384642011-05-02 21:03:47 +00005414 // Give --sysroot= preference, over the Apple specific behavior to also use
5415 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005416 StringRef sysroot = C.getSysRoot();
5417 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005418 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005419 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005420 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5421 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005422 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005423 }
5424
Daniel Dunbarc1964212009-03-26 16:23:12 +00005425 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5426 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5427 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5428 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5429 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005430 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005431 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5432 Args.AddAllArgs(CmdArgs, options::OPT_y);
5433 Args.AddLastArg(CmdArgs, options::OPT_w);
5434 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5435 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5436 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5437 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5438 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5439 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5440 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5441 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5442 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5443 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5444 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5445 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5446}
5447
Alexey Bataev186b28a2014-03-06 05:43:53 +00005448enum LibOpenMP {
5449 LibUnknown,
5450 LibGOMP,
5451 LibIOMP5
5452};
5453
Daniel Dunbarc1964212009-03-26 16:23:12 +00005454void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005455 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005456 const InputInfoList &Inputs,
5457 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005458 const char *LinkingOutput) const {
5459 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005460
Daniel Dunbarc1964212009-03-26 16:23:12 +00005461 // The logic here is derived from gcc's behavior; most of which
5462 // comes from specs (starting with link_command). Consult gcc for
5463 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005464 ArgStringList CmdArgs;
5465
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005466 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5467 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5468 options::OPT_ccc_arcmt_migrate)) {
5469 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
5470 (*I)->claim();
5471 const char *Exec =
5472 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5473 CmdArgs.push_back(Output.getFilename());
5474 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5475 return;
5476 }
5477
Daniel Dunbarc1964212009-03-26 16:23:12 +00005478 // I'm not sure why this particular decomposition exists in gcc, but
5479 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005480 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005481
Daniel Dunbarc1964212009-03-26 16:23:12 +00005482 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5483 Args.AddAllArgs(CmdArgs, options::OPT_s);
5484 Args.AddAllArgs(CmdArgs, options::OPT_t);
5485 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5486 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005487 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005488 Args.AddAllArgs(CmdArgs, options::OPT_r);
5489
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005490 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5491 // members of static archive libraries which implement Objective-C classes or
5492 // categories.
5493 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5494 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005495
Daniel Dunbarc1964212009-03-26 16:23:12 +00005496 CmdArgs.push_back("-o");
5497 CmdArgs.push_back(Output.getFilename());
5498
Chad Rosier06fd3c62012-05-16 23:45:12 +00005499 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005500 !Args.hasArg(options::OPT_nostartfiles))
5501 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005502
5503 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005504
Alexey Bataev186b28a2014-03-06 05:43:53 +00005505 LibOpenMP UsedOpenMPLib = LibUnknown;
5506 if (Args.hasArg(options::OPT_fopenmp)) {
5507 UsedOpenMPLib = LibGOMP;
5508 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5509 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5510 .Case("libgomp", LibGOMP)
5511 .Case("libiomp5", LibIOMP5)
5512 .Default(LibUnknown);
5513 if (UsedOpenMPLib == LibUnknown)
5514 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5515 << A->getOption().getName() << A->getValue();
5516 }
5517 switch (UsedOpenMPLib) {
5518 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005519 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005520 break;
5521 case LibIOMP5:
5522 CmdArgs.push_back("-liomp5");
5523 break;
5524 case LibUnknown:
5525 break;
5526 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005527
Douglas Gregor9295df02012-05-15 21:00:27 +00005528 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5529
Bob Wilson16d93952012-05-15 18:57:39 +00005530 if (isObjCRuntimeLinked(Args) &&
5531 !Args.hasArg(options::OPT_nostdlib) &&
5532 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005533 // We use arclite library for both ARC and subscripting support.
5534 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5535
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005536 CmdArgs.push_back("-framework");
5537 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005538 // Link libobj.
5539 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005540 }
John McCall31168b02011-06-15 23:02:42 +00005541
Daniel Dunbarc1964212009-03-26 16:23:12 +00005542 if (LinkingOutput) {
5543 CmdArgs.push_back("-arch_multiple");
5544 CmdArgs.push_back("-final_output");
5545 CmdArgs.push_back(LinkingOutput);
5546 }
5547
Daniel Dunbarc1964212009-03-26 16:23:12 +00005548 if (Args.hasArg(options::OPT_fnested_functions))
5549 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005550
Daniel Dunbarc1964212009-03-26 16:23:12 +00005551 if (!Args.hasArg(options::OPT_nostdlib) &&
5552 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005553 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005554 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005555
Daniel Dunbarc1964212009-03-26 16:23:12 +00005556 // link_ssp spec is empty.
5557
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005558 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005559 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005560 }
5561
Chad Rosier06fd3c62012-05-16 23:45:12 +00005562 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005563 !Args.hasArg(options::OPT_nostartfiles)) {
5564 // endfile_spec is empty.
5565 }
5566
5567 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5568 Args.AddAllArgs(CmdArgs, options::OPT_F);
5569
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005570 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005571 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005572 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005573}
5574
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005575void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005576 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005577 const InputInfoList &Inputs,
5578 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005579 const char *LinkingOutput) const {
5580 ArgStringList CmdArgs;
5581
5582 CmdArgs.push_back("-create");
5583 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005584
5585 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005586 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005587
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005588 for (InputInfoList::const_iterator
5589 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5590 const InputInfo &II = *it;
5591 assert(II.isFilename() && "Unexpected lipo input.");
5592 CmdArgs.push_back(II.getFilename());
5593 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005594 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005595 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005596 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005597}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005598
Daniel Dunbar88299622010-06-04 18:28:36 +00005599void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005600 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005601 const InputInfoList &Inputs,
5602 const ArgList &Args,
5603 const char *LinkingOutput) const {
5604 ArgStringList CmdArgs;
5605
Daniel Dunbareb86b042011-05-09 17:23:16 +00005606 CmdArgs.push_back("-o");
5607 CmdArgs.push_back(Output.getFilename());
5608
Daniel Dunbar88299622010-06-04 18:28:36 +00005609 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5610 const InputInfo &Input = Inputs[0];
5611 assert(Input.isFilename() && "Unexpected dsymutil input.");
5612 CmdArgs.push_back(Input.getFilename());
5613
Daniel Dunbar88299622010-06-04 18:28:36 +00005614 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005615 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005616 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005617}
5618
Eric Christopher551ef452011-08-23 17:56:55 +00005619void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005620 const InputInfo &Output,
5621 const InputInfoList &Inputs,
5622 const ArgList &Args,
5623 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005624 ArgStringList CmdArgs;
5625 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005626 CmdArgs.push_back("--debug-info");
5627 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005628 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005629
5630 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5631 const InputInfo &Input = Inputs[0];
5632 assert(Input.isFilename() && "Unexpected verify input");
5633
5634 // Grabbing the output of the earlier dsymutil run.
5635 CmdArgs.push_back(Input.getFilename());
5636
5637 const char *Exec =
5638 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5639 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5640}
5641
David Chisnallf571cde2012-02-15 13:39:01 +00005642void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5643 const InputInfo &Output,
5644 const InputInfoList &Inputs,
5645 const ArgList &Args,
5646 const char *LinkingOutput) const {
5647 ArgStringList CmdArgs;
5648
5649 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5650 options::OPT_Xassembler);
5651
5652 CmdArgs.push_back("-o");
5653 CmdArgs.push_back(Output.getFilename());
5654
5655 for (InputInfoList::const_iterator
5656 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5657 const InputInfo &II = *it;
5658 CmdArgs.push_back(II.getFilename());
5659 }
5660
5661 const char *Exec =
5662 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5663 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5664}
5665
5666
5667void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5668 const InputInfo &Output,
5669 const InputInfoList &Inputs,
5670 const ArgList &Args,
5671 const char *LinkingOutput) const {
5672 // FIXME: Find a real GCC, don't hard-code versions here
5673 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5674 const llvm::Triple &T = getToolChain().getTriple();
5675 std::string LibPath = "/usr/lib/";
5676 llvm::Triple::ArchType Arch = T.getArch();
5677 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005678 case llvm::Triple::x86:
5679 GCCLibPath +=
5680 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5681 break;
5682 case llvm::Triple::x86_64:
5683 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5684 GCCLibPath += "/4.5.2/amd64/";
5685 LibPath += "amd64/";
5686 break;
5687 default:
5688 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005689 }
5690
5691 ArgStringList CmdArgs;
5692
David Chisnall272a0712012-02-29 15:06:12 +00005693 // Demangle C++ names in errors
5694 CmdArgs.push_back("-C");
5695
David Chisnallf571cde2012-02-15 13:39:01 +00005696 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5697 (!Args.hasArg(options::OPT_shared))) {
5698 CmdArgs.push_back("-e");
5699 CmdArgs.push_back("_start");
5700 }
5701
5702 if (Args.hasArg(options::OPT_static)) {
5703 CmdArgs.push_back("-Bstatic");
5704 CmdArgs.push_back("-dn");
5705 } else {
5706 CmdArgs.push_back("-Bdynamic");
5707 if (Args.hasArg(options::OPT_shared)) {
5708 CmdArgs.push_back("-shared");
5709 } else {
5710 CmdArgs.push_back("--dynamic-linker");
5711 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5712 }
5713 }
5714
5715 if (Output.isFilename()) {
5716 CmdArgs.push_back("-o");
5717 CmdArgs.push_back(Output.getFilename());
5718 } else {
5719 assert(Output.isNothing() && "Invalid output.");
5720 }
5721
5722 if (!Args.hasArg(options::OPT_nostdlib) &&
5723 !Args.hasArg(options::OPT_nostartfiles)) {
5724 if (!Args.hasArg(options::OPT_shared)) {
5725 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5726 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005727 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005728 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5729 } else {
5730 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005731 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5732 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005733 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005734 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005735 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005736 }
5737
5738 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5739
5740 Args.AddAllArgs(CmdArgs, options::OPT_L);
5741 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5742 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005743 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005744
5745 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5746
5747 if (!Args.hasArg(options::OPT_nostdlib) &&
5748 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005749 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005750 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005751 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005752 if (!Args.hasArg(options::OPT_shared)) {
5753 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005754 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005755 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005756 }
David Chisnallf571cde2012-02-15 13:39:01 +00005757 }
5758
5759 if (!Args.hasArg(options::OPT_nostdlib) &&
5760 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005761 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005762 }
David Chisnall96de9932012-02-16 16:00:47 +00005763 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005764
Alexey Samsonov7811d192014-02-20 13:57:37 +00005765 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005766
5767 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005768 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005769 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5770}
5771
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005772void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005773 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005774 const InputInfoList &Inputs,
5775 const ArgList &Args,
5776 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005777 ArgStringList CmdArgs;
5778
5779 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5780 options::OPT_Xassembler);
5781
5782 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005783 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005784
5785 for (InputInfoList::const_iterator
5786 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5787 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005788 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005789 }
5790
5791 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005792 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005793 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005794}
5795
5796void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005797 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005798 const InputInfoList &Inputs,
5799 const ArgList &Args,
5800 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005801 ArgStringList CmdArgs;
5802
5803 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005804 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005805 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005806 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005807 }
5808
5809 if (Args.hasArg(options::OPT_static)) {
5810 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005811 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005812 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005813// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005814 CmdArgs.push_back("-Bdynamic");
5815 if (Args.hasArg(options::OPT_shared)) {
5816 CmdArgs.push_back("-shared");
5817 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005818 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005819 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5820 }
5821 }
5822
Daniel Dunbarb440f562010-08-02 02:38:21 +00005823 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005824 CmdArgs.push_back("-o");
5825 CmdArgs.push_back(Output.getFilename());
5826 } else {
5827 assert(Output.isNothing() && "Invalid output.");
5828 }
5829
5830 if (!Args.hasArg(options::OPT_nostdlib) &&
5831 !Args.hasArg(options::OPT_nostartfiles)) {
5832 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005833 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005834 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005835 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005836 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005837 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005838 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005839 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005840 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005841 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005842 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005843 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005844 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005845 }
5846
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005847 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5848 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005849 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005850
5851 Args.AddAllArgs(CmdArgs, options::OPT_L);
5852 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5853 Args.AddAllArgs(CmdArgs, options::OPT_e);
5854
Daniel Dunbar54423b22010-09-17 00:24:54 +00005855 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005856
5857 if (!Args.hasArg(options::OPT_nostdlib) &&
5858 !Args.hasArg(options::OPT_nodefaultlibs)) {
5859 // FIXME: For some reason GCC passes -lgcc before adding
5860 // the default system libraries. Just mimic this for now.
5861 CmdArgs.push_back("-lgcc");
5862
5863 if (Args.hasArg(options::OPT_pthread))
5864 CmdArgs.push_back("-pthread");
5865 if (!Args.hasArg(options::OPT_shared))
5866 CmdArgs.push_back("-lc");
5867 CmdArgs.push_back("-lgcc");
5868 }
5869
5870 if (!Args.hasArg(options::OPT_nostdlib) &&
5871 !Args.hasArg(options::OPT_nostartfiles)) {
5872 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005873 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005874 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005875 }
5876
Alexey Samsonov7811d192014-02-20 13:57:37 +00005877 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005878
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005879 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005880 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005881 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005882}
5883
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005884void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005885 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005886 const InputInfoList &Inputs,
5887 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005888 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005889 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005890 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005891
Rafael Espindolacc126272014-02-28 01:55:21 +00005892 switch (getToolChain().getArch()) {
5893 case llvm::Triple::x86:
5894 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5895 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005896 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005897 break;
5898
5899 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005900 CmdArgs.push_back("-mppc");
5901 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005902 break;
5903
5904 case llvm::Triple::sparc:
5905 CmdArgs.push_back("-32");
5906 NeedsKPIC = true;
5907 break;
5908
5909 case llvm::Triple::sparcv9:
5910 CmdArgs.push_back("-64");
5911 CmdArgs.push_back("-Av9a");
5912 NeedsKPIC = true;
5913 break;
5914
5915 case llvm::Triple::mips64:
5916 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005917 StringRef CPUName;
5918 StringRef ABIName;
5919 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5920
5921 CmdArgs.push_back("-mabi");
5922 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5923
5924 if (getToolChain().getArch() == llvm::Triple::mips64)
5925 CmdArgs.push_back("-EB");
5926 else
5927 CmdArgs.push_back("-EL");
5928
Rafael Espindolacc126272014-02-28 01:55:21 +00005929 NeedsKPIC = true;
5930 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005931 }
5932
Rafael Espindolacc126272014-02-28 01:55:21 +00005933 default:
5934 break;
5935 }
5936
5937 if (NeedsKPIC)
5938 addAssemblerKPIC(Args, CmdArgs);
5939
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005940 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5941 options::OPT_Xassembler);
5942
5943 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005944 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005945
5946 for (InputInfoList::const_iterator
5947 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5948 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00005949 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005950 }
5951
5952 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005953 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005954 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005955}
5956
5957void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005958 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005959 const InputInfoList &Inputs,
5960 const ArgList &Args,
5961 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005962 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005963 ArgStringList CmdArgs;
5964
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005965 // Silence warning for "clang -g foo.o -o foo"
5966 Args.ClaimAllArgs(options::OPT_g_Group);
5967 // and "clang -emit-llvm foo.o -o foo"
5968 Args.ClaimAllArgs(options::OPT_emit_llvm);
5969 // and for "clang -w foo.o -o foo". Other warning options are already
5970 // handled somewhere else.
5971 Args.ClaimAllArgs(options::OPT_w);
5972
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005973 if (getToolChain().getArch() == llvm::Triple::mips64)
5974 CmdArgs.push_back("-EB");
5975 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5976 CmdArgs.push_back("-EL");
5977
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005978 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005979 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005980 CmdArgs.push_back("-e");
5981 CmdArgs.push_back("__start");
5982 }
5983
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005984 if (Args.hasArg(options::OPT_static)) {
5985 CmdArgs.push_back("-Bstatic");
5986 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005987 if (Args.hasArg(options::OPT_rdynamic))
5988 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005989 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005990 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005991 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005992 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005993 } else {
5994 CmdArgs.push_back("-dynamic-linker");
5995 CmdArgs.push_back("/usr/libexec/ld.so");
5996 }
5997 }
5998
Rafael Espindola044f7832013-06-05 04:28:55 +00005999 if (Args.hasArg(options::OPT_nopie))
6000 CmdArgs.push_back("-nopie");
6001
Daniel Dunbarb440f562010-08-02 02:38:21 +00006002 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006003 CmdArgs.push_back("-o");
6004 CmdArgs.push_back(Output.getFilename());
6005 } else {
6006 assert(Output.isNothing() && "Invalid output.");
6007 }
6008
6009 if (!Args.hasArg(options::OPT_nostdlib) &&
6010 !Args.hasArg(options::OPT_nostartfiles)) {
6011 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006012 if (Args.hasArg(options::OPT_pg))
6013 CmdArgs.push_back(Args.MakeArgString(
6014 getToolChain().GetFilePath("gcrt0.o")));
6015 else
6016 CmdArgs.push_back(Args.MakeArgString(
6017 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006018 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006019 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006020 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006021 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006022 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006023 }
6024 }
6025
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006026 std::string Triple = getToolChain().getTripleString();
6027 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006028 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006029 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006030 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006031
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006032 Args.AddAllArgs(CmdArgs, options::OPT_L);
6033 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6034 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006035 Args.AddAllArgs(CmdArgs, options::OPT_s);
6036 Args.AddAllArgs(CmdArgs, options::OPT_t);
6037 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6038 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006039
Daniel Dunbar54423b22010-09-17 00:24:54 +00006040 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006041
6042 if (!Args.hasArg(options::OPT_nostdlib) &&
6043 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006044 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006045 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006046 if (Args.hasArg(options::OPT_pg))
6047 CmdArgs.push_back("-lm_p");
6048 else
6049 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006050 }
6051
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006052 // FIXME: For some reason GCC passes -lgcc before adding
6053 // the default system libraries. Just mimic this for now.
6054 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006055
Eric Christopher17674ec2012-09-13 06:32:34 +00006056 if (Args.hasArg(options::OPT_pthread)) {
6057 if (!Args.hasArg(options::OPT_shared) &&
6058 Args.hasArg(options::OPT_pg))
6059 CmdArgs.push_back("-lpthread_p");
6060 else
6061 CmdArgs.push_back("-lpthread");
6062 }
6063
Chandler Carruth45661652011-12-17 22:32:42 +00006064 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006065 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006066 CmdArgs.push_back("-lc_p");
6067 else
6068 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006069 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006070
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006071 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006072 }
6073
6074 if (!Args.hasArg(options::OPT_nostdlib) &&
6075 !Args.hasArg(options::OPT_nostartfiles)) {
6076 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006077 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006078 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006079 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006080 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006081 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006082 }
6083
6084 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006085 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006086 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006087}
Ed Schoutene33194b2009-04-02 19:13:12 +00006088
Eli Friedman9fa28852012-08-08 23:57:20 +00006089void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6090 const InputInfo &Output,
6091 const InputInfoList &Inputs,
6092 const ArgList &Args,
6093 const char *LinkingOutput) const {
6094 ArgStringList CmdArgs;
6095
6096 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6097 options::OPT_Xassembler);
6098
6099 CmdArgs.push_back("-o");
6100 CmdArgs.push_back(Output.getFilename());
6101
6102 for (InputInfoList::const_iterator
6103 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6104 const InputInfo &II = *it;
6105 CmdArgs.push_back(II.getFilename());
6106 }
6107
6108 const char *Exec =
6109 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6110 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6111}
6112
6113void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6114 const InputInfo &Output,
6115 const InputInfoList &Inputs,
6116 const ArgList &Args,
6117 const char *LinkingOutput) const {
6118 const Driver &D = getToolChain().getDriver();
6119 ArgStringList CmdArgs;
6120
6121 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6122 (!Args.hasArg(options::OPT_shared))) {
6123 CmdArgs.push_back("-e");
6124 CmdArgs.push_back("__start");
6125 }
6126
6127 if (Args.hasArg(options::OPT_static)) {
6128 CmdArgs.push_back("-Bstatic");
6129 } else {
6130 if (Args.hasArg(options::OPT_rdynamic))
6131 CmdArgs.push_back("-export-dynamic");
6132 CmdArgs.push_back("--eh-frame-hdr");
6133 CmdArgs.push_back("-Bdynamic");
6134 if (Args.hasArg(options::OPT_shared)) {
6135 CmdArgs.push_back("-shared");
6136 } else {
6137 CmdArgs.push_back("-dynamic-linker");
6138 CmdArgs.push_back("/usr/libexec/ld.so");
6139 }
6140 }
6141
6142 if (Output.isFilename()) {
6143 CmdArgs.push_back("-o");
6144 CmdArgs.push_back(Output.getFilename());
6145 } else {
6146 assert(Output.isNothing() && "Invalid output.");
6147 }
6148
6149 if (!Args.hasArg(options::OPT_nostdlib) &&
6150 !Args.hasArg(options::OPT_nostartfiles)) {
6151 if (!Args.hasArg(options::OPT_shared)) {
6152 if (Args.hasArg(options::OPT_pg))
6153 CmdArgs.push_back(Args.MakeArgString(
6154 getToolChain().GetFilePath("gcrt0.o")));
6155 else
6156 CmdArgs.push_back(Args.MakeArgString(
6157 getToolChain().GetFilePath("crt0.o")));
6158 CmdArgs.push_back(Args.MakeArgString(
6159 getToolChain().GetFilePath("crtbegin.o")));
6160 } else {
6161 CmdArgs.push_back(Args.MakeArgString(
6162 getToolChain().GetFilePath("crtbeginS.o")));
6163 }
6164 }
6165
6166 Args.AddAllArgs(CmdArgs, options::OPT_L);
6167 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6168 Args.AddAllArgs(CmdArgs, options::OPT_e);
6169
6170 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6171
6172 if (!Args.hasArg(options::OPT_nostdlib) &&
6173 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006174 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006175 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6176 if (Args.hasArg(options::OPT_pg))
6177 CmdArgs.push_back("-lm_p");
6178 else
6179 CmdArgs.push_back("-lm");
6180 }
6181
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006182 if (Args.hasArg(options::OPT_pthread)) {
6183 if (!Args.hasArg(options::OPT_shared) &&
6184 Args.hasArg(options::OPT_pg))
6185 CmdArgs.push_back("-lpthread_p");
6186 else
6187 CmdArgs.push_back("-lpthread");
6188 }
6189
Eli Friedman9fa28852012-08-08 23:57:20 +00006190 if (!Args.hasArg(options::OPT_shared)) {
6191 if (Args.hasArg(options::OPT_pg))
6192 CmdArgs.push_back("-lc_p");
6193 else
6194 CmdArgs.push_back("-lc");
6195 }
6196
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006197 StringRef MyArch;
6198 switch (getToolChain().getTriple().getArch()) {
6199 case llvm::Triple::arm:
6200 MyArch = "arm";
6201 break;
6202 case llvm::Triple::x86:
6203 MyArch = "i386";
6204 break;
6205 case llvm::Triple::x86_64:
6206 MyArch = "amd64";
6207 break;
6208 default:
6209 llvm_unreachable("Unsupported architecture");
6210 }
6211 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006212 }
6213
6214 if (!Args.hasArg(options::OPT_nostdlib) &&
6215 !Args.hasArg(options::OPT_nostartfiles)) {
6216 if (!Args.hasArg(options::OPT_shared))
6217 CmdArgs.push_back(Args.MakeArgString(
6218 getToolChain().GetFilePath("crtend.o")));
6219 else
6220 CmdArgs.push_back(Args.MakeArgString(
6221 getToolChain().GetFilePath("crtendS.o")));
6222 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006223
6224 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006225 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006226 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006227}
6228
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006229void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006230 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006231 const InputInfoList &Inputs,
6232 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006233 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006234 ArgStringList CmdArgs;
6235
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006236 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6237 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006238 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006239 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006240 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006241 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006242 else if (getToolChain().getArch() == llvm::Triple::mips ||
6243 getToolChain().getArch() == llvm::Triple::mipsel ||
6244 getToolChain().getArch() == llvm::Triple::mips64 ||
6245 getToolChain().getArch() == llvm::Triple::mips64el) {
6246 StringRef CPUName;
6247 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006248 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006249
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006250 CmdArgs.push_back("-march");
6251 CmdArgs.push_back(CPUName.data());
6252
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006253 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006254 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006255
6256 if (getToolChain().getArch() == llvm::Triple::mips ||
6257 getToolChain().getArch() == llvm::Triple::mips64)
6258 CmdArgs.push_back("-EB");
6259 else
6260 CmdArgs.push_back("-EL");
6261
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006262 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006263 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006264 getToolChain().getArch() == llvm::Triple::armeb ||
6265 getToolChain().getArch() == llvm::Triple::thumb ||
6266 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006267 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006268 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006269 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6270
6271 if (FloatABI == "hard") {
6272 CmdArgs.push_back("-mfpu=vfp");
6273 } else {
6274 CmdArgs.push_back("-mfpu=softvfp");
6275 }
6276
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006277 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006278 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006279 case llvm::Triple::GNUEABI:
6280 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006281 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006282 break;
6283
6284 default:
6285 CmdArgs.push_back("-matpcs");
6286 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006287 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006288 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006289 if (getToolChain().getArch() == llvm::Triple::sparc)
6290 CmdArgs.push_back("-Av8plusa");
6291 else
6292 CmdArgs.push_back("-Av9a");
6293
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006294 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006295 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006296
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006297 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6298 options::OPT_Xassembler);
6299
6300 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006301 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006302
6303 for (InputInfoList::const_iterator
6304 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6305 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00006306 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006307 }
6308
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006309 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006310 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006311 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006312}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006313
6314void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006315 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006316 const InputInfoList &Inputs,
6317 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006318 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006319 const toolchains::FreeBSD& ToolChain =
6320 static_cast<const toolchains::FreeBSD&>(getToolChain());
6321 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006322 const bool IsPIE =
6323 !Args.hasArg(options::OPT_shared) &&
6324 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006325 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006326
6327 // Silence warning for "clang -g foo.o -o foo"
6328 Args.ClaimAllArgs(options::OPT_g_Group);
6329 // and "clang -emit-llvm foo.o -o foo"
6330 Args.ClaimAllArgs(options::OPT_emit_llvm);
6331 // and for "clang -w foo.o -o foo". Other warning options are already
6332 // handled somewhere else.
6333 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006334
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006335 if (!D.SysRoot.empty())
6336 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6337
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006338 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006339 CmdArgs.push_back("-pie");
6340
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006341 if (Args.hasArg(options::OPT_static)) {
6342 CmdArgs.push_back("-Bstatic");
6343 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006344 if (Args.hasArg(options::OPT_rdynamic))
6345 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006346 CmdArgs.push_back("--eh-frame-hdr");
6347 if (Args.hasArg(options::OPT_shared)) {
6348 CmdArgs.push_back("-Bshareable");
6349 } else {
6350 CmdArgs.push_back("-dynamic-linker");
6351 CmdArgs.push_back("/libexec/ld-elf.so.1");
6352 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006353 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6354 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006355 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6356 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6357 CmdArgs.push_back("--hash-style=both");
6358 }
6359 }
6360 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006361 }
6362
6363 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6364 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006365 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006366 CmdArgs.push_back("-m");
6367 CmdArgs.push_back("elf_i386_fbsd");
6368 }
6369
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006370 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006371 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006372 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006373 }
6374
Daniel Dunbarb440f562010-08-02 02:38:21 +00006375 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006376 CmdArgs.push_back("-o");
6377 CmdArgs.push_back(Output.getFilename());
6378 } else {
6379 assert(Output.isNothing() && "Invalid output.");
6380 }
6381
6382 if (!Args.hasArg(options::OPT_nostdlib) &&
6383 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006384 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006385 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006386 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006387 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006388 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006389 crt1 = "Scrt1.o";
6390 else
6391 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006392 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006393 if (crt1)
6394 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6395
6396 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6397
Craig Topper92fc2df2014-05-17 16:56:41 +00006398 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006399 if (Args.hasArg(options::OPT_static))
6400 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006401 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006402 crtbegin = "crtbeginS.o";
6403 else
6404 crtbegin = "crtbegin.o";
6405
6406 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006407 }
6408
6409 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006410 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divackyee8188a2011-03-01 17:53:14 +00006411 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6412 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006413 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006414 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6415 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006416 Args.AddAllArgs(CmdArgs, options::OPT_s);
6417 Args.AddAllArgs(CmdArgs, options::OPT_t);
6418 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6419 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006420
Alp Tokerce365ca2013-12-02 12:43:03 +00006421 if (D.IsUsingLTO(Args))
6422 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006423
Roman Divackyafe2f232012-08-28 15:09:03 +00006424 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006425
6426 if (!Args.hasArg(options::OPT_nostdlib) &&
6427 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006428 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006429 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006430 if (Args.hasArg(options::OPT_pg))
6431 CmdArgs.push_back("-lm_p");
6432 else
6433 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006434 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006435 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6436 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006437 if (Args.hasArg(options::OPT_pg))
6438 CmdArgs.push_back("-lgcc_p");
6439 else
6440 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006441 if (Args.hasArg(options::OPT_static)) {
6442 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006443 } else if (Args.hasArg(options::OPT_pg)) {
6444 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006445 } else {
6446 CmdArgs.push_back("--as-needed");
6447 CmdArgs.push_back("-lgcc_s");
6448 CmdArgs.push_back("--no-as-needed");
6449 }
6450
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006451 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006452 if (Args.hasArg(options::OPT_pg))
6453 CmdArgs.push_back("-lpthread_p");
6454 else
6455 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006456 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006457
Roman Divacky66f22762011-02-10 16:59:40 +00006458 if (Args.hasArg(options::OPT_pg)) {
6459 if (Args.hasArg(options::OPT_shared))
6460 CmdArgs.push_back("-lc");
6461 else
6462 CmdArgs.push_back("-lc_p");
6463 CmdArgs.push_back("-lgcc_p");
6464 } else {
6465 CmdArgs.push_back("-lc");
6466 CmdArgs.push_back("-lgcc");
6467 }
6468
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006469 if (Args.hasArg(options::OPT_static)) {
6470 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006471 } else if (Args.hasArg(options::OPT_pg)) {
6472 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006473 } else {
6474 CmdArgs.push_back("--as-needed");
6475 CmdArgs.push_back("-lgcc_s");
6476 CmdArgs.push_back("--no-as-needed");
6477 }
6478 }
6479
6480 if (!Args.hasArg(options::OPT_nostdlib) &&
6481 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006482 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006483 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006484 else
6485 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006486 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006487 }
6488
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006489 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6490
Alexey Samsonov7811d192014-02-20 13:57:37 +00006491 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006492
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006493 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006494 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006495 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006496}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006497
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006498void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6499 const InputInfo &Output,
6500 const InputInfoList &Inputs,
6501 const ArgList &Args,
6502 const char *LinkingOutput) const {
6503 ArgStringList CmdArgs;
6504
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006505 // GNU as needs different flags for creating the correct output format
6506 // on architectures with different ABIs or optional feature sets.
6507 switch (getToolChain().getArch()) {
6508 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006509 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006510 break;
6511 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006512 case llvm::Triple::armeb:
6513 case llvm::Triple::thumb:
6514 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006515 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006516 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006517 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006518 }
6519
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006520 case llvm::Triple::mips:
6521 case llvm::Triple::mipsel:
6522 case llvm::Triple::mips64:
6523 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006524 StringRef CPUName;
6525 StringRef ABIName;
6526 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6527
6528 CmdArgs.push_back("-march");
6529 CmdArgs.push_back(CPUName.data());
6530
6531 CmdArgs.push_back("-mabi");
6532 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6533
6534 if (getToolChain().getArch() == llvm::Triple::mips ||
6535 getToolChain().getArch() == llvm::Triple::mips64)
6536 CmdArgs.push_back("-EB");
6537 else
6538 CmdArgs.push_back("-EL");
6539
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006540 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006541 break;
6542 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006543
6544 case llvm::Triple::sparc:
6545 CmdArgs.push_back("-32");
6546 addAssemblerKPIC(Args, CmdArgs);
6547 break;
6548
6549 case llvm::Triple::sparcv9:
6550 CmdArgs.push_back("-64");
6551 CmdArgs.push_back("-Av9");
6552 addAssemblerKPIC(Args, CmdArgs);
6553 break;
6554
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006555 default:
6556 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006557 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006558
6559 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6560 options::OPT_Xassembler);
6561
6562 CmdArgs.push_back("-o");
6563 CmdArgs.push_back(Output.getFilename());
6564
6565 for (InputInfoList::const_iterator
6566 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6567 const InputInfo &II = *it;
6568 CmdArgs.push_back(II.getFilename());
6569 }
6570
David Chisnallddbd68f2011-09-27 22:03:18 +00006571 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006572 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6573}
6574
6575void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6576 const InputInfo &Output,
6577 const InputInfoList &Inputs,
6578 const ArgList &Args,
6579 const char *LinkingOutput) const {
6580 const Driver &D = getToolChain().getDriver();
6581 ArgStringList CmdArgs;
6582
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006583 if (!D.SysRoot.empty())
6584 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6585
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006586 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006587 if (Args.hasArg(options::OPT_static)) {
6588 CmdArgs.push_back("-Bstatic");
6589 } else {
6590 if (Args.hasArg(options::OPT_rdynamic))
6591 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006592 if (Args.hasArg(options::OPT_shared)) {
6593 CmdArgs.push_back("-Bshareable");
6594 } else {
6595 CmdArgs.push_back("-dynamic-linker");
6596 CmdArgs.push_back("/libexec/ld.elf_so");
6597 }
6598 }
6599
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006600 // Many NetBSD architectures support more than one ABI.
6601 // Determine the correct emulation for ld.
6602 switch (getToolChain().getArch()) {
6603 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006604 CmdArgs.push_back("-m");
6605 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006606 break;
6607 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006608 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006609 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006610 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006611 CmdArgs.push_back("-m");
6612 switch (getToolChain().getTriple().getEnvironment()) {
6613 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006614 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006615 CmdArgs.push_back("armelf_nbsd_eabi");
6616 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006617 case llvm::Triple::EABIHF:
6618 case llvm::Triple::GNUEABIHF:
6619 CmdArgs.push_back("armelf_nbsd_eabihf");
6620 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006621 default:
6622 CmdArgs.push_back("armelf_nbsd");
6623 break;
6624 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006625 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006626 case llvm::Triple::mips64:
6627 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006628 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006629 CmdArgs.push_back("-m");
6630 if (getToolChain().getArch() == llvm::Triple::mips64)
6631 CmdArgs.push_back("elf32btsmip");
6632 else
6633 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006634 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006635 CmdArgs.push_back("-m");
6636 if (getToolChain().getArch() == llvm::Triple::mips64)
6637 CmdArgs.push_back("elf64btsmip");
6638 else
6639 CmdArgs.push_back("elf64ltsmip");
6640 }
6641 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006642
6643 case llvm::Triple::sparc:
6644 CmdArgs.push_back("-m");
6645 CmdArgs.push_back("elf32_sparc");
6646 break;
6647
6648 case llvm::Triple::sparcv9:
6649 CmdArgs.push_back("-m");
6650 CmdArgs.push_back("elf64_sparc");
6651 break;
6652
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006653 default:
6654 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006655 }
6656
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006657 if (Output.isFilename()) {
6658 CmdArgs.push_back("-o");
6659 CmdArgs.push_back(Output.getFilename());
6660 } else {
6661 assert(Output.isNothing() && "Invalid output.");
6662 }
6663
6664 if (!Args.hasArg(options::OPT_nostdlib) &&
6665 !Args.hasArg(options::OPT_nostartfiles)) {
6666 if (!Args.hasArg(options::OPT_shared)) {
6667 CmdArgs.push_back(Args.MakeArgString(
6668 getToolChain().GetFilePath("crt0.o")));
6669 CmdArgs.push_back(Args.MakeArgString(
6670 getToolChain().GetFilePath("crti.o")));
6671 CmdArgs.push_back(Args.MakeArgString(
6672 getToolChain().GetFilePath("crtbegin.o")));
6673 } else {
6674 CmdArgs.push_back(Args.MakeArgString(
6675 getToolChain().GetFilePath("crti.o")));
6676 CmdArgs.push_back(Args.MakeArgString(
6677 getToolChain().GetFilePath("crtbeginS.o")));
6678 }
6679 }
6680
6681 Args.AddAllArgs(CmdArgs, options::OPT_L);
6682 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6683 Args.AddAllArgs(CmdArgs, options::OPT_e);
6684 Args.AddAllArgs(CmdArgs, options::OPT_s);
6685 Args.AddAllArgs(CmdArgs, options::OPT_t);
6686 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6687 Args.AddAllArgs(CmdArgs, options::OPT_r);
6688
6689 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6690
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006691 unsigned Major, Minor, Micro;
6692 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6693 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006694 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006695 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006696 case llvm::Triple::arm:
6697 case llvm::Triple::armeb:
6698 case llvm::Triple::thumb:
6699 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006700 case llvm::Triple::x86:
6701 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006702 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006703 break;
6704 default:
6705 break;
6706 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006707 }
6708
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006709 if (!Args.hasArg(options::OPT_nostdlib) &&
6710 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006711 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006712 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6713 CmdArgs.push_back("-lm");
6714 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006715 if (Args.hasArg(options::OPT_pthread))
6716 CmdArgs.push_back("-lpthread");
6717 CmdArgs.push_back("-lc");
6718
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006719 if (useLibgcc) {
6720 if (Args.hasArg(options::OPT_static)) {
6721 // libgcc_eh depends on libc, so resolve as much as possible,
6722 // pull in any new requirements from libc and then get the rest
6723 // of libgcc.
6724 CmdArgs.push_back("-lgcc_eh");
6725 CmdArgs.push_back("-lc");
6726 CmdArgs.push_back("-lgcc");
6727 } else {
6728 CmdArgs.push_back("-lgcc");
6729 CmdArgs.push_back("--as-needed");
6730 CmdArgs.push_back("-lgcc_s");
6731 CmdArgs.push_back("--no-as-needed");
6732 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006733 }
6734 }
6735
6736 if (!Args.hasArg(options::OPT_nostdlib) &&
6737 !Args.hasArg(options::OPT_nostartfiles)) {
6738 if (!Args.hasArg(options::OPT_shared))
6739 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6740 "crtend.o")));
6741 else
6742 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6743 "crtendS.o")));
6744 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6745 "crtn.o")));
6746 }
6747
Alexey Samsonov7811d192014-02-20 13:57:37 +00006748 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006749
Rafael Espindola236db462013-11-09 20:07:19 +00006750 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006751 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6752}
6753
Thomas Schwinge4e555262013-03-28 19:04:25 +00006754void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6755 const InputInfo &Output,
6756 const InputInfoList &Inputs,
6757 const ArgList &Args,
6758 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006759 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006760 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006761
6762 // Add --32/--64 to make sure we get the format we want.
6763 // This is incomplete
6764 if (getToolChain().getArch() == llvm::Triple::x86) {
6765 CmdArgs.push_back("--32");
6766 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6767 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006768 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6769 CmdArgs.push_back("-a32");
6770 CmdArgs.push_back("-mppc");
6771 CmdArgs.push_back("-many");
6772 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6773 CmdArgs.push_back("-a64");
6774 CmdArgs.push_back("-mppc64");
6775 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006776 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6777 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006778 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006779 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006780 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006781 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6782 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006783 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006784 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006785 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6786 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006787 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006788 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006789 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6790 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006791 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006792 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6793 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006794 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6795 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006796 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006797
Tim Northover9c7e0352013-12-12 11:55:52 +00006798 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6799 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006800 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006801
6802 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006803
6804 // FIXME: remove krait check when GNU tools support krait cpu
6805 // for now replace it with -march=armv7-a to avoid a lower
6806 // march from being picked in the absence of a cpu flag.
6807 Arg *A;
6808 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6809 StringRef(A->getValue()) == "krait")
6810 CmdArgs.push_back("-march=armv7-a");
6811 else
6812 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006813 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006814 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6815 getToolChain().getArch() == llvm::Triple::mipsel ||
6816 getToolChain().getArch() == llvm::Triple::mips64 ||
6817 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006818 StringRef CPUName;
6819 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006820 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006821
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006822 CmdArgs.push_back("-march");
6823 CmdArgs.push_back(CPUName.data());
6824
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006825 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006826 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006827
6828 if (getToolChain().getArch() == llvm::Triple::mips ||
6829 getToolChain().getArch() == llvm::Triple::mips64)
6830 CmdArgs.push_back("-EB");
6831 else
6832 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006833
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006834 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6835 if (StringRef(A->getValue()) == "2008")
6836 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6837 }
6838
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006839 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006840 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6841 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6842 options::OPT_mno_micromips);
6843 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6844 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6845
Simon Atanasyanbd986632013-11-26 11:58:04 +00006846 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6847 // Do not use AddLastArg because not all versions of MIPS assembler
6848 // support -mmsa / -mno-msa options.
6849 if (A->getOption().matches(options::OPT_mmsa))
6850 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6851 }
6852
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006853 NeedsKPIC = true;
6854 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6855 // Always pass an -march option, since our default of z10 is later
6856 // than the GNU assembler's default.
6857 StringRef CPUName = getSystemZTargetCPU(Args);
6858 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6859 }
6860
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006861 if (NeedsKPIC)
6862 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006863
6864 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6865 options::OPT_Xassembler);
6866
6867 CmdArgs.push_back("-o");
6868 CmdArgs.push_back(Output.getFilename());
6869
6870 for (InputInfoList::const_iterator
6871 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6872 const InputInfo &II = *it;
6873 CmdArgs.push_back(II.getFilename());
6874 }
6875
6876 const char *Exec =
6877 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6878 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006879
6880 // Handle the debug info splitting at object creation time if we're
6881 // creating an object.
6882 // TODO: Currently only works on linux with newer objcopy.
6883 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006884 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006885 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6886 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006887}
6888
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006889static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006890 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006891 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006892 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6893 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006894 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006895 CmdArgs.push_back("-lgcc");
6896
Logan Chien3d3373c2012-11-19 12:04:11 +00006897 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006898 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006899 CmdArgs.push_back("-lgcc");
6900 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006901 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006902 CmdArgs.push_back("--as-needed");
6903 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006904 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006905 CmdArgs.push_back("--no-as-needed");
6906 }
6907
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006908 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006909 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006910 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006911 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006912
6913 // According to Android ABI, we have to link with libdl if we are
6914 // linking with non-static libgcc.
6915 //
6916 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6917 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6918 if (isAndroid && !StaticLibgcc)
6919 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006920}
6921
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006922static StringRef getLinuxDynamicLinker(const ArgList &Args,
6923 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006924 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6925 if (ToolChain.getTriple().isArch64Bit())
6926 return "/system/bin/linker64";
6927 else
6928 return "/system/bin/linker";
6929 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6930 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006931 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00006932 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
6933 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006934 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00006935 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
6936 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00006937 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006938 else if (ToolChain.getArch() == llvm::Triple::arm ||
6939 ToolChain.getArch() == llvm::Triple::thumb) {
6940 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6941 return "/lib/ld-linux-armhf.so.3";
6942 else
6943 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006944 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
6945 ToolChain.getArch() == llvm::Triple::thumbeb) {
6946 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6947 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
6948 else
6949 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006950 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6951 ToolChain.getArch() == llvm::Triple::mipsel)
6952 return "/lib/ld.so.1";
6953 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6954 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006955 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006956 return "/lib32/ld.so.1";
6957 else
6958 return "/lib64/ld.so.1";
6959 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6960 return "/lib/ld.so.1";
6961 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidt778d3872013-07-26 01:36:11 +00006962 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006963 ToolChain.getArch() == llvm::Triple::systemz)
6964 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006965 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6966 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006967 else
6968 return "/lib64/ld-linux-x86-64.so.2";
6969}
6970
Renato Golinc4b49242014-02-13 10:01:16 +00006971static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6972 ArgStringList &CmdArgs, const ArgList &Args) {
6973 // Make use of compiler-rt if --rtlib option is used
6974 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6975
6976 switch(RLT) {
6977 case ToolChain::RLT_CompilerRT:
6978 addClangRTLinux(TC, Args, CmdArgs);
6979 break;
6980 case ToolChain::RLT_Libgcc:
6981 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6982 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006983 }
6984}
6985
Thomas Schwinge4e555262013-03-28 19:04:25 +00006986void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6987 const InputInfo &Output,
6988 const InputInfoList &Inputs,
6989 const ArgList &Args,
6990 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006991 const toolchains::Linux& ToolChain =
6992 static_cast<const toolchains::Linux&>(getToolChain());
6993 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006994 const bool isAndroid =
6995 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006996 const bool IsPIE =
6997 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00006998 !Args.hasArg(options::OPT_static) &&
6999 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7000 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007001 // Cannot use isPIEDefault here since otherwise
7002 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007003 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007004
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007005 ArgStringList CmdArgs;
7006
Rafael Espindolad1002f62010-11-15 18:28:16 +00007007 // Silence warning for "clang -g foo.o -o foo"
7008 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007009 // and "clang -emit-llvm foo.o -o foo"
7010 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007011 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007012 // handled somewhere else.
7013 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007014
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007015 if (!D.SysRoot.empty())
7016 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007017
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007018 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007019 CmdArgs.push_back("-pie");
7020
Rafael Espindola1c76c592010-11-07 22:57:16 +00007021 if (Args.hasArg(options::OPT_rdynamic))
7022 CmdArgs.push_back("-export-dynamic");
7023
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007024 if (Args.hasArg(options::OPT_s))
7025 CmdArgs.push_back("-s");
7026
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007027 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
7028 e = ToolChain.ExtraOpts.end();
7029 i != e; ++i)
7030 CmdArgs.push_back(i->c_str());
7031
7032 if (!Args.hasArg(options::OPT_static)) {
7033 CmdArgs.push_back("--eh-frame-hdr");
7034 }
7035
7036 CmdArgs.push_back("-m");
7037 if (ToolChain.getArch() == llvm::Triple::x86)
7038 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007039 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7040 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007041 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007042 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7043 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007044 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007045 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007046 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007047 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007048 else if (ToolChain.getArch() == llvm::Triple::armeb
7049 || ToolChain.getArch() == llvm::Triple::thumbeb)
7050 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007051 else if (ToolChain.getArch() == llvm::Triple::ppc)
7052 CmdArgs.push_back("elf32ppclinux");
7053 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7054 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007055 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7056 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007057 else if (ToolChain.getArch() == llvm::Triple::sparc)
7058 CmdArgs.push_back("elf32_sparc");
7059 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7060 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007061 else if (ToolChain.getArch() == llvm::Triple::mips)
7062 CmdArgs.push_back("elf32btsmip");
7063 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7064 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007065 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007066 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007067 CmdArgs.push_back("elf32btsmipn32");
7068 else
7069 CmdArgs.push_back("elf64btsmip");
7070 }
7071 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007072 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007073 CmdArgs.push_back("elf32ltsmipn32");
7074 else
7075 CmdArgs.push_back("elf64ltsmip");
7076 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007077 else if (ToolChain.getArch() == llvm::Triple::systemz)
7078 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007079 else
7080 CmdArgs.push_back("elf_x86_64");
7081
7082 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007083 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007084 ToolChain.getArch() == llvm::Triple::armeb ||
7085 ToolChain.getArch() == llvm::Triple::thumb ||
7086 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007087 CmdArgs.push_back("-Bstatic");
7088 else
7089 CmdArgs.push_back("-static");
7090 } else if (Args.hasArg(options::OPT_shared)) {
7091 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00007092 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007093 CmdArgs.push_back("-Bsymbolic");
7094 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007095 }
7096
7097 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007098 ToolChain.getArch() == llvm::Triple::armeb ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00007099 ToolChain.getArch() == llvm::Triple::thumb ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007100 ToolChain.getArch() == llvm::Triple::thumbeb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007101 (!Args.hasArg(options::OPT_static) &&
7102 !Args.hasArg(options::OPT_shared))) {
7103 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007104 CmdArgs.push_back(Args.MakeArgString(
7105 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007106 }
7107
7108 CmdArgs.push_back("-o");
7109 CmdArgs.push_back(Output.getFilename());
7110
Rafael Espindola81937ec2010-12-01 01:52:43 +00007111 if (!Args.hasArg(options::OPT_nostdlib) &&
7112 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007113 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007114 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007115 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007116 if (Args.hasArg(options::OPT_pg))
7117 crt1 = "gcrt1.o";
7118 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007119 crt1 = "Scrt1.o";
7120 else
7121 crt1 = "crt1.o";
7122 }
7123 if (crt1)
7124 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007125
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007126 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7127 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007128
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007129 const char *crtbegin;
7130 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007131 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007132 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007133 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007134 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007135 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007136 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007137 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007138 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007139
7140 // Add crtfastmath.o if available and fast math is enabled.
7141 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007142 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007143
7144 Args.AddAllArgs(CmdArgs, options::OPT_L);
7145
7146 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7147
Roman Divackyee8188a2011-03-01 17:53:14 +00007148 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
7149 i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007150 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007151
Alp Tokerce365ca2013-12-02 12:43:03 +00007152 if (D.IsUsingLTO(Args))
7153 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007154
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007155 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7156 CmdArgs.push_back("--no-demangle");
7157
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007158 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7159
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007160 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007161 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007162 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007163
Hans Wennborg70850d82013-07-18 20:29:38 +00007164 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007165 !Args.hasArg(options::OPT_nostdlib) &&
7166 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007167 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7168 !Args.hasArg(options::OPT_static);
7169 if (OnlyLibstdcxxStatic)
7170 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007171 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007172 if (OnlyLibstdcxxStatic)
7173 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007174 CmdArgs.push_back("-lm");
7175 }
7176
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007177 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007178 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7179 if (Args.hasArg(options::OPT_static))
7180 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007181
Alexey Bataev186b28a2014-03-06 05:43:53 +00007182 LibOpenMP UsedOpenMPLib = LibUnknown;
7183 if (Args.hasArg(options::OPT_fopenmp)) {
7184 UsedOpenMPLib = LibGOMP;
7185 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7186 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7187 .Case("libgomp", LibGOMP)
7188 .Case("libiomp5", LibIOMP5)
7189 .Default(LibUnknown);
7190 if (UsedOpenMPLib == LibUnknown)
7191 D.Diag(diag::err_drv_unsupported_option_argument)
7192 << A->getOption().getName() << A->getValue();
7193 }
7194 switch (UsedOpenMPLib) {
7195 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007196 CmdArgs.push_back("-lgomp");
7197
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007198 // FIXME: Exclude this for platforms with libgomp that don't require
7199 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007200 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007201 break;
7202 case LibIOMP5:
7203 CmdArgs.push_back("-liomp5");
7204 break;
7205 case LibUnknown:
7206 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007207 }
Renato Golinc4b49242014-02-13 10:01:16 +00007208 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007209
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007210 if ((Args.hasArg(options::OPT_pthread) ||
7211 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7212 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007213 CmdArgs.push_back("-lpthread");
7214
7215 CmdArgs.push_back("-lc");
7216
7217 if (Args.hasArg(options::OPT_static))
7218 CmdArgs.push_back("--end-group");
7219 else
Renato Golinc4b49242014-02-13 10:01:16 +00007220 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007221 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007222
Rafael Espindola81937ec2010-12-01 01:52:43 +00007223 if (!Args.hasArg(options::OPT_nostartfiles)) {
7224 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007225 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007226 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007227 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007228 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007229 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007230 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007231
Rafael Espindola81937ec2010-12-01 01:52:43 +00007232 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007233 if (!isAndroid)
7234 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007235 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007236 }
7237
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007238 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
7239}
Rafael Espindola92b00932010-08-10 00:25:48 +00007240
Chris Lattner3e2ee142010-07-07 16:01:42 +00007241void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007242 const InputInfo &Output,
7243 const InputInfoList &Inputs,
7244 const ArgList &Args,
7245 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007246 ArgStringList CmdArgs;
7247
7248 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7249 options::OPT_Xassembler);
7250
7251 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007252 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007253
7254 for (InputInfoList::const_iterator
7255 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7256 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007257 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007258 }
7259
7260 const char *Exec =
Eli Friedman83de5132011-12-08 23:54:21 +00007261 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007262 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007263}
7264
7265void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007266 const InputInfo &Output,
7267 const InputInfoList &Inputs,
7268 const ArgList &Args,
7269 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007270 const Driver &D = getToolChain().getDriver();
7271 ArgStringList CmdArgs;
7272
Daniel Dunbarb440f562010-08-02 02:38:21 +00007273 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007274 CmdArgs.push_back("-o");
7275 CmdArgs.push_back(Output.getFilename());
7276 } else {
7277 assert(Output.isNothing() && "Invalid output.");
7278 }
7279
7280 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007281 !Args.hasArg(options::OPT_nostartfiles)) {
7282 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7283 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7284 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7285 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7286 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007287
7288 Args.AddAllArgs(CmdArgs, options::OPT_L);
7289 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7290 Args.AddAllArgs(CmdArgs, options::OPT_e);
7291
Daniel Dunbar54423b22010-09-17 00:24:54 +00007292 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007293
Alexey Samsonov7811d192014-02-20 13:57:37 +00007294 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007295
Chris Lattner3e2ee142010-07-07 16:01:42 +00007296 if (!Args.hasArg(options::OPT_nostdlib) &&
7297 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007298 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007299 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007300 CmdArgs.push_back("-lm");
7301 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007302 }
7303
7304 if (!Args.hasArg(options::OPT_nostdlib) &&
7305 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007306 if (Args.hasArg(options::OPT_pthread))
7307 CmdArgs.push_back("-lpthread");
7308 CmdArgs.push_back("-lc");
7309 CmdArgs.push_back("-lCompilerRT-Generic");
7310 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7311 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007312 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007313 }
7314
Rafael Espindola236db462013-11-09 20:07:19 +00007315 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007316 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007317}
7318
Daniel Dunbarcc912342009-05-02 18:28:39 +00007319/// DragonFly Tools
7320
7321// For now, DragonFly Assemble does just about the same as for
7322// FreeBSD, but this may change soon.
7323void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007324 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007325 const InputInfoList &Inputs,
7326 const ArgList &Args,
7327 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007328 ArgStringList CmdArgs;
7329
7330 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7331 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007332 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007333 CmdArgs.push_back("--32");
7334
7335 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7336 options::OPT_Xassembler);
7337
7338 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007339 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007340
7341 for (InputInfoList::const_iterator
7342 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7343 const InputInfo &II = *it;
Daniel Dunbarb440f562010-08-02 02:38:21 +00007344 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007345 }
7346
7347 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007348 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007349 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007350}
7351
7352void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007353 const InputInfo &Output,
7354 const InputInfoList &Inputs,
7355 const ArgList &Args,
7356 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007357 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007358 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007359 ArgStringList CmdArgs;
7360
John McCall65b8da02013-04-11 22:55:55 +00007361 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7362 UseGCC47 = false;
7363
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007364 if (!D.SysRoot.empty())
7365 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7366
John McCall65b8da02013-04-11 22:55:55 +00007367 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007368 if (Args.hasArg(options::OPT_static)) {
7369 CmdArgs.push_back("-Bstatic");
7370 } else {
John McCall65b8da02013-04-11 22:55:55 +00007371 if (Args.hasArg(options::OPT_rdynamic))
7372 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007373 if (Args.hasArg(options::OPT_shared))
7374 CmdArgs.push_back("-Bshareable");
7375 else {
7376 CmdArgs.push_back("-dynamic-linker");
7377 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7378 }
John McCall65b8da02013-04-11 22:55:55 +00007379 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007380 }
7381
7382 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7383 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007384 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007385 CmdArgs.push_back("-m");
7386 CmdArgs.push_back("elf_i386");
7387 }
7388
Daniel Dunbarb440f562010-08-02 02:38:21 +00007389 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007390 CmdArgs.push_back("-o");
7391 CmdArgs.push_back(Output.getFilename());
7392 } else {
7393 assert(Output.isNothing() && "Invalid output.");
7394 }
7395
7396 if (!Args.hasArg(options::OPT_nostdlib) &&
7397 !Args.hasArg(options::OPT_nostartfiles)) {
7398 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007399 if (Args.hasArg(options::OPT_pg))
7400 CmdArgs.push_back(Args.MakeArgString(
7401 getToolChain().GetFilePath("gcrt1.o")));
7402 else {
7403 if (Args.hasArg(options::OPT_pie))
7404 CmdArgs.push_back(Args.MakeArgString(
7405 getToolChain().GetFilePath("Scrt1.o")));
7406 else
7407 CmdArgs.push_back(Args.MakeArgString(
7408 getToolChain().GetFilePath("crt1.o")));
7409 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007410 }
John McCall65b8da02013-04-11 22:55:55 +00007411 CmdArgs.push_back(Args.MakeArgString(
7412 getToolChain().GetFilePath("crti.o")));
7413 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7414 CmdArgs.push_back(Args.MakeArgString(
7415 getToolChain().GetFilePath("crtbeginS.o")));
7416 else
7417 CmdArgs.push_back(Args.MakeArgString(
7418 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007419 }
7420
7421 Args.AddAllArgs(CmdArgs, options::OPT_L);
7422 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7423 Args.AddAllArgs(CmdArgs, options::OPT_e);
7424
Daniel Dunbar54423b22010-09-17 00:24:54 +00007425 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007426
7427 if (!Args.hasArg(options::OPT_nostdlib) &&
7428 !Args.hasArg(options::OPT_nodefaultlibs)) {
7429 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7430 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007431 if (UseGCC47)
7432 CmdArgs.push_back("-L/usr/lib/gcc47");
7433 else
7434 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007435
7436 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007437 if (UseGCC47) {
7438 CmdArgs.push_back("-rpath");
7439 CmdArgs.push_back("/usr/lib/gcc47");
7440 } else {
7441 CmdArgs.push_back("-rpath");
7442 CmdArgs.push_back("/usr/lib/gcc44");
7443 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007444 }
7445
Hans Wennborg70850d82013-07-18 20:29:38 +00007446 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007447 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007448 CmdArgs.push_back("-lm");
7449 }
7450
Daniel Dunbarcc912342009-05-02 18:28:39 +00007451 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007452 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007453
7454 if (!Args.hasArg(options::OPT_nolibc)) {
7455 CmdArgs.push_back("-lc");
7456 }
7457
John McCall65b8da02013-04-11 22:55:55 +00007458 if (UseGCC47) {
7459 if (Args.hasArg(options::OPT_static) ||
7460 Args.hasArg(options::OPT_static_libgcc)) {
7461 CmdArgs.push_back("-lgcc");
7462 CmdArgs.push_back("-lgcc_eh");
7463 } else {
7464 if (Args.hasArg(options::OPT_shared_libgcc)) {
7465 CmdArgs.push_back("-lgcc_pic");
7466 if (!Args.hasArg(options::OPT_shared))
7467 CmdArgs.push_back("-lgcc");
7468 } else {
7469 CmdArgs.push_back("-lgcc");
7470 CmdArgs.push_back("--as-needed");
7471 CmdArgs.push_back("-lgcc_pic");
7472 CmdArgs.push_back("--no-as-needed");
7473 }
7474 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007475 } else {
John McCall65b8da02013-04-11 22:55:55 +00007476 if (Args.hasArg(options::OPT_shared)) {
7477 CmdArgs.push_back("-lgcc_pic");
7478 } else {
7479 CmdArgs.push_back("-lgcc");
7480 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007481 }
7482 }
7483
7484 if (!Args.hasArg(options::OPT_nostdlib) &&
7485 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007486 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007487 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007488 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007489 else
7490 CmdArgs.push_back(Args.MakeArgString(
7491 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007492 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007493 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007494 }
7495
Alexey Samsonov7811d192014-02-20 13:57:37 +00007496 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007497
Daniel Dunbarcc912342009-05-02 18:28:39 +00007498 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00007499 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007500 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007501}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007502
Alexey Samsonov6424e022014-05-12 20:20:20 +00007503static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7504 ArgStringList &CmdArgs,
7505 const StringRef RTName) {
7506 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7507 llvm::sys::path::append(LibSanitizer,
7508 Twine("clang_rt.") + RTName + ".lib");
7509 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7510}
7511
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007512void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7513 const InputInfo &Output,
7514 const InputInfoList &Inputs,
7515 const ArgList &Args,
7516 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007517 ArgStringList CmdArgs;
7518
7519 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007520 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7521 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007522 } else {
7523 assert(Output.isNothing() && "Invalid output.");
7524 }
7525
7526 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007527 !Args.hasArg(options::OPT_nostartfiles) &&
7528 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007529 CmdArgs.push_back("-defaultlib:libcmt");
7530 }
7531
7532 CmdArgs.push_back("-nologo");
7533
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007534 if (Args.hasArg(options::OPT_g_Group)) {
7535 CmdArgs.push_back("-debug");
7536 }
7537
Hans Wennborgf1a74252013-09-10 20:18:04 +00007538 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7539
7540 if (DLL) {
7541 CmdArgs.push_back(Args.MakeArgString("-dll"));
7542
7543 SmallString<128> ImplibName(Output.getFilename());
7544 llvm::sys::path::replace_extension(ImplibName, "lib");
7545 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7546 ImplibName.str()));
7547 }
7548
Peter Collingbourne32701642013-11-01 18:16:25 +00007549 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007550 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007551 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007552 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007553 if (DLL) {
7554 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7555 "asan_dll_thunk-i386");
7556 } else {
7557 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7558 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7559 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007560 }
7561
Michael J. Spencere2f49362012-06-18 16:56:04 +00007562 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007563 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007564
7565 // Add filenames immediately.
7566 for (InputInfoList::const_iterator
7567 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7568 if (it->isFilename())
7569 CmdArgs.push_back(it->getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007570 else
7571 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007572 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007573
7574 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007575 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007576 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7577}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007578
7579void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7580 const InputInfo &Output,
7581 const InputInfoList &Inputs,
7582 const ArgList &Args,
7583 const char *LinkingOutput) const {
7584 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7585}
7586
Hans Wennborg188382e2013-09-20 18:16:35 +00007587// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7588// If one cannot be found, return FallbackName.
7589// We do this special search to prevent clang-cl from falling back onto itself
7590// if it's available as cl.exe on the path.
7591static std::string FindFallback(const char *FallbackName,
7592 const char *ClangProgramPath) {
7593 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7594 if (!OptPath.hasValue())
7595 return FallbackName;
7596
7597#ifdef LLVM_ON_WIN32
7598 const StringRef PathSeparators = ";";
7599#else
7600 const StringRef PathSeparators = ":";
7601#endif
7602
7603 SmallVector<StringRef, 8> PathSegments;
7604 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7605
7606 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7607 const StringRef &PathSegment = PathSegments[i];
7608 if (PathSegment.empty())
7609 continue;
7610
7611 SmallString<128> FilePath(PathSegment);
7612 llvm::sys::path::append(FilePath, FallbackName);
7613 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7614 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7615 return FilePath.str();
7616 }
7617
7618 return FallbackName;
7619}
7620
Hans Wennborg87cfa712013-09-19 20:32:16 +00007621Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7622 const InputInfo &Output,
7623 const InputInfoList &Inputs,
7624 const ArgList &Args,
7625 const char *LinkingOutput) const {
7626 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007627 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007628 CmdArgs.push_back("/c"); // Compile only.
7629 CmdArgs.push_back("/W0"); // No warnings.
7630
7631 // The goal is to be able to invoke this tool correctly based on
7632 // any flag accepted by clang-cl.
7633
7634 // These are spelled the same way in clang and cl.exe,.
7635 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7636 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007637
7638 // Optimization level.
7639 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7640 if (A->getOption().getID() == options::OPT_O0) {
7641 CmdArgs.push_back("/Od");
7642 } else {
7643 StringRef OptLevel = A->getValue();
7644 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7645 A->render(Args, CmdArgs);
7646 else if (OptLevel == "3")
7647 CmdArgs.push_back("/Ox");
7648 }
7649 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007650
7651 // Flags for which clang-cl have an alias.
7652 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7653
7654 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7655 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7656 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007657 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7658 options::OPT_fno_function_sections))
7659 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7660 ? "/Gy"
7661 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007662 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7663 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007664 CmdArgs.push_back(
7665 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007666 if (Args.hasArg(options::OPT_fsyntax_only))
7667 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007668 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7669 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007670
Hans Wennborg260ff402013-09-27 17:54:18 +00007671 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7672 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7673 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7674
Hans Wennborg87cfa712013-09-19 20:32:16 +00007675 // Flags that can simply be passed through.
7676 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7677 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7678
7679 // The order of these flags is relevant, so pick the last one.
7680 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7681 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7682 A->render(Args, CmdArgs);
7683
7684
7685 // Input filename.
7686 assert(Inputs.size() == 1);
7687 const InputInfo &II = Inputs[0];
7688 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7689 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7690 if (II.isFilename())
7691 CmdArgs.push_back(II.getFilename());
7692 else
7693 II.getInputArg().renderAsInput(Args, CmdArgs);
7694
7695 // Output filename.
7696 assert(Output.getType() == types::TY_Object);
7697 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7698 Output.getFilename());
7699 CmdArgs.push_back(Fo);
7700
Hans Wennborg188382e2013-09-20 18:16:35 +00007701 const Driver &D = getToolChain().getDriver();
7702 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg87cfa712013-09-19 20:32:16 +00007703
Hans Wennborg188382e2013-09-20 18:16:35 +00007704 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007705}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007706
7707
7708/// XCore Tools
7709// We pass assemble and link construction to the xcc tool.
7710
7711void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7712 const InputInfo &Output,
7713 const InputInfoList &Inputs,
7714 const ArgList &Args,
7715 const char *LinkingOutput) const {
7716 ArgStringList CmdArgs;
7717
7718 CmdArgs.push_back("-o");
7719 CmdArgs.push_back(Output.getFilename());
7720
7721 CmdArgs.push_back("-c");
7722
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007723 if (Args.hasArg(options::OPT_v))
7724 CmdArgs.push_back("-v");
7725
Robert Lytton894d25c2014-05-02 09:33:25 +00007726 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7727 if (!A->getOption().matches(options::OPT_g0))
7728 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007729
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007730 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7731 false))
7732 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007733
7734 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7735 options::OPT_Xassembler);
7736
7737 for (InputInfoList::const_iterator
7738 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7739 const InputInfo &II = *it;
7740 CmdArgs.push_back(II.getFilename());
7741 }
7742
7743 const char *Exec =
7744 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7745 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7746}
7747
7748void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7749 const InputInfo &Output,
7750 const InputInfoList &Inputs,
7751 const ArgList &Args,
7752 const char *LinkingOutput) const {
7753 ArgStringList CmdArgs;
7754
7755 if (Output.isFilename()) {
7756 CmdArgs.push_back("-o");
7757 CmdArgs.push_back(Output.getFilename());
7758 } else {
7759 assert(Output.isNothing() && "Invalid output.");
7760 }
7761
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007762 if (Args.hasArg(options::OPT_v))
7763 CmdArgs.push_back("-v");
7764
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007765 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7766 if (EH.ShouldUseExceptionTables)
7767 CmdArgs.push_back("-fexceptions");
7768
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007769 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7770
7771 const char *Exec =
7772 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7773 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7774}