blob: 4302f1a9cd0cace8e24818e8cccd2bcf2004bafc [file] [log] [blame]
Nick Lewyckye3365aa2010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar47ac7d22009-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 Carruth55fc8732012-12-04 09:13:33 +000011#include "InputInfo.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000012#include "ToolChains.h"
13#include "clang/Basic/ObjCRuntime.h"
Kevin Enderby02341792013-01-17 21:38:06 +000014#include "clang/Basic/Version.h"
Daniel Dunbar1d460332009-03-18 10:01:51 +000015#include "clang/Driver/Action.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000016#include "clang/Driver/Compilation.h"
Daniel Dunbaree848a72009-10-29 02:39:57 +000017#include "clang/Driver/Driver.h"
18#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000019#include "clang/Driver/Job.h"
Daniel Dunbar265e9ef2009-11-19 04:25:22 +000020#include "clang/Driver/Options.h"
Alexey Samsonov1b8f12d2013-08-19 09:14:21 +000021#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbarb488c1d2009-03-18 08:07:30 +000022#include "clang/Driver/ToolChain.h"
Daniel Dunbar871adcf2009-03-18 07:06:02 +000023#include "clang/Driver/Util.h"
Daniel Dunbar88137642009-09-09 22:32:48 +000024#include "llvm/ADT/SmallString.h"
Hans Wennborgdc40bf92013-09-20 18:16:35 +000025#include "llvm/ADT/StringExtras.h"
Douglas Gregor55d3f7a2009-10-29 00:41:01 +000026#include "llvm/ADT/StringSwitch.h"
Daniel Dunbar5b750fe2009-09-09 22:32:34 +000027#include "llvm/ADT/Twine.h"
Reid Klecknerb1e25a12013-06-14 17:17:23 +000028#include "llvm/Option/Arg.h"
29#include "llvm/Option/ArgList.h"
30#include "llvm/Option/Option.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000031#include "llvm/Support/ErrorHandling.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000032#include "llvm/Support/FileSystem.h"
Daniel Dunbar02633b52009-03-26 16:23:12 +000033#include "llvm/Support/Format.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000034#include "llvm/Support/Host.h"
Hans Wennborgdc40bf92013-09-20 18:16:35 +000035#include "llvm/Support/Path.h"
Rafael Espindola8db7ec02013-06-25 14:29:51 +000036#include "llvm/Support/Program.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000037#include "llvm/Support/Process.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000038#include "llvm/Support/raw_ostream.h"
Reid Klecknerb1e25a12013-06-14 17:17:23 +000039#include <sys/stat.h>
Daniel Dunbar871adcf2009-03-18 07:06:02 +000040
Daniel Dunbar47ac7d22009-03-18 06:00:36 +000041using namespace clang::driver;
42using namespace clang::driver::tools;
Chris Lattner5f9e2722011-07-23 10:55:15 +000043using namespace clang;
Reid Klecknerb1e25a12013-06-14 17:17:23 +000044using namespace llvm::opt;
Daniel Dunbar47ac7d22009-03-18 06:00:36 +000045
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000046/// CheckPreprocessingOptions - Perform some validation of preprocessing
47/// arguments that is shared with gcc.
48static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
49 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
Hans Wennborg76b86c22013-07-18 20:29:38 +000050 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
Chris Lattner5f9e2722011-07-23 10:55:15 +000051 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar88a3d6c2009-09-10 01:21:05 +000052 << A->getAsString(Args) << "-E";
53}
54
Daniel Dunbare2fd6642009-09-10 01:21:12 +000055/// CheckCodeGenerationOptions - Perform some validation of code generation
56/// arguments that is shared with gcc.
57static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
58 // In gcc, only ARM checks this, but it seems reasonable to check universally.
59 if (Args.hasArg(options::OPT_static))
60 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
61 options::OPT_mdynamic_no_pic))
Chris Lattner5f9e2722011-07-23 10:55:15 +000062 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbare2fd6642009-09-10 01:21:12 +000063 << A->getAsString(Args) << "-static";
64}
65
Chris Lattner3edbeb72010-03-29 17:55:58 +000066// Quote target names for inclusion in GNU Make dependency files.
67// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner5f9e2722011-07-23 10:55:15 +000068static void QuoteTarget(StringRef Target,
69 SmallVectorImpl<char> &Res) {
Chris Lattner3edbeb72010-03-29 17:55:58 +000070 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
71 switch (Target[i]) {
72 case ' ':
73 case '\t':
74 // Escape the preceding backslashes
75 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
76 Res.push_back('\\');
77
78 // Escape the space/tab
79 Res.push_back('\\');
80 break;
81 case '$':
82 Res.push_back('$');
83 break;
84 case '#':
85 Res.push_back('\\');
86 break;
87 default:
88 break;
89 }
90
91 Res.push_back(Target[i]);
92 }
93}
94
Bill Wendling3d717152012-03-12 22:10:06 +000095static void addDirectoryList(const ArgList &Args,
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +000096 ArgStringList &CmdArgs,
97 const char *ArgName,
Bill Wendling3d717152012-03-12 22:10:06 +000098 const char *EnvVar) {
99 const char *DirList = ::getenv(EnvVar);
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000100 bool CombinedArg = false;
101
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000102 if (!DirList)
103 return; // Nothing to do.
104
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000105 StringRef Name(ArgName);
106 if (Name.equals("-I") || Name.equals("-L"))
107 CombinedArg = true;
108
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000109 StringRef Dirs(DirList);
110 if (Dirs.empty()) // Empty string should not add '.'.
111 return;
112
113 StringRef::size_type Delim;
Rafael Espindola8db7ec02013-06-25 14:29:51 +0000114 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000115 if (Delim == 0) { // Leading colon.
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000116 if (CombinedArg) {
117 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
118 } else {
119 CmdArgs.push_back(ArgName);
120 CmdArgs.push_back(".");
121 }
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000122 } else {
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000123 if (CombinedArg) {
124 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
125 } else {
126 CmdArgs.push_back(ArgName);
127 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
128 }
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000129 }
Nico Weber09c5c392012-03-19 15:00:03 +0000130 Dirs = Dirs.substr(Delim + 1);
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000131 }
132
133 if (Dirs.empty()) { // Trailing colon.
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000134 if (CombinedArg) {
135 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
136 } else {
137 CmdArgs.push_back(ArgName);
138 CmdArgs.push_back(".");
139 }
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000140 } else { // Add the last path.
Chad Rosier89aa2ce2012-10-30 21:42:09 +0000141 if (CombinedArg) {
142 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
143 } else {
144 CmdArgs.push_back(ArgName);
145 CmdArgs.push_back(Args.MakeArgString(Dirs));
146 }
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000147 }
148}
149
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000150static void AddLinkerInputs(const ToolChain &TC,
151 const InputInfoList &Inputs, const ArgList &Args,
152 ArgStringList &CmdArgs) {
153 const Driver &D = TC.getDriver();
154
Daniel Dunbar8ac38d72011-02-19 05:33:51 +0000155 // Add extra linker input arguments which are not treated as inputs
156 // (constructed via -Xarch_).
157 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
158
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000159 for (InputInfoList::const_iterator
160 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
161 const InputInfo &II = *it;
162
163 if (!TC.HasNativeLLVMSupport()) {
164 // Don't try to pass LLVM inputs unless we have native support.
165 if (II.getType() == types::TY_LLVM_IR ||
166 II.getType() == types::TY_LTO_IR ||
167 II.getType() == types::TY_LLVM_BC ||
168 II.getType() == types::TY_LTO_BC)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000169 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000170 << TC.getTripleString();
171 }
172
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000173 // Add filenames immediately.
174 if (II.isFilename()) {
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000175 CmdArgs.push_back(II.getFilename());
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000176 continue;
177 }
178
179 // Otherwise, this is a linker input argument.
180 const Arg &A = II.getInputArg();
181
182 // Handle reserved library options.
183 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +0000184 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Shantonu Sen7433fed2010-09-17 18:39:08 +0000185 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
186 TC.AddCCKextLibArgs(Args, CmdArgs);
Daniel Dunbare5a37f42010-09-17 00:45:02 +0000187 } else
188 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000189 }
Bill Wendlingbdb8f3c2012-03-12 21:22:35 +0000190
191 // LIBRARY_PATH - included following the user specified library paths.
Bill Wendling3d717152012-03-12 22:10:06 +0000192 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar2008fee2010-09-17 00:24:54 +0000193}
194
John McCallf85e1932011-06-15 23:02:42 +0000195/// \brief Determine whether Objective-C automated reference counting is
196/// enabled.
197static bool isObjCAutoRefCount(const ArgList &Args) {
198 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
199}
200
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000201/// \brief Determine whether we are linking the ObjC runtime.
202static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilsona7635f12012-08-07 19:58:00 +0000203 if (isObjCAutoRefCount(Args)) {
204 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000205 return true;
Bob Wilsona7635f12012-08-07 19:58:00 +0000206 }
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000207 return Args.hasArg(options::OPT_fobjc_link_runtime);
208}
209
Rafael Espindoladb3f24a2011-06-02 18:58:46 +0000210static void addProfileRT(const ToolChain &TC, const ArgList &Args,
Bill Wendling3f4be6f2011-06-27 19:15:03 +0000211 ArgStringList &CmdArgs,
212 llvm::Triple Triple) {
213 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
214 Args.hasArg(options::OPT_fprofile_generate) ||
215 Args.hasArg(options::OPT_fcreate_profile) ||
216 Args.hasArg(options::OPT_coverage)))
217 return;
218
219 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
220 // the link line. We cannot do the same thing because unlike gcov there is a
221 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
222 // not supported by old linkers.
Benjamin Kramerf2db04c2011-11-07 16:02:25 +0000223 std::string ProfileRT =
224 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
Bill Wendling3f4be6f2011-06-27 19:15:03 +0000225
Bill Wendling3f4be6f2011-06-27 19:15:03 +0000226 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
Rafael Espindoladb3f24a2011-06-02 18:58:46 +0000227}
228
Michael J. Spencer91e06da2012-10-19 22:37:06 +0000229static bool forwardToGCC(const Option &O) {
Reid Kleckner4cd90df2013-06-19 15:09:06 +0000230 // Don't forward inputs from the original command line. They are added from
231 // InputInfoList.
Richard Smithe40bc4b2013-06-20 01:33:59 +0000232 return O.getKind() != Option::InputClass &&
Michael J. Spencer91e06da2012-10-19 22:37:06 +0000233 !O.hasFlag(options::DriverOption) &&
234 !O.hasFlag(options::LinkerInput);
235}
236
Peter Collingbourne54db68b2011-11-06 00:40:05 +0000237void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier9d718632013-01-24 19:14:47 +0000238 const JobAction &JA,
Peter Collingbourne54db68b2011-11-06 00:40:05 +0000239 const Driver &D,
Douglas Gregordf91ef32009-04-18 00:34:01 +0000240 const ArgList &Args,
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000241 ArgStringList &CmdArgs,
242 const InputInfo &Output,
243 const InputInfoList &Inputs) const {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000244 Arg *A;
Daniel Dunbar3a183d32009-06-08 21:48:20 +0000245
Daniel Dunbar88a3d6c2009-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 Dunbar3a183d32009-06-08 21:48:20 +0000250
251 // Handle dependency file generation.
Daniel Dunbar9eb93b02010-12-08 21:33:40 +0000252 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbarc21c4852009-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 Kramer99c72082012-09-26 19:01:49 +0000257 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000258 DepFile = MF->getValue();
Chad Rosier9d718632013-01-24 19:14:47 +0000259 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer99c72082012-09-26 19:01:49 +0000260 } else if (Output.getType() == types::TY_Dependencies) {
261 DepFile = Output.getFilename();
Daniel Dunbarb827a052009-11-19 03:26:40 +0000262 } else if (A->getOption().matches(options::OPT_M) ||
263 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000264 DepFile = "-";
265 } else {
Bob Wilson66b8a662012-11-23 06:14:39 +0000266 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier9d718632013-01-24 19:14:47 +0000267 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000268 }
269 CmdArgs.push_back("-dependency-file");
270 CmdArgs.push_back(DepFile);
271
Chris Lattner3edbeb72010-03-29 17:55:58 +0000272 // Add a default target if one wasn't specified.
Daniel Dunbarc21c4852009-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 Smith1d489cf2012-11-01 04:30:05 +0000280 DepTarget = OutputOpt->getValue();
Daniel Dunbarc21c4852009-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 Noblesmithf7ccbad2012-02-05 02:13:05 +0000285 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencer472ccff2010-12-18 00:19:12 +0000286 llvm::sys::path::replace_extension(P, "o");
287 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000288 }
289
290 CmdArgs.push_back("-MT");
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000291 SmallString<128> Quoted;
Chris Lattner3edbeb72010-03-29 17:55:58 +0000292 QuoteTarget(DepTarget, Quoted);
293 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000294 }
295
Daniel Dunbarb827a052009-11-19 03:26:40 +0000296 if (A->getOption().matches(options::OPT_M) ||
297 A->getOption().matches(options::OPT_MD))
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000298 CmdArgs.push_back("-sys-header-deps");
299 }
300
Peter Collingbournebb527862011-07-12 19:35:15 +0000301 if (Args.hasArg(options::OPT_MG)) {
302 if (!A || A->getOption().matches(options::OPT_MD) ||
303 A->getOption().matches(options::OPT_MMD))
Chris Lattner5f9e2722011-07-23 10:55:15 +0000304 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbournebb527862011-07-12 19:35:15 +0000305 CmdArgs.push_back("-MG");
306 }
307
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000308 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000309
310 // Convert all -MQ <target> args to -MT <quoted target>
311 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
312 options::OPT_MQ),
313 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000314 const Arg *A = *it;
315 A->claim();
Chris Lattner3edbeb72010-03-29 17:55:58 +0000316
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000317 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattner3edbeb72010-03-29 17:55:58 +0000318 CmdArgs.push_back("-MT");
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000319 SmallString<128> Quoted;
Richard Smith1d489cf2012-11-01 04:30:05 +0000320 QuoteTarget(A->getValue(), Quoted);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000321 CmdArgs.push_back(Args.MakeArgString(Quoted));
322
323 // -MT flag - no change
324 } else {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +0000325 A->render(Args, CmdArgs);
Chris Lattner3edbeb72010-03-29 17:55:58 +0000326 }
327 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000328
Douglas Gregordf91ef32009-04-18 00:34:01 +0000329 // Add -i* options, and automatically translate to
330 // -include-pch/-include-pth for transparent PCH support. It's
331 // wonky, but we include looking for .gch so we can support seamless
332 // replacement into a build system already set up to be generating
333 // .gch files.
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000334 bool RenderedImplicitInclude = false;
Daniel Dunbarcdd96862009-11-25 11:53:23 +0000335 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
336 ie = Args.filtered_end(); it != ie; ++it) {
337 const Arg *A = it;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000338
339 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000340 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
341 RenderedImplicitInclude = true;
342
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +0000343 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000344 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000345
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000346 bool FoundPTH = false;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000347 bool FoundPCH = false;
Rafael Espindolaf8edb992013-06-25 15:03:59 +0000348 SmallString<128> P(A->getValue());
349 // We want the files to have a name like foo.h.pch. Add a dummy extension
350 // so that replace_extension does the right thing.
351 P += ".dummy";
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000352 if (UsePCH) {
Rafael Espindolaf8edb992013-06-25 15:03:59 +0000353 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola829e88d2013-06-25 14:48:00 +0000354 if (llvm::sys::fs::exists(P.str()))
Douglas Gregordf91ef32009-04-18 00:34:01 +0000355 FoundPCH = true;
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000356 }
357
Douglas Gregordf91ef32009-04-18 00:34:01 +0000358 if (!FoundPCH) {
Rafael Espindolaf8edb992013-06-25 15:03:59 +0000359 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola829e88d2013-06-25 14:48:00 +0000360 if (llvm::sys::fs::exists(P.str()))
Douglas Gregordf91ef32009-04-18 00:34:01 +0000361 FoundPTH = true;
Mike Stump1eb44332009-09-09 15:08:12 +0000362 }
363
Douglas Gregordf91ef32009-04-18 00:34:01 +0000364 if (!FoundPCH && !FoundPTH) {
Rafael Espindolaf8edb992013-06-25 15:03:59 +0000365 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola829e88d2013-06-25 14:48:00 +0000366 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbar0ebd9322009-10-15 20:02:44 +0000367 FoundPCH = UsePCH;
368 FoundPTH = !UsePCH;
Douglas Gregordf91ef32009-04-18 00:34:01 +0000369 }
Douglas Gregordf91ef32009-04-18 00:34:01 +0000370 }
371
372 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000373 if (IsFirstImplicitInclude) {
374 A->claim();
375 if (UsePCH)
376 CmdArgs.push_back("-include-pch");
377 else
378 CmdArgs.push_back("-include-pth");
379 CmdArgs.push_back(Args.MakeArgString(P.str()));
380 continue;
381 } else {
382 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000383 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis990142a2010-09-30 16:53:47 +0000384 << P.str() << A->getAsString(Args);
385 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000386 }
387 }
388
389 // Not translated, render as usual.
390 A->claim();
391 A->render(Args, CmdArgs);
392 }
393
394 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor65e02fa2011-07-28 04:45:53 +0000395 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
396 options::OPT_index_header_map);
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000397
398 // Add -Wp, and -Xassembler if using the preprocessor.
399
400 // FIXME: There is a very unfortunate problem here, some troubled
401 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
402 // really support that we would have to parse and then translate
403 // those options. :(
404 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
405 options::OPT_Xpreprocessor);
Daniel Dunbar607d7f62009-10-29 01:53:44 +0000406
407 // -I- is a deprecated GCC feature, reject it.
408 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner5f9e2722011-07-23 10:55:15 +0000409 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruthfeee58c2010-10-20 07:00:47 +0000410
411 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
412 // -isysroot to the CC1 invocation.
Sebastian Pop4762a2d2012-04-16 04:16:43 +0000413 StringRef sysroot = C.getSysRoot();
414 if (sysroot != "") {
Chandler Carruthfeee58c2010-10-20 07:00:47 +0000415 if (!Args.hasArg(options::OPT_isysroot)) {
416 CmdArgs.push_back("-isysroot");
Sebastian Pop4762a2d2012-04-16 04:16:43 +0000417 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruthfeee58c2010-10-20 07:00:47 +0000418 }
419 }
Douglas Gregor2a060852013-02-07 00:21:12 +0000420
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000421 // Parse additional include paths from environment variables.
Chandler Carruthb5870e72011-11-04 07:12:58 +0000422 // FIXME: We should probably sink the logic for handling these from the
423 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000424 // CPATH - included following the user specified includes (but prior to
425 // builtin and standard includes).
Bill Wendling3d717152012-03-12 22:10:06 +0000426 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000427 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendling3d717152012-03-12 22:10:06 +0000428 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000429 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendling3d717152012-03-12 22:10:06 +0000430 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000431 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendling3d717152012-03-12 22:10:06 +0000432 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer47adebe2011-09-22 21:41:16 +0000433 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendling3d717152012-03-12 22:10:06 +0000434 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth88491fc2011-11-04 07:12:53 +0000435
Chandler Carruth88491fc2011-11-04 07:12:53 +0000436 // Add C++ include arguments, if needed.
Chandler Carrutha4614422011-11-04 07:43:33 +0000437 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth7ffa0322011-11-04 07:34:47 +0000438 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carruth7d7e9f92011-11-05 20:17:13 +0000439
440 // Add system include arguments.
441 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbarc21c4852009-04-08 23:54:23 +0000442}
443
Daniel Dunbar1d65e4b2009-09-10 22:59:51 +0000444/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Daniel Dunbar728a5122009-09-10 06:49:20 +0000445/// CPU.
446//
447// FIXME: This is redundant with -mcpu, why does LLVM use this.
448// FIXME: tblgen this, or kill it!
Chris Lattner5f9e2722011-07-23 10:55:15 +0000449static const char *getLLVMArchSuffixForARM(StringRef CPU) {
Chad Rosierae1aee62011-10-07 17:48:56 +0000450 return llvm::StringSwitch<const char *>(CPU)
Tim Northover4889a1f2013-06-13 15:02:46 +0000451 .Case("strongarm", "v4")
Chad Rosierae1aee62011-10-07 17:48:56 +0000452 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
453 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
454 .Cases("arm920", "arm920t", "arm922t", "v4t")
455 .Cases("arm940t", "ep9312","v4t")
456 .Cases("arm10tdmi", "arm1020t", "v5")
457 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
458 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
459 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
460 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
461 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
462 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonfc553452013-03-04 22:37:46 +0000463 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
Renato Golin5df40452013-09-13 17:02:54 +0000464 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7")
465 .Cases("cortex-r4", "cortex-r5", "v7r")
Bob Wilson57f6d192012-03-21 17:19:12 +0000466 .Case("cortex-m0", "v6m")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000467 .Case("cortex-m3", "v7m")
468 .Case("cortex-m4", "v7em")
Bob Wilson336bfa32012-09-29 23:52:50 +0000469 .Case("cortex-a9-mp", "v7f")
470 .Case("swift", "v7s")
Chad Rosierae1aee62011-10-07 17:48:56 +0000471 .Default("");
Daniel Dunbar728a5122009-09-10 06:49:20 +0000472}
473
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000474/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
475//
476// FIXME: tblgen this.
477static std::string getARMTargetCPU(const ArgList &Args,
478 const llvm::Triple &Triple) {
479 // FIXME: Warn on inconsistent use of -mcpu and -march.
480
481 // If we have -mcpu=, use that.
482 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000483 StringRef MCPU = A->getValue();
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000484 // Handle -mcpu=native.
485 if (MCPU == "native")
486 return llvm::sys::getHostCPUName();
487 else
488 return MCPU;
489 }
490
491 StringRef MArch;
492 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
493 // Otherwise, if we have -march= choose the base CPU for that arch.
Richard Smith1d489cf2012-11-01 04:30:05 +0000494 MArch = A->getValue();
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000495 } else {
496 // Otherwise, use the Arch from the triple.
497 MArch = Triple.getArchName();
498 }
499
500 // Handle -march=native.
501 std::string NativeMArch;
502 if (MArch == "native") {
503 std::string CPU = llvm::sys::getHostCPUName();
504 if (CPU != "generic") {
505 // Translate the native cpu into the architecture. The switch below will
506 // then chose the minimum cpu for that arch.
507 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
508 MArch = NativeMArch;
509 }
510 }
511
512 return llvm::StringSwitch<const char *>(MArch)
513 .Cases("armv2", "armv2a","arm2")
514 .Case("armv3", "arm6")
515 .Case("armv3m", "arm7m")
Tim Northover4889a1f2013-06-13 15:02:46 +0000516 .Case("armv4", "strongarm")
517 .Case("armv4t", "arm7tdmi")
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000518 .Cases("armv5", "armv5t", "arm10tdmi")
519 .Cases("armv5e", "armv5te", "arm1022e")
520 .Case("armv5tej", "arm926ej-s")
521 .Cases("armv6", "armv6k", "arm1136jf-s")
522 .Case("armv6j", "arm1136j-s")
523 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
524 .Case("armv6t2", "arm1156t2-s")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000525 .Cases("armv6m", "armv6-m", "cortex-m0")
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000526 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
Bob Wilson2503ebd2013-03-04 22:37:49 +0000527 .Cases("armv7em", "armv7e-m", "cortex-m4")
Bob Wilson336bfa32012-09-29 23:52:50 +0000528 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
529 .Cases("armv7s", "armv7-s", "swift")
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000530 .Cases("armv7r", "armv7-r", "cortex-r4")
531 .Cases("armv7m", "armv7-m", "cortex-m3")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +0000532 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000533 .Case("ep9312", "ep9312")
534 .Case("iwmmxt", "iwmmxt")
535 .Case("xscale", "xscale")
Tim Northover4889a1f2013-06-13 15:02:46 +0000536 // If all else failed, return the most base CPU with thumb interworking
537 // supported by LLVM.
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000538 .Default("arm7tdmi");
539}
540
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000541// FIXME: Move to target hook.
542static bool isSignedCharDefault(const llvm::Triple &Triple) {
543 switch (Triple.getArch()) {
544 default:
545 return true;
546
Tim Northoverc264e162013-01-31 12:13:10 +0000547 case llvm::Triple::aarch64:
Jim Grosbach5b4e7b12011-05-24 15:40:46 +0000548 case llvm::Triple::arm:
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000549 case llvm::Triple::ppc:
550 case llvm::Triple::ppc64:
Bob Wilson905c45f2011-10-14 05:03:44 +0000551 if (Triple.isOSDarwin())
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000552 return true;
553 return false;
Ulrich Weigandb8409212013-05-06 16:26:41 +0000554
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000555 case llvm::Triple::ppc64le:
Ulrich Weigandb8409212013-05-06 16:26:41 +0000556 case llvm::Triple::systemz:
Robert Lytton5f15f4d2013-08-13 09:43:10 +0000557 case llvm::Triple::xcore:
Ulrich Weigandb8409212013-05-06 16:26:41 +0000558 return false;
Daniel Dunbar1f95e652009-11-17 06:37:03 +0000559 }
560}
561
Robert Lytton5f15f4d2013-08-13 09:43:10 +0000562static bool isNoCommonDefault(const llvm::Triple &Triple) {
563 switch (Triple.getArch()) {
564 default:
565 return false;
566
567 case llvm::Triple::xcore:
568 return true;
569 }
570}
571
Chad Rosier99317272012-04-04 20:51:35 +0000572// Handle -mfpu=.
573//
574// FIXME: Centralize feature selection, defaulting shouldn't be also in the
575// frontend target.
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000576static void getFPUFeatures(const Driver &D, const Arg *A, const ArgList &Args,
577 std::vector<const char *> &Features) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000578 StringRef FPU = A->getValue();
Chad Rosier99317272012-04-04 20:51:35 +0000579
580 // Set the target features based on the FPU.
581 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
582 // Disable any default FPU support.
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000583 Features.push_back("-vfp2");
584 Features.push_back("-vfp3");
585 Features.push_back("-neon");
Chad Rosier99317272012-04-04 20:51:35 +0000586 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000587 Features.push_back("+vfp3");
588 Features.push_back("+d16");
589 Features.push_back("-neon");
Chad Rosier99317272012-04-04 20:51:35 +0000590 } else if (FPU == "vfp") {
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000591 Features.push_back("+vfp2");
592 Features.push_back("-neon");
Chad Rosier99317272012-04-04 20:51:35 +0000593 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000594 Features.push_back("+vfp3");
595 Features.push_back("-neon");
Joey Goulycbed3bf2013-06-27 13:19:54 +0000596 } else if (FPU == "fp-armv8") {
Joey Gouly2b33b7e2013-09-13 13:48:33 +0000597 Features.push_back("+fp-armv8");
Joey Goulycbed3bf2013-06-27 13:19:54 +0000598 } else if (FPU == "neon-fp-armv8") {
Joey Gouly2b33b7e2013-09-13 13:48:33 +0000599 Features.push_back("+fp-armv8");
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000600 Features.push_back("+neon");
Amara Emersoncdc532c2013-09-19 13:54:03 +0000601 } else if (FPU == "crypto-neon-fp-armv8") {
602 Features.push_back("+crypto");
603 Features.push_back("+fp-armv8");
Chad Rosier99317272012-04-04 20:51:35 +0000604 } else if (FPU == "neon") {
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000605 Features.push_back("+neon");
Chad Rosier99317272012-04-04 20:51:35 +0000606 } else
607 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
608}
609
Anton Korobeynikove2571792012-04-09 13:38:30 +0000610// Select the float ABI as determined by -msoft-float, -mhard-float, and
611// -mfloat-abi=.
612static StringRef getARMFloatABI(const Driver &D,
613 const ArgList &Args,
614 const llvm::Triple &Triple) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000615 StringRef FloatABI;
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000616 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
617 options::OPT_mhard_float,
618 options::OPT_mfloat_abi_EQ)) {
619 if (A->getOption().matches(options::OPT_msoft_float))
620 FloatABI = "soft";
621 else if (A->getOption().matches(options::OPT_mhard_float))
622 FloatABI = "hard";
623 else {
Richard Smith1d489cf2012-11-01 04:30:05 +0000624 FloatABI = A->getValue();
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000625 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000626 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000627 << A->getAsString(Args);
628 FloatABI = "soft";
629 }
630 }
631 }
632
633 // If unspecified, choose the default based on the platform.
634 if (FloatABI.empty()) {
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000635 switch (Triple.getOS()) {
Bob Wilson905c45f2011-10-14 05:03:44 +0000636 case llvm::Triple::Darwin:
637 case llvm::Triple::MacOSX:
638 case llvm::Triple::IOS: {
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000639 // Darwin defaults to "softfp" for v6 and v7.
640 //
641 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000642 std::string ArchName =
Rafael Espindolabcd6df62010-06-28 17:18:09 +0000643 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000644 if (StringRef(ArchName).startswith("v6") ||
645 StringRef(ArchName).startswith("v7"))
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000646 FloatABI = "softfp";
647 else
648 FloatABI = "soft";
649 break;
650 }
651
Rafael Espindola27fa2362012-12-13 04:17:14 +0000652 case llvm::Triple::FreeBSD:
653 // FreeBSD defaults to soft float
654 FloatABI = "soft";
655 break;
656
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000657 default:
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000658 switch(Triple.getEnvironment()) {
Jiangning Liuff104a12012-07-31 08:06:29 +0000659 case llvm::Triple::GNUEABIHF:
660 FloatABI = "hard";
661 break;
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000662 case llvm::Triple::GNUEABI:
663 FloatABI = "softfp";
664 break;
665 case llvm::Triple::EABI:
666 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
667 FloatABI = "softfp";
668 break;
Logan Chien94a71422012-09-02 09:30:11 +0000669 case llvm::Triple::Android: {
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000670 std::string ArchName =
Chandler Carruthb43550b2012-01-10 19:47:42 +0000671 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
Benjamin Kramer92c4fd52012-06-26 22:20:06 +0000672 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthb43550b2012-01-10 19:47:42 +0000673 FloatABI = "softfp";
674 else
675 FloatABI = "soft";
676 break;
677 }
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000678 default:
679 // Assume "soft", but warn the user we are guessing.
680 FloatABI = "soft";
Chris Lattner5f9e2722011-07-23 10:55:15 +0000681 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsonfc2bd7c2011-02-04 17:59:28 +0000682 break;
683 }
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000684 }
685 }
686
Anton Korobeynikove2571792012-04-09 13:38:30 +0000687 return FloatABI;
688}
689
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000690static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
691 const ArgList &Args,
692 std::vector<const char *> &Features) {
693 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
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.
697 // Use software floating point operations?
698 if (FloatABI == "soft")
699 Features.push_back("+soft-float");
700
701 // Use software floating point argument passing?
702 if (FloatABI != "hard")
703 Features.push_back("+soft-float-abi");
704
705 // Honor -mfpu=.
706 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
707 getFPUFeatures(D, A, Args, Features);
708
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000709 // Setting -msoft-float effectively disables NEON because of the GCC
710 // implementation, although the same isn't true of VFP or VFP3.
711 if (FloatABI == "soft")
712 Features.push_back("-neon");
713}
Anton Korobeynikove2571792012-04-09 13:38:30 +0000714
715void Clang::AddARMTargetArgs(const ArgList &Args,
716 ArgStringList &CmdArgs,
717 bool KernelOrKext) const {
718 const Driver &D = getToolChain().getDriver();
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000719 // Get the effective triple, which takes into account the deployment target.
720 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
721 llvm::Triple Triple(TripleStr);
Daniel Dunbar2e4e1102012-10-22 18:30:51 +0000722 std::string CPUName = getARMTargetCPU(Args, Triple);
Anton Korobeynikove2571792012-04-09 13:38:30 +0000723
724 // Select the ABI to use.
725 //
726 // FIXME: Support -meabi.
727 const char *ABIName = 0;
728 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000729 ABIName = A->getValue();
Daniel Dunbar2e4e1102012-10-22 18:30:51 +0000730 } else if (Triple.isOSDarwin()) {
731 // The backend is hardwired to assume AAPCS for M-class processors, ensure
732 // the frontend matches that.
733 if (StringRef(CPUName).startswith("cortex-m")) {
734 ABIName = "aapcs";
735 } else {
736 ABIName = "apcs-gnu";
737 }
Anton Korobeynikove2571792012-04-09 13:38:30 +0000738 } else {
739 // Select the default based on the platform.
740 switch(Triple.getEnvironment()) {
Logan Chien94a71422012-09-02 09:30:11 +0000741 case llvm::Triple::Android:
Anton Korobeynikove2571792012-04-09 13:38:30 +0000742 case llvm::Triple::GNUEABI:
Jiangning Liuff104a12012-07-31 08:06:29 +0000743 case llvm::Triple::GNUEABIHF:
Anton Korobeynikove2571792012-04-09 13:38:30 +0000744 ABIName = "aapcs-linux";
745 break;
746 case llvm::Triple::EABI:
747 ABIName = "aapcs";
748 break;
749 default:
750 ABIName = "apcs-gnu";
751 }
752 }
753 CmdArgs.push_back("-target-abi");
754 CmdArgs.push_back(ABIName);
755
Anton Korobeynikove2571792012-04-09 13:38:30 +0000756 // Determine floating point ABI from the options & target defaults.
757 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000758 if (FloatABI == "soft") {
759 // Floating point operations and argument passing are soft.
760 //
761 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbar3b315262009-11-30 08:42:00 +0000762 CmdArgs.push_back("-msoft-float");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000763 CmdArgs.push_back("-mfloat-abi");
764 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000765 } else if (FloatABI == "softfp") {
766 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000767 CmdArgs.push_back("-mfloat-abi");
768 CmdArgs.push_back("soft");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000769 } else {
770 // Floating point operations and argument passing are hard.
771 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar87667aa2009-12-08 19:49:51 +0000772 CmdArgs.push_back("-mfloat-abi");
773 CmdArgs.push_back("hard");
Daniel Dunbarcbd19332009-09-10 23:00:09 +0000774 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +0000775
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000776 // Kernel code has more strict alignment requirements.
777 if (KernelOrKext) {
Cameron Esfahani57b1da12013-09-14 01:09:11 +0000778 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbar7a0c0642012-10-15 22:23:53 +0000779 CmdArgs.push_back("-backend-option");
780 CmdArgs.push_back("-arm-long-calls");
781 }
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000782
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000783 CmdArgs.push_back("-backend-option");
Daniel Dunbarfa41d692011-03-17 17:10:06 +0000784 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbarb5fbb892011-04-18 21:26:42 +0000785
786 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbarb5fbb892011-04-18 21:26:42 +0000787 CmdArgs.push_back("-backend-option");
Renato Golinebc313d2013-08-15 20:54:45 +0000788 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbar7187fac2011-03-17 00:07:34 +0000789 }
Chad Rosier1b906052011-08-26 00:26:29 +0000790
791 // Setting -mno-global-merge disables the codegen global merge pass. Setting
792 // -mglobal-merge has no effect as the pass is enabled by default.
793 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
794 options::OPT_mno_global_merge)) {
795 if (A->getOption().matches(options::OPT_mno_global_merge))
796 CmdArgs.push_back("-mno-global-merge");
797 }
Chad Rosieree9ad5c2012-05-16 20:40:09 +0000798
Bob Wilsonf6f77bd2013-04-11 18:53:25 +0000799 if (!Args.hasFlag(options::OPT_mimplicit_float,
800 options::OPT_mno_implicit_float,
801 true))
Chad Rosieree9ad5c2012-05-16 20:40:09 +0000802 CmdArgs.push_back("-no-implicit-float");
Renato Golin45bd2942013-08-24 14:44:35 +0000803
804 // llvm does not support reserving registers in general. There is support
805 // for reserving r9 on ARM though (defined as a platform-specific register
806 // in ARM EABI).
807 if (Args.hasArg(options::OPT_ffixed_r9)) {
808 CmdArgs.push_back("-backend-option");
809 CmdArgs.push_back("-arm-reserve-r9");
810 }
Daniel Dunbarb163ef72009-09-10 04:57:17 +0000811}
812
Simon Atanasyan8e1c5982012-09-21 20:19:32 +0000813// Translate MIPS CPU name alias option to CPU name.
814static StringRef getMipsCPUFromAlias(const Arg &A) {
815 if (A.getOption().matches(options::OPT_mips32))
816 return "mips32";
817 if (A.getOption().matches(options::OPT_mips32r2))
818 return "mips32r2";
819 if (A.getOption().matches(options::OPT_mips64))
820 return "mips64";
821 if (A.getOption().matches(options::OPT_mips64r2))
822 return "mips64r2";
823 llvm_unreachable("Unexpected option");
824 return "";
825}
826
Simon Atanasyana2768be2012-04-07 22:09:23 +0000827// Get CPU and ABI names. They are not independent
828// so we have to calculate them together.
829static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindolab330e402013-08-20 22:12:08 +0000830 const llvm::Triple &Triple,
Simon Atanasyana2768be2012-04-07 22:09:23 +0000831 StringRef &CPUName,
832 StringRef &ABIName) {
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000833 const char *DefMips32CPU = "mips32";
834 const char *DefMips64CPU = "mips64";
Akira Hatanaka9f360622011-09-26 21:07:52 +0000835
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000836 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyan8e1c5982012-09-21 20:19:32 +0000837 options::OPT_mcpu_EQ,
838 options::OPT_mips_CPUs_Group)) {
839 if (A->getOption().matches(options::OPT_mips_CPUs_Group))
840 CPUName = getMipsCPUFromAlias(*A);
841 else
Richard Smith1d489cf2012-11-01 04:30:05 +0000842 CPUName = A->getValue();
Simon Atanasyan8e1c5982012-09-21 20:19:32 +0000843 }
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000844
Simon Atanasyanc7e2a4e2013-04-21 13:30:10 +0000845 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +0000846 ABIName = A->getValue();
Simon Atanasyanc7e2a4e2013-04-21 13:30:10 +0000847 // Convert a GNU style Mips ABI name to the name
848 // accepted by LLVM Mips backend.
849 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
850 .Case("32", "o32")
851 .Case("64", "n64")
852 .Default(ABIName);
853 }
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000854
855 // Setup default CPU and ABI names.
856 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindolab330e402013-08-20 22:12:08 +0000857 switch (Triple.getArch()) {
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000858 default:
859 llvm_unreachable("Unexpected triple arch name");
860 case llvm::Triple::mips:
861 case llvm::Triple::mipsel:
862 CPUName = DefMips32CPU;
863 break;
864 case llvm::Triple::mips64:
865 case llvm::Triple::mips64el:
866 CPUName = DefMips64CPU;
867 break;
868 }
869 }
870
871 if (!ABIName.empty()) {
872 // Deduce CPU name from ABI name.
873 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyane9616a42013-02-27 14:55:49 +0000874 .Cases("32", "o32", "eabi", DefMips32CPU)
875 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan89d83ff2012-09-10 08:32:41 +0000876 .Default("");
877 }
878 else if (!CPUName.empty()) {
879 // Deduce ABI name from CPU name.
880 ABIName = llvm::StringSwitch<const char *>(CPUName)
881 .Cases("mips32", "mips32r2", "o32")
882 .Cases("mips64", "mips64r2", "n64")
883 .Default("");
884 }
885
886 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyana2768be2012-04-07 22:09:23 +0000887}
888
Simon Atanasyane9616a42013-02-27 14:55:49 +0000889// Convert ABI name to the GNU tools acceptable variant.
890static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
891 return llvm::StringSwitch<llvm::StringRef>(ABI)
892 .Case("o32", "32")
893 .Case("n64", "64")
894 .Default(ABI);
895}
896
Simon Atanasyan5e627792012-06-02 15:06:29 +0000897// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
898// and -mfloat-abi=.
899static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000900 StringRef FloatABI;
Eric Christophered734732010-03-02 02:41:08 +0000901 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000902 options::OPT_mhard_float,
903 options::OPT_mfloat_abi_EQ)) {
Eric Christophered734732010-03-02 02:41:08 +0000904 if (A->getOption().matches(options::OPT_msoft_float))
905 FloatABI = "soft";
906 else if (A->getOption().matches(options::OPT_mhard_float))
907 FloatABI = "hard";
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000908 else {
Richard Smith1d489cf2012-11-01 04:30:05 +0000909 FloatABI = A->getValue();
Simon Atanasyan2ed42b82013-04-14 08:37:15 +0000910 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan5e627792012-06-02 15:06:29 +0000911 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000912 FloatABI = "hard";
913 }
914 }
Eric Christophered734732010-03-02 02:41:08 +0000915 }
916
917 // If unspecified, choose the default based on the platform.
918 if (FloatABI.empty()) {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000919 // Assume "hard", because it's a default value used by gcc.
920 // When we start to recognize specific target MIPS processors,
921 // we will be able to select the default more correctly.
922 FloatABI = "hard";
Eric Christophered734732010-03-02 02:41:08 +0000923 }
924
Simon Atanasyan5e627792012-06-02 15:06:29 +0000925 return FloatABI;
926}
927
Simon Atanasyandc536f52012-07-05 18:51:43 +0000928static void AddTargetFeature(const ArgList &Args,
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000929 std::vector<const char *> &Features,
930 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyandc536f52012-07-05 18:51:43 +0000931 StringRef FeatureName) {
932 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyandc536f52012-07-05 18:51:43 +0000933 if (A->getOption().matches(OnOpt))
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000934 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyandc536f52012-07-05 18:51:43 +0000935 else
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000936 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyandc536f52012-07-05 18:51:43 +0000937 }
938}
939
Rafael Espindola146dbbf2013-08-21 16:39:20 +0000940static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
941 std::vector<const char *> &Features) {
942 StringRef FloatABI = getMipsFloatABI(D, Args);
943 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
944 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
945 // FIXME: Note, this is a hack. We need to pass the selected float
946 // mode to the MipsTargetInfoBase to define appropriate macros there.
947 // Now it is the only method.
948 Features.push_back("+soft-float");
949 }
950
951 AddTargetFeature(Args, Features, options::OPT_msingle_float,
952 options::OPT_mdouble_float, "single-float");
953 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
954 "mips16");
955 AddTargetFeature(Args, Features, options::OPT_mmicromips,
956 options::OPT_mno_micromips, "micromips");
957 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
958 "dsp");
959 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
960 "dspr2");
961 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
962 "msa");
963}
964
Simon Atanasyan5e627792012-06-02 15:06:29 +0000965void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyana8141612013-04-14 14:07:41 +0000966 ArgStringList &CmdArgs) const {
Simon Atanasyan5e627792012-06-02 15:06:29 +0000967 const Driver &D = getToolChain().getDriver();
968 StringRef CPUName;
969 StringRef ABIName;
Rafael Espindolab330e402013-08-20 22:12:08 +0000970 const llvm::Triple &Triple = getToolChain().getTriple();
971 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan5e627792012-06-02 15:06:29 +0000972
973 CmdArgs.push_back("-target-abi");
974 CmdArgs.push_back(ABIName.data());
975
976 StringRef FloatABI = getMipsFloatABI(D, Args);
977
Simon Atanasyane1d792f2013-01-10 12:36:19 +0000978 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
979
980 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
Eric Christophered734732010-03-02 02:41:08 +0000981 // Floating point operations and argument passing are soft.
Eric Christophered734732010-03-02 02:41:08 +0000982 CmdArgs.push_back("-msoft-float");
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000983 CmdArgs.push_back("-mfloat-abi");
984 CmdArgs.push_back("soft");
985
Simon Atanasyane1d792f2013-01-10 12:36:19 +0000986 if (FloatABI == "hard" && IsMips16) {
987 CmdArgs.push_back("-mllvm");
988 CmdArgs.push_back("-mips16-hard-float");
989 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000990 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000991 else {
992 // Floating point operations and argument passing are hard.
Eric Christophered734732010-03-02 02:41:08 +0000993 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanakaad8d8a32012-03-23 23:07:09 +0000994 CmdArgs.push_back("-mfloat-abi");
995 CmdArgs.push_back("hard");
Eric Christophered734732010-03-02 02:41:08 +0000996 }
Simon Atanasyan0b273ef2012-07-05 14:19:39 +0000997
Simon Atanasyanbda07ac2012-12-01 18:27:21 +0000998 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
999 if (A->getOption().matches(options::OPT_mxgot)) {
1000 CmdArgs.push_back("-mllvm");
1001 CmdArgs.push_back("-mxgot");
1002 }
1003 }
1004
Simon Atanasyan6bdc4c62013-05-11 06:33:44 +00001005 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1006 options::OPT_mno_ldc1_sdc1)) {
1007 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1008 CmdArgs.push_back("-mllvm");
1009 CmdArgs.push_back("-mno-ldc1-sdc1");
1010 }
1011 }
1012
Akira Hatanakacdbc3b32013-07-19 18:58:48 +00001013 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1014 options::OPT_mno_check_zero_division)) {
1015 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1016 CmdArgs.push_back("-mllvm");
1017 CmdArgs.push_back("-mno-check-zero-division");
1018 }
1019 }
1020
Simon Atanasyan9804b762012-08-27 20:55:56 +00001021 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00001022 StringRef v = A->getValue();
Simon Atanasyan9804b762012-08-27 20:55:56 +00001023 CmdArgs.push_back("-mllvm");
1024 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1025 A->claim();
1026 }
Eric Christophered734732010-03-02 02:41:08 +00001027}
1028
Hal Finkel02a84272012-06-11 22:35:19 +00001029/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1030static std::string getPPCTargetCPU(const ArgList &Args) {
1031 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00001032 StringRef CPUName = A->getValue();
Hal Finkel02a84272012-06-11 22:35:19 +00001033
1034 if (CPUName == "native") {
1035 std::string CPU = llvm::sys::getHostCPUName();
1036 if (!CPU.empty() && CPU != "generic")
1037 return CPU;
1038 else
1039 return "";
1040 }
1041
1042 return llvm::StringSwitch<const char *>(CPUName)
1043 .Case("common", "generic")
1044 .Case("440", "440")
1045 .Case("440fp", "440")
1046 .Case("450", "450")
1047 .Case("601", "601")
1048 .Case("602", "602")
1049 .Case("603", "603")
1050 .Case("603e", "603e")
1051 .Case("603ev", "603ev")
1052 .Case("604", "604")
1053 .Case("604e", "604e")
1054 .Case("620", "620")
Bill Schmidt2821e182013-02-01 20:23:10 +00001055 .Case("630", "pwr3")
Hal Finkel02a84272012-06-11 22:35:19 +00001056 .Case("G3", "g3")
1057 .Case("7400", "7400")
1058 .Case("G4", "g4")
1059 .Case("7450", "7450")
1060 .Case("G4+", "g4+")
1061 .Case("750", "750")
1062 .Case("970", "970")
1063 .Case("G5", "g5")
1064 .Case("a2", "a2")
Hal Finkel5ccd3d02013-02-01 05:53:33 +00001065 .Case("a2q", "a2q")
Hal Finkel7de32962012-09-18 22:25:03 +00001066 .Case("e500mc", "e500mc")
1067 .Case("e5500", "e5500")
Bill Schmidt2821e182013-02-01 20:23:10 +00001068 .Case("power3", "pwr3")
1069 .Case("power4", "pwr4")
1070 .Case("power5", "pwr5")
1071 .Case("power5x", "pwr5x")
Hal Finkel02a84272012-06-11 22:35:19 +00001072 .Case("power6", "pwr6")
Bill Schmidt2821e182013-02-01 20:23:10 +00001073 .Case("power6x", "pwr6x")
Hal Finkel02a84272012-06-11 22:35:19 +00001074 .Case("power7", "pwr7")
Bill Schmidt2821e182013-02-01 20:23:10 +00001075 .Case("pwr3", "pwr3")
1076 .Case("pwr4", "pwr4")
1077 .Case("pwr5", "pwr5")
1078 .Case("pwr5x", "pwr5x")
1079 .Case("pwr6", "pwr6")
1080 .Case("pwr6x", "pwr6x")
1081 .Case("pwr7", "pwr7")
Hal Finkel02a84272012-06-11 22:35:19 +00001082 .Case("powerpc", "ppc")
1083 .Case("powerpc64", "ppc64")
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001084 .Case("powerpc64le", "ppc64le")
Hal Finkel02a84272012-06-11 22:35:19 +00001085 .Default("");
1086 }
1087
1088 return "";
1089}
1090
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001091static void getPPCTargetFeatures(const ArgList &Args,
1092 std::vector<const char *> &Features) {
Bill Schmidt199402b2013-02-01 02:14:03 +00001093 // Allow override of the Altivec feature.
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001094 AddTargetFeature(Args, Features, options::OPT_faltivec,
1095 options::OPT_fno_altivec, "altivec");
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001096
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001097 AddTargetFeature(Args, Features, options::OPT_mfprnd, options::OPT_mno_fprnd,
Hal Finkelfe6b2712013-03-30 13:47:44 +00001098 "fprnd");
1099
Hal Finkelf4320ab2013-03-28 08:38:53 +00001100 // Note that gcc calls this mfcrf and LLVM calls this mfocrf.
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001101 AddTargetFeature(Args, Features, options::OPT_mmfcrf, options::OPT_mno_mfcrf,
Hal Finkelf4320ab2013-03-28 08:38:53 +00001102 "mfocrf");
1103
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001104 AddTargetFeature(Args, Features, options::OPT_mpopcntd,
1105 options::OPT_mno_popcntd, "popcntd");
Hal Finkel829d1872013-03-28 13:51:36 +00001106
Hal Finkelf4320ab2013-03-28 08:38:53 +00001107 // It is really only possible to turn qpx off because turning qpx on is tied
1108 // to using the a2q CPU.
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001109 if (Args.hasFlag(options::OPT_mno_qpx, options::OPT_mqpx, false))
1110 Features.push_back("-qpx");
Hal Finkel02a84272012-06-11 22:35:19 +00001111}
1112
Tom Stellarde25d2f62013-04-01 20:56:53 +00001113/// Get the (LLVM) name of the R600 gpu we are targeting.
1114static std::string getR600TargetGPU(const ArgList &Args) {
1115 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1116 std::string GPUName = A->getValue();
1117 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardfd4aa4b2013-05-06 16:12:05 +00001118 .Cases("rv630", "rv635", "r600")
1119 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellarde25d2f62013-04-01 20:56:53 +00001120 .Case("rv740", "rv770")
1121 .Case("palm", "cedar")
Tom Stellardfd4aa4b2013-05-06 16:12:05 +00001122 .Cases("sumo", "sumo2", "sumo")
Tom Stellarde25d2f62013-04-01 20:56:53 +00001123 .Case("hemlock", "cypress")
1124 .Case("aruba", "cayman")
1125 .Default(GPUName.c_str());
1126 }
1127 return "";
1128}
1129
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001130static void getSparcTargetFeatures(const ArgList &Args,
1131 std::vector<const char *> Features) {
1132 bool SoftFloatABI = true;
1133 if (Arg *A =
1134 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1135 if (A->getOption().matches(options::OPT_mhard_float))
1136 SoftFloatABI = false;
1137 }
1138 if (SoftFloatABI)
1139 Features.push_back("+soft-float");
1140}
1141
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001142void Clang::AddSparcTargetArgs(const ArgList &Args,
1143 ArgStringList &CmdArgs) const {
1144 const Driver &D = getToolChain().getDriver();
1145
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001146 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner5f9e2722011-07-23 10:55:15 +00001147 StringRef FloatABI;
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001148 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1149 options::OPT_mhard_float)) {
1150 if (A->getOption().matches(options::OPT_msoft_float))
1151 FloatABI = "soft";
1152 else if (A->getOption().matches(options::OPT_mhard_float))
1153 FloatABI = "hard";
1154 }
1155
1156 // If unspecified, choose the default based on the platform.
1157 if (FloatABI.empty()) {
Aaron Ballmand58915e2013-07-15 13:41:33 +00001158 // Assume "soft", but warn the user we are guessing.
1159 FloatABI = "soft";
1160 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001161 }
1162
1163 if (FloatABI == "soft") {
1164 // Floating point operations and argument passing are soft.
1165 //
1166 // FIXME: This changes CPP defines, we need -target-soft-float.
1167 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00001168 } else {
1169 assert(FloatABI == "hard" && "Invalid float abi!");
1170 CmdArgs.push_back("-mhard-float");
1171 }
1172}
1173
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00001174static const char *getSystemZTargetCPU(const ArgList &Args) {
1175 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1176 return A->getValue();
1177 return "z10";
1178}
1179
Chandler Carruth700d4e42013-01-13 11:46:33 +00001180static const char *getX86TargetCPU(const ArgList &Args,
1181 const llvm::Triple &Triple) {
1182 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1183 if (StringRef(A->getValue()) != "native")
1184 return A->getValue();
1185
1186 // FIXME: Reject attempts to use -march=native unless the target matches
1187 // the host.
1188 //
1189 // FIXME: We should also incorporate the detected target features for use
1190 // with -native.
1191 std::string CPU = llvm::sys::getHostCPUName();
1192 if (!CPU.empty() && CPU != "generic")
1193 return Args.MakeArgString(CPU);
1194 }
1195
1196 // Select the default CPU if none was given (or detection failed).
1197
1198 if (Triple.getArch() != llvm::Triple::x86_64 &&
1199 Triple.getArch() != llvm::Triple::x86)
1200 return 0; // This routine is only handling x86 targets.
1201
1202 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1203
1204 // FIXME: Need target hooks.
1205 if (Triple.isOSDarwin())
1206 return Is64Bit ? "core2" : "yonah";
1207
1208 // Everything else goes to x86-64 in 64-bit mode.
1209 if (Is64Bit)
1210 return "x86-64";
1211
1212 if (Triple.getOSName().startswith("haiku"))
1213 return "i586";
1214 if (Triple.getOSName().startswith("openbsd"))
1215 return "i486";
1216 if (Triple.getOSName().startswith("bitrig"))
1217 return "i686";
1218 if (Triple.getOSName().startswith("freebsd"))
1219 return "i486";
1220 if (Triple.getOSName().startswith("netbsd"))
1221 return "i486";
1222 // All x86 devices running Android have core2 as their common
1223 // denominator. This makes a better choice than pentium4.
1224 if (Triple.getEnvironment() == llvm::Triple::Android)
1225 return "core2";
1226
1227 // Fallback to p4.
1228 return "pentium4";
1229}
1230
Rafael Espindolab330e402013-08-20 22:12:08 +00001231static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1232 switch(T.getArch()) {
1233 default:
1234 return "";
1235
1236 case llvm::Triple::arm:
1237 case llvm::Triple::thumb:
1238 return getARMTargetCPU(Args, T);
1239
1240 case llvm::Triple::mips:
1241 case llvm::Triple::mipsel:
1242 case llvm::Triple::mips64:
1243 case llvm::Triple::mips64el: {
1244 StringRef CPUName;
1245 StringRef ABIName;
1246 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1247 return CPUName;
1248 }
1249
1250 case llvm::Triple::ppc:
1251 case llvm::Triple::ppc64:
1252 case llvm::Triple::ppc64le: {
1253 std::string TargetCPUName = getPPCTargetCPU(Args);
1254 // LLVM may default to generating code for the native CPU,
1255 // but, like gcc, we default to a more generic option for
1256 // each architecture. (except on Darwin)
1257 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1258 if (T.getArch() == llvm::Triple::ppc64)
1259 TargetCPUName = "ppc64";
1260 else if (T.getArch() == llvm::Triple::ppc64le)
1261 TargetCPUName = "ppc64le";
1262 else
1263 TargetCPUName = "ppc";
1264 }
1265 return TargetCPUName;
1266 }
1267
1268 case llvm::Triple::sparc:
1269 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1270 return A->getValue();
1271 return "";
1272
1273 case llvm::Triple::x86:
1274 case llvm::Triple::x86_64:
1275 return getX86TargetCPU(Args, T);
1276
1277 case llvm::Triple::hexagon:
1278 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1279
1280 case llvm::Triple::systemz:
1281 return getSystemZTargetCPU(Args);
1282
1283 case llvm::Triple::r600:
1284 return getR600TargetGPU(Args);
1285 }
1286}
1287
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001288static void getX86TargetFeatures(const ArgList &Args,
1289 std::vector<const char *> &Features) {
1290 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1291 ie = Args.filtered_end();
1292 it != ie; ++it) {
1293 StringRef Name = (*it)->getOption().getName();
1294 (*it)->claim();
1295
1296 // Skip over "-m".
1297 assert(Name.startswith("m") && "Invalid feature name.");
1298 Name = Name.substr(1);
1299
1300 bool IsNegative = Name.startswith("no-");
1301 if (IsNegative)
1302 Name = Name.substr(3);
1303
1304 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1305 }
1306}
1307
Daniel Dunbar6acda162009-09-09 22:33:08 +00001308void Clang::AddX86TargetArgs(const ArgList &Args,
1309 ArgStringList &CmdArgs) const {
Daniel Dunbare6ad3f92009-09-10 22:59:57 +00001310 if (!Args.hasFlag(options::OPT_mred_zone,
1311 options::OPT_mno_red_zone,
1312 true) ||
1313 Args.hasArg(options::OPT_mkernel) ||
1314 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar66861e02009-11-20 22:21:36 +00001315 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare6ad3f92009-09-10 22:59:57 +00001316
Bob Wilsonf0c54562013-02-10 16:01:41 +00001317 // Default to avoid implicit floating-point for kernel/kext code, but allow
1318 // that to be overridden with -mno-soft-float.
1319 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1320 Args.hasArg(options::OPT_fapple_kext));
1321 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1322 options::OPT_mno_soft_float,
Bob Wilsonf6f77bd2013-04-11 18:53:25 +00001323 options::OPT_mimplicit_float,
Bob Wilsonf0c54562013-02-10 16:01:41 +00001324 options::OPT_mno_implicit_float)) {
1325 const Option &O = A->getOption();
1326 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1327 O.matches(options::OPT_msoft_float));
1328 }
1329 if (NoImplicitFloat)
Daniel Dunbar66861e02009-11-20 22:21:36 +00001330 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar6acda162009-09-09 22:33:08 +00001331}
1332
Matthew Curtis33c95f12012-12-06 17:49:03 +00001333static inline bool HasPICArg(const ArgList &Args) {
1334 return Args.hasArg(options::OPT_fPIC)
1335 || Args.hasArg(options::OPT_fpic);
1336}
1337
1338static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1339 return Args.getLastArg(options::OPT_G,
1340 options::OPT_G_EQ,
1341 options::OPT_msmall_data_threshold_EQ);
1342}
1343
1344static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1345 std::string value;
1346 if (HasPICArg(Args))
1347 value = "0";
1348 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1349 value = A->getValue();
1350 A->claim();
1351 }
1352 return value;
1353}
1354
Tony Linthicum96319392011-12-12 21:14:55 +00001355void Clang::AddHexagonTargetArgs(const ArgList &Args,
1356 ArgStringList &CmdArgs) const {
Tony Linthicum96319392011-12-12 21:14:55 +00001357 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis1dbaef52012-12-07 13:52:44 +00001358 CmdArgs.push_back("-mqdsp6-compat");
1359 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum96319392011-12-12 21:14:55 +00001360
Matthew Curtis33c95f12012-12-06 17:49:03 +00001361 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1362 if (!SmallDataThreshold.empty()) {
Tony Linthicum96319392011-12-12 21:14:55 +00001363 CmdArgs.push_back ("-mllvm");
Matthew Curtis33c95f12012-12-06 17:49:03 +00001364 CmdArgs.push_back(Args.MakeArgString(
1365 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum96319392011-12-12 21:14:55 +00001366 }
1367
Sirish Pande5f9688b2012-05-10 20:19:54 +00001368 if (!Args.hasArg(options::OPT_fno_short_enums))
1369 CmdArgs.push_back("-fshort-enums");
1370 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1371 CmdArgs.push_back ("-mllvm");
1372 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1373 }
Tony Linthicum96319392011-12-12 21:14:55 +00001374 CmdArgs.push_back ("-mllvm");
1375 CmdArgs.push_back ("-machine-sink-split=0");
1376}
1377
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001378static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1379 std::vector<const char *> &Features) {
Tim Northoverb793f0d2013-08-01 09:23:19 +00001380 // Honor -mfpu=.
1381 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001382 getFPUFeatures(D, A, Args, Features);
1383}
1384
1385static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1386 const ArgList &Args, ArgStringList &CmdArgs) {
1387 std::vector<const char *> Features;
1388 switch (Triple.getArch()) {
1389 default:
1390 break;
1391 case llvm::Triple::mips:
1392 case llvm::Triple::mipsel:
1393 case llvm::Triple::mips64:
1394 case llvm::Triple::mips64el:
1395 getMIPSTargetFeatures(D, Args, Features);
1396 break;
1397
1398 case llvm::Triple::arm:
1399 case llvm::Triple::thumb:
1400 getARMTargetFeatures(D, Triple, Args, Features);
1401 break;
1402
1403 case llvm::Triple::ppc:
1404 case llvm::Triple::ppc64:
1405 case llvm::Triple::ppc64le:
1406 getPPCTargetFeatures(Args, Features);
1407 break;
1408 case llvm::Triple::sparc:
1409 getSparcTargetFeatures(Args, Features);
1410 break;
1411 case llvm::Triple::aarch64:
1412 getAArch64TargetFeatures(D, Args, Features);
1413 break;
1414 case llvm::Triple::x86:
1415 case llvm::Triple::x86_64:
1416 getX86TargetFeatures(Args, Features);
1417 break;
1418 }
Rafael Espindolabc1e5452013-08-21 17:34:32 +00001419
1420 // Find the last of each feature.
1421 llvm::StringMap<unsigned> LastOpt;
1422 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1423 const char *Name = Features[I];
1424 assert(Name[0] == '-' || Name[0] == '+');
1425 LastOpt[Name + 1] = I;
1426 }
1427
1428 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1429 // If this feature was overridden, ignore it.
1430 const char *Name = Features[I];
1431 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1432 assert(LastI != LastOpt.end());
1433 unsigned Last = LastI->second;
1434 if (Last != I)
1435 continue;
1436
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001437 CmdArgs.push_back("-target-feature");
Rafael Espindolabc1e5452013-08-21 17:34:32 +00001438 CmdArgs.push_back(Name);
Rafael Espindola146dbbf2013-08-21 16:39:20 +00001439 }
Tim Northoverb793f0d2013-08-01 09:23:19 +00001440}
1441
Eric Christopher88b7cf02011-08-19 00:30:14 +00001442static bool
John McCall260611a2012-06-20 06:18:46 +00001443shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson525544d2011-02-28 00:44:51 +00001444 const llvm::Triple &Triple) {
1445 // We use the zero-cost exception tables for Objective-C if the non-fragile
1446 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1447 // later.
John McCall260611a2012-06-20 06:18:46 +00001448 if (runtime.isNonFragile())
Anders Carlsson525544d2011-02-28 00:44:51 +00001449 return true;
1450
Bob Wilson905c45f2011-10-14 05:03:44 +00001451 if (!Triple.isOSDarwin())
Anders Carlsson525544d2011-02-28 00:44:51 +00001452 return false;
1453
Eric Christopheraa7333c2011-07-02 00:20:22 +00001454 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson525544d2011-02-28 00:44:51 +00001455 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher88b7cf02011-08-19 00:30:14 +00001456 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson525544d2011-02-28 00:44:51 +00001457}
1458
Anders Carlsson15348ae2011-02-28 02:27:16 +00001459/// addExceptionArgs - Adds exception related arguments to the driver command
1460/// arguments. There's a master flag, -fexceptions and also language specific
1461/// flags to enable/disable C++ and Objective-C exceptions.
1462/// This makes it possible to for example disable C++ exceptions but enable
1463/// Objective-C exceptions.
1464static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1465 const llvm::Triple &Triple,
Fariborz Jahanian15b77312012-04-04 18:28:00 +00001466 bool KernelOrKext,
John McCall260611a2012-06-20 06:18:46 +00001467 const ObjCRuntime &objcRuntime,
Anders Carlsson15348ae2011-02-28 02:27:16 +00001468 ArgStringList &CmdArgs) {
Chad Rosierafc4baa2012-03-26 22:04:46 +00001469 if (KernelOrKext) {
1470 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1471 // arguments now to avoid warnings about unused arguments.
1472 Args.ClaimAllArgs(options::OPT_fexceptions);
1473 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1474 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1475 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1476 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1477 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlsson15348ae2011-02-28 02:27:16 +00001478 return;
Chad Rosierafc4baa2012-03-26 22:04:46 +00001479 }
Anders Carlsson15348ae2011-02-28 02:27:16 +00001480
1481 // Exceptions are enabled by default.
1482 bool ExceptionsEnabled = true;
1483
1484 // This keeps track of whether exceptions were explicitly turned on or off.
1485 bool DidHaveExplicitExceptionFlag = false;
1486
Rafael Espindolaf759df02009-10-01 13:33:33 +00001487 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1488 options::OPT_fno_exceptions)) {
1489 if (A->getOption().matches(options::OPT_fexceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +00001490 ExceptionsEnabled = true;
Eric Christopher88b7cf02011-08-19 00:30:14 +00001491 else
Anders Carlsson15348ae2011-02-28 02:27:16 +00001492 ExceptionsEnabled = false;
1493
1494 DidHaveExplicitExceptionFlag = true;
Rafael Espindolaf759df02009-10-01 13:33:33 +00001495 }
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +00001496
Anders Carlsson15348ae2011-02-28 02:27:16 +00001497 bool ShouldUseExceptionTables = false;
Fariborz Jahanian85caf032009-10-01 20:30:46 +00001498
Anders Carlsson15348ae2011-02-28 02:27:16 +00001499 // Exception tables and cleanups can be enabled with -fexceptions even if the
1500 // language itself doesn't support exceptions.
1501 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1502 ShouldUseExceptionTables = true;
Daniel Dunbar1a2cd4f2010-09-14 23:12:31 +00001503
Daniel Dunbard47ea692011-03-17 23:28:31 +00001504 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1505 // is not necessarily sensible, but follows GCC.
1506 if (types::isObjC(InputType) &&
Eric Christopher88b7cf02011-08-19 00:30:14 +00001507 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbard47ea692011-03-17 23:28:31 +00001508 options::OPT_fno_objc_exceptions,
1509 true)) {
1510 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlsson15348ae2011-02-28 02:27:16 +00001511
Eric Christopher88b7cf02011-08-19 00:30:14 +00001512 ShouldUseExceptionTables |=
John McCall260611a2012-06-20 06:18:46 +00001513 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlsson15348ae2011-02-28 02:27:16 +00001514 }
1515
1516 if (types::isCXX(InputType)) {
1517 bool CXXExceptionsEnabled = ExceptionsEnabled;
1518
Eric Christopher88b7cf02011-08-19 00:30:14 +00001519 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1520 options::OPT_fno_cxx_exceptions,
Anders Carlsson15348ae2011-02-28 02:27:16 +00001521 options::OPT_fexceptions,
1522 options::OPT_fno_exceptions)) {
1523 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1524 CXXExceptionsEnabled = true;
Chandler Carruth43f220f2011-02-28 07:25:18 +00001525 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlsson15348ae2011-02-28 02:27:16 +00001526 CXXExceptionsEnabled = false;
1527 }
1528
1529 if (CXXExceptionsEnabled) {
1530 CmdArgs.push_back("-fcxx-exceptions");
1531
1532 ShouldUseExceptionTables = true;
1533 }
1534 }
1535
1536 if (ShouldUseExceptionTables)
1537 CmdArgs.push_back("-fexceptions");
Rafael Espindolaf759df02009-10-01 13:33:33 +00001538}
1539
Daniel Dunbarf4910132013-04-16 18:21:19 +00001540static bool ShouldDisableAutolink(const ArgList &Args,
1541 const ToolChain &TC) {
1542 bool Default = true;
1543 if (TC.getTriple().isOSDarwin()) {
1544 // The native darwin assembler doesn't support the linker_option directives,
1545 // so we disable them if we think the .s file will be passed to it.
1546 Default = TC.useIntegratedAs();
1547 }
1548 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1549 Default);
1550}
1551
Rafael Espindola61b1efe2011-05-02 17:43:32 +00001552static bool ShouldDisableCFI(const ArgList &Args,
1553 const ToolChain &TC) {
Rafael Espindola701ec8d2012-03-08 14:39:55 +00001554 bool Default = true;
Bob Wilson905c45f2011-10-14 05:03:44 +00001555 if (TC.getTriple().isOSDarwin()) {
Rafael Espindola97f6abb2011-05-17 16:26:17 +00001556 // The native darwin assembler doesn't support cfi directives, so
Rafael Espindolacb773922011-05-17 19:06:58 +00001557 // we disable them if we think the .s file will be passed to it.
Rafael Espindolaaf370e62013-03-18 18:10:27 +00001558 Default = TC.useIntegratedAs();
Rafael Espindola97f6abb2011-05-17 16:26:17 +00001559 }
Rafael Espindola701ec8d2012-03-08 14:39:55 +00001560 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
Eric Christopher27e2b982012-12-18 00:31:10 +00001561 options::OPT_fno_dwarf2_cfi_asm,
1562 Default);
Rafael Espindola61b1efe2011-05-02 17:43:32 +00001563}
1564
Ted Kremenekc06fcdf2013-03-12 17:02:12 +00001565static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1566 const ToolChain &TC) {
Nick Lewyckyea523d72011-10-17 23:05:52 +00001567 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1568 options::OPT_fno_dwarf_directory_asm,
Rafael Espindolaaf370e62013-03-18 18:10:27 +00001569 TC.useIntegratedAs());
Nick Lewyckyea523d72011-10-17 23:05:52 +00001570 return !UseDwarfDirectory;
1571}
1572
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00001573/// \brief Check whether the given input tree contains any compilation actions.
1574static bool ContainsCompileAction(const Action *A) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001575 if (isa<CompileJobAction>(A))
Joerg Sonnenberger359cf922011-05-06 14:35:16 +00001576 return true;
1577
1578 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1579 if (ContainsCompileAction(*it))
1580 return true;
1581
1582 return false;
1583}
1584
1585/// \brief Check if -relax-all should be passed to the internal assembler.
1586/// This is done by default when compiling non-assembler source with -O0.
1587static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1588 bool RelaxDefault = true;
1589
1590 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1591 RelaxDefault = A->getOption().matches(options::OPT_O0);
1592
1593 if (RelaxDefault) {
1594 RelaxDefault = false;
1595 for (ActionList::const_iterator it = C.getActions().begin(),
1596 ie = C.getActions().end(); it != ie; ++it) {
1597 if (ContainsCompileAction(*it)) {
1598 RelaxDefault = true;
1599 break;
1600 }
1601 }
1602 }
1603
1604 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1605 RelaxDefault);
1606}
1607
David Blaikie73168db2013-07-25 21:19:01 +00001608static void CollectArgsForIntegratedAssembler(Compilation &C,
1609 const ArgList &Args,
1610 ArgStringList &CmdArgs,
1611 const Driver &D) {
1612 if (UseRelaxAll(C, Args))
1613 CmdArgs.push_back("-mrelax-all");
1614
1615 // When using an integrated assembler, translate -Wa, and -Xassembler
1616 // options.
1617 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1618 options::OPT_Xassembler),
1619 ie = Args.filtered_end(); it != ie; ++it) {
1620 const Arg *A = *it;
1621 A->claim();
1622
1623 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1624 StringRef Value = A->getValue(i);
1625
1626 if (Value == "-force_cpusubtype_ALL") {
1627 // Do nothing, this is the default and we don't support anything else.
1628 } else if (Value == "-L") {
1629 CmdArgs.push_back("-msave-temp-labels");
1630 } else if (Value == "--fatal-warnings") {
1631 CmdArgs.push_back("-mllvm");
1632 CmdArgs.push_back("-fatal-assembler-warnings");
1633 } else if (Value == "--noexecstack") {
1634 CmdArgs.push_back("-mnoexecstack");
1635 } else {
1636 D.Diag(diag::err_drv_unsupported_option_argument)
1637 << A->getOption().getName() << Value;
1638 }
1639 }
1640 }
1641}
1642
Chandler Carruth9db37cd2013-06-23 11:28:48 +00001643static void addProfileRTLinux(
1644 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1645 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1646 Args.hasArg(options::OPT_fprofile_generate) ||
1647 Args.hasArg(options::OPT_fcreate_profile) ||
1648 Args.hasArg(options::OPT_coverage)))
1649 return;
1650
1651 // The profile runtime is located in the Linux library directory and has name
1652 // "libclang_rt.profile-<ArchName>.a".
1653 SmallString<128> LibProfile(TC.getDriver().ResourceDir);
1654 llvm::sys::path::append(
1655 LibProfile, "lib", "linux",
1656 Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
1657
1658 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1659}
1660
Alexey Samsonov86143042013-02-27 11:14:55 +00001661static void addSanitizerRTLinkFlagsLinux(
1662 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
Richard Smith76e6e132013-03-23 00:30:08 +00001663 const StringRef Sanitizer, bool BeforeLibStdCXX,
1664 bool ExportSymbols = true) {
Alexey Samsonov86143042013-02-27 11:14:55 +00001665 // Sanitizer runtime is located in the Linux library directory and
1666 // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1667 SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1668 llvm::sys::path::append(
1669 LibSanitizer, "lib", "linux",
1670 (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
Richard Smith61a574f2013-03-20 23:49:07 +00001671
Alexey Samsonov86143042013-02-27 11:14:55 +00001672 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1673 // etc.) so that the linker picks custom versions of the global 'operator
1674 // new' and 'operator delete' symbols. We take the extreme (but simple)
1675 // strategy of inserting it at the front of the link command. It also
1676 // needs to be forced to end up in the executable, so wrap it in
1677 // whole-archive.
Richard Smith61a574f2013-03-20 23:49:07 +00001678 SmallVector<const char *, 3> LibSanitizerArgs;
1679 LibSanitizerArgs.push_back("-whole-archive");
1680 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1681 LibSanitizerArgs.push_back("-no-whole-archive");
1682
1683 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1684 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1685
Alexey Samsonov86143042013-02-27 11:14:55 +00001686 CmdArgs.push_back("-lpthread");
Evgeniy Stepanov3a8aff92013-05-24 14:28:03 +00001687 CmdArgs.push_back("-lrt");
Alexey Samsonov86143042013-02-27 11:14:55 +00001688 CmdArgs.push_back("-ldl");
Richard Smith76e6e132013-03-23 00:30:08 +00001689
1690 // If possible, use a dynamic symbols file to export the symbols from the
1691 // runtime library. If we can't do so, use -export-dynamic instead to export
1692 // all symbols from the binary.
1693 if (ExportSymbols) {
1694 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1695 CmdArgs.push_back(
1696 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1697 else
1698 CmdArgs.push_back("-export-dynamic");
1699 }
Alexey Samsonov86143042013-02-27 11:14:55 +00001700}
1701
Kostya Serebryanydff466c2011-11-30 01:39:16 +00001702/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1703/// This needs to be called before we add the C run-time (malloc, etc).
1704static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
Kostya Serebryany7b5f1012011-12-06 19:18:44 +00001705 ArgStringList &CmdArgs) {
Logan Chien94a71422012-09-02 09:30:11 +00001706 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov8ba75412012-09-12 09:09:08 +00001707 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1708 llvm::sys::path::append(LibAsan, "lib", "linux",
1709 (Twine("libclang_rt.asan-") +
1710 TC.getArchName() + "-android.so"));
Matt Beaumont-Gay45b27382012-12-04 21:18:26 +00001711 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00001712 } else {
Sergey Matveev050309f2013-05-27 11:17:01 +00001713 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonov86143042013-02-27 11:14:55 +00001714 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00001715 }
Kostya Serebryanydff466c2011-11-30 01:39:16 +00001716}
1717
Kostya Serebryanyf7efb0e2012-05-16 06:36:00 +00001718/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1719/// This needs to be called before we add the C run-time (malloc, etc).
1720static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1721 ArgStringList &CmdArgs) {
Sergey Matveev050309f2013-05-27 11:17:01 +00001722 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonov86143042013-02-27 11:14:55 +00001723 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryanyf7efb0e2012-05-16 06:36:00 +00001724}
1725
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +00001726/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1727/// This needs to be called before we add the C run-time (malloc, etc).
1728static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1729 ArgStringList &CmdArgs) {
Sergey Matveev050309f2013-05-27 11:17:01 +00001730 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonov86143042013-02-27 11:14:55 +00001731 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
Sergey Matveev050309f2013-05-27 11:17:01 +00001732}
1733
1734/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1735/// This needs to be called before we add the C run-time (malloc, etc).
1736static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args,
1737 ArgStringList &CmdArgs) {
1738 if (!Args.hasArg(options::OPT_shared))
1739 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +00001740}
1741
Richard Smith4def70d2012-10-09 19:52:38 +00001742/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1743/// (Linux).
1744static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
Richard Smith61a574f2013-03-20 23:49:07 +00001745 ArgStringList &CmdArgs, bool IsCXX,
1746 bool HasOtherSanitizerRt) {
Richard Smith61a574f2013-03-20 23:49:07 +00001747 // Need a copy of sanitizer_common. This could come from another sanitizer
1748 // runtime; if we're not including one, include our own copy.
1749 if (!HasOtherSanitizerRt)
Richard Smith76e6e132013-03-23 00:30:08 +00001750 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false);
Richard Smith61a574f2013-03-20 23:49:07 +00001751
Alexey Samsonov86143042013-02-27 11:14:55 +00001752 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
Richard Smith61a574f2013-03-20 23:49:07 +00001753
1754 // Only include the bits of the runtime which need a C++ ABI library if
1755 // we're linking in C++ mode.
1756 if (IsCXX)
1757 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false);
Richard Smith4def70d2012-10-09 19:52:38 +00001758}
1759
Peter Collingbourne2eeed712013-08-07 22:47:34 +00001760static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
1761 ArgStringList &CmdArgs) {
1762 if (!Args.hasArg(options::OPT_shared))
1763 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
1764}
1765
Rafael Espindola6af27ec2011-12-14 21:02:23 +00001766static bool shouldUseFramePointer(const ArgList &Args,
1767 const llvm::Triple &Triple) {
1768 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1769 options::OPT_fomit_frame_pointer))
1770 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1771
Richard Sandiford0e373ec2013-07-19 14:06:49 +00001772 // Don't use a frame pointer on linux x86, x86_64 and z if optimizing.
Rafael Espindola6af27ec2011-12-14 21:02:23 +00001773 if ((Triple.getArch() == llvm::Triple::x86_64 ||
Richard Sandiford0e373ec2013-07-19 14:06:49 +00001774 Triple.getArch() == llvm::Triple::x86 ||
1775 Triple.getArch() == llvm::Triple::systemz) &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00001776 Triple.isOSLinux()) {
Rafael Espindola6af27ec2011-12-14 21:02:23 +00001777 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1778 if (!A->getOption().matches(options::OPT_O0))
1779 return false;
1780 }
1781
Robert Lytton5f15f4d2013-08-13 09:43:10 +00001782 if (Triple.getArch() == llvm::Triple::xcore)
1783 return false;
1784
Rafael Espindola6af27ec2011-12-14 21:02:23 +00001785 return true;
1786}
1787
Eric Christopherd3e22df2013-04-03 01:58:53 +00001788static bool shouldUseLeafFramePointer(const ArgList &Args,
1789 const llvm::Triple &Triple) {
1790 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1791 options::OPT_momit_leaf_frame_pointer))
1792 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1793
Richard Sandiford0e373ec2013-07-19 14:06:49 +00001794 // Don't use a leaf frame pointer on linux x86, x86_64 and z if optimizing.
Eric Christopherd3e22df2013-04-03 01:58:53 +00001795 if ((Triple.getArch() == llvm::Triple::x86_64 ||
Richard Sandiford0e373ec2013-07-19 14:06:49 +00001796 Triple.getArch() == llvm::Triple::x86 ||
1797 Triple.getArch() == llvm::Triple::systemz) &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00001798 Triple.isOSLinux()) {
Eric Christopherd3e22df2013-04-03 01:58:53 +00001799 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1800 if (!A->getOption().matches(options::OPT_O0))
1801 return false;
1802 }
1803
Robert Lytton5f15f4d2013-08-13 09:43:10 +00001804 if (Triple.getArch() == llvm::Triple::xcore)
1805 return false;
1806
Eric Christopherd3e22df2013-04-03 01:58:53 +00001807 return true;
1808}
1809
Rafael Espindolaa2148242013-08-10 01:40:10 +00001810/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruthd566df62012-12-17 21:40:04 +00001811static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer6089adc2013-04-27 08:12:29 +00001812 SmallString<128> cwd;
1813 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosierb1c81222013-04-26 20:49:50 +00001814 CmdArgs.push_back("-fdebug-compilation-dir");
1815 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruthd566df62012-12-17 21:40:04 +00001816 }
1817}
1818
Eric Christopher80190392013-02-22 20:12:52 +00001819static const char *SplitDebugName(const ArgList &Args,
1820 const InputInfoList &Inputs) {
1821 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1822 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1823 SmallString<128> T(FinalOutput->getValue());
1824 llvm::sys::path::replace_extension(T, "dwo");
1825 return Args.MakeArgString(T);
1826 } else {
1827 // Use the compilation dir.
1828 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1829 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1830 llvm::sys::path::replace_extension(F, "dwo");
1831 T += F;
1832 return Args.MakeArgString(F);
1833 }
1834}
1835
1836static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1837 const Tool &T, const JobAction &JA,
1838 const ArgList &Args, const InputInfo &Output,
1839 const char *OutFile) {
Eric Christopher59320e72013-02-21 22:35:01 +00001840 ArgStringList ExtractArgs;
1841 ExtractArgs.push_back("--extract-dwo");
1842
1843 ArgStringList StripArgs;
1844 StripArgs.push_back("--strip-dwo");
1845
1846 // Grabbing the output of the earlier compile step.
1847 StripArgs.push_back(Output.getFilename());
1848 ExtractArgs.push_back(Output.getFilename());
Eric Christopher59320e72013-02-21 22:35:01 +00001849 ExtractArgs.push_back(OutFile);
1850
1851 const char *Exec =
Eric Christopher80190392013-02-22 20:12:52 +00001852 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher59320e72013-02-21 22:35:01 +00001853
1854 // First extract the dwo sections.
Eric Christopher80190392013-02-22 20:12:52 +00001855 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher59320e72013-02-21 22:35:01 +00001856
1857 // Then remove them from the original .o file.
Eric Christopher80190392013-02-22 20:12:52 +00001858 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher59320e72013-02-21 22:35:01 +00001859}
1860
Chad Rosierb82e1172013-04-24 18:09:54 +00001861static bool isOptimizationLevelFast(const ArgList &Args) {
1862 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1863 if (A->getOption().matches(options::OPT_Ofast))
1864 return true;
1865 return false;
1866}
1867
Arnold Schwaighofer99662a12013-08-13 15:46:23 +00001868/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
1869static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
1870 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindola55ee1eb2013-08-27 16:58:15 +00001871 if (A->getOption().matches(options::OPT_O4) ||
1872 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer99662a12013-08-13 15:46:23 +00001873 return true;
1874
1875 if (A->getOption().matches(options::OPT_O0))
1876 return false;
1877
1878 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
1879
Rafael Espindola168de192013-08-26 14:05:41 +00001880 // Vectorize -Os.
Arnold Schwaighofer99662a12013-08-13 15:46:23 +00001881 StringRef S(A->getValue());
Rafael Espindola168de192013-08-26 14:05:41 +00001882 if (S == "s")
Arnold Schwaighofer99662a12013-08-13 15:46:23 +00001883 return true;
1884
1885 // Don't vectorize -Oz.
1886 if (S == "z")
1887 return false;
1888
1889 unsigned OptLevel = 0;
1890 if (S.getAsInteger(10, OptLevel))
1891 return false;
1892
1893 return OptLevel > 1;
1894 }
1895
1896 return false;
1897}
1898
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00001899void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar871adcf2009-03-18 07:06:02 +00001900 const InputInfo &Output,
Daniel Dunbar62cf6012009-03-18 06:07:59 +00001901 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +00001902 const ArgList &Args,
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00001903 const char *LinkingOutput) const {
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00001904 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1905 options::OPT_fapple_kext);
Daniel Dunbaree788e72009-12-21 18:54:17 +00001906 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001907 ArgStringList CmdArgs;
1908
Daniel Dunbar077ba6a2009-03-31 20:53:55 +00001909 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1910
Daniel Dunbar8ff5b282009-12-11 23:00:49 +00001911 // Invoke ourselves in -cc1 mode.
1912 //
1913 // FIXME: Implement custom jobs for internal actions.
1914 CmdArgs.push_back("-cc1");
1915
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001916 // Add the "effective" target triple.
Daniel Dunbaraf07f932009-03-31 17:35:15 +00001917 CmdArgs.push_back("-triple");
Daniel Dunbar00577ad2010-08-23 22:35:37 +00001918 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001919 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbar728a5122009-09-10 06:49:20 +00001920
Daniel Dunbardd4fe002009-10-30 18:12:20 +00001921 // Select the appropriate action.
John McCall260611a2012-06-20 06:18:46 +00001922 RewriteKind rewriteKind = RK_None;
Fariborz Jahaniane982cc02012-04-04 18:50:28 +00001923
Daniel Dunbar1d460332009-03-18 10:01:51 +00001924 if (isa<AnalyzeJobAction>(JA)) {
1925 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1926 CmdArgs.push_back("-analyze");
Ted Kremenek30660a82012-03-06 20:06:33 +00001927 } else if (isa<MigrateJobAction>(JA)) {
1928 CmdArgs.push_back("-migrate");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001929 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00001930 if (Output.getType() == types::TY_Dependencies)
1931 CmdArgs.push_back("-Eonly");
Fariborz Jahanian51be73d2013-03-18 19:41:18 +00001932 else {
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00001933 CmdArgs.push_back("-E");
Fariborz Jahanian51be73d2013-03-18 19:41:18 +00001934 if (Args.hasArg(options::OPT_rewrite_objc) &&
1935 !Args.hasArg(options::OPT_g_Group))
1936 CmdArgs.push_back("-P");
1937 }
Daniel Dunbar8767cbc2010-02-03 03:07:56 +00001938 } else if (isa<AssembleJobAction>(JA)) {
1939 CmdArgs.push_back("-emit-obj");
Daniel Dunbar99298002010-05-27 06:18:05 +00001940
David Blaikie73168db2013-07-25 21:19:01 +00001941 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbard02bba82010-11-19 16:23:35 +00001942
1943 // Also ignore explicit -force_cpusubtype_ALL option.
1944 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar1d460332009-03-18 10:01:51 +00001945 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidise5c35372010-08-11 23:27:58 +00001946 // Use PCH if the user requested it.
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001947 bool UsePCH = D.CCCUsePCH;
Daniel Dunbar0ebd9322009-10-15 20:02:44 +00001948
Aaron Ballman761322b2012-07-31 01:21:00 +00001949 if (JA.getType() == types::TY_Nothing)
1950 CmdArgs.push_back("-fsyntax-only");
1951 else if (UsePCH)
Douglas Gregordf91ef32009-04-18 00:34:01 +00001952 CmdArgs.push_back("-emit-pch");
1953 else
1954 CmdArgs.push_back("-emit-pth");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001955 } else {
1956 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00001957
Daniel Dunbar1d460332009-03-18 10:01:51 +00001958 if (JA.getType() == types::TY_Nothing) {
1959 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001960 } else if (JA.getType() == types::TY_LLVM_IR ||
1961 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001962 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00001963 } else if (JA.getType() == types::TY_LLVM_BC ||
1964 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00001965 CmdArgs.push_back("-emit-llvm-bc");
1966 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbare3b8d072009-09-17 00:47:53 +00001967 CmdArgs.push_back("-S");
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00001968 } else if (JA.getType() == types::TY_AST) {
1969 CmdArgs.push_back("-emit-pch");
Douglas Gregorc544ba02013-03-27 16:47:18 +00001970 } else if (JA.getType() == types::TY_ModuleFile) {
1971 CmdArgs.push_back("-module-file-info");
Daniel Dunbar64952502010-02-11 03:16:21 +00001972 } else if (JA.getType() == types::TY_RewrittenObjC) {
1973 CmdArgs.push_back("-rewrite-objc");
John McCall260611a2012-06-20 06:18:46 +00001974 rewriteKind = RK_NonFragile;
Fariborz Jahanian582b3952012-04-02 15:59:19 +00001975 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1976 CmdArgs.push_back("-rewrite-objc");
John McCall260611a2012-06-20 06:18:46 +00001977 rewriteKind = RK_Fragile;
Daniel Dunbar64952502010-02-11 03:16:21 +00001978 } else {
1979 assert(JA.getType() == types::TY_PP_Asm &&
1980 "Unexpected output type!");
Daniel Dunbar1d460332009-03-18 10:01:51 +00001981 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00001982 }
1983
Daniel Dunbar1d460332009-03-18 10:01:51 +00001984 // The make clang go fast button.
1985 CmdArgs.push_back("-disable-free");
1986
John McCallb689afb2010-02-13 03:50:24 +00001987 // Disable the verification pass in -asserts builds.
1988#ifdef NDEBUG
1989 CmdArgs.push_back("-disable-llvm-verifier");
1990#endif
1991
Daniel Dunbarc9abc042009-04-08 05:11:16 +00001992 // Set the main file name, so that debug info works even with
1993 // -save-temps.
1994 CmdArgs.push_back("-main-file-name");
Bob Wilson66b8a662012-11-23 06:14:39 +00001995 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbarc9abc042009-04-08 05:11:16 +00001996
Daniel Dunbar3bbc7532009-04-08 18:03:55 +00001997 // Some flags which affect the language (via preprocessor
Bob Wilson66b8a662012-11-23 06:14:39 +00001998 // defines).
Daniel Dunbar3bbc7532009-04-08 18:03:55 +00001999 if (Args.hasArg(options::OPT_static))
2000 CmdArgs.push_back("-static-define");
2001
Daniel Dunbar1d460332009-03-18 10:01:51 +00002002 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenekb8bb3e72009-09-25 05:55:59 +00002003 // Enable region store model by default.
2004 CmdArgs.push_back("-analyzer-store=region");
2005
Ted Kremenekb40d06d2009-12-07 22:26:14 +00002006 // Treat blocks as analysis entry points.
2007 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2008
Ted Kremenek51885072011-03-24 00:28:47 +00002009 CmdArgs.push_back("-analyzer-eagerly-assume");
2010
Daniel Dunbar1d460332009-03-18 10:01:51 +00002011 // Add default argument set.
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00002012 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00002013 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek51885072011-03-24 00:28:47 +00002014
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00002015 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2016 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek51885072011-03-24 00:28:47 +00002017
Argyrios Kyrtzidis027a6ab2011-02-15 07:42:33 +00002018 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek51885072011-03-24 00:28:47 +00002019 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremeneka8180e52012-01-20 06:00:17 +00002020
2021 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek8dc05062012-01-26 02:27:38 +00002022
Jordan Rosee449edc2013-04-05 17:55:07 +00002023 if (types::isCXX(Inputs[0].getType()))
2024 CmdArgs.push_back("-analyzer-checker=cplusplus");
2025
Ted Kremenek8dc05062012-01-26 02:27:38 +00002026 // Enable the following experimental checkers for testing.
Ted Kremenek8dc05062012-01-26 02:27:38 +00002027 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2028 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2029 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2030 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2031 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2032 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00002033 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002034
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00002035 // Set the output format. The default is plist, for (lame) historical
2036 // reasons.
2037 CmdArgs.push_back("-analyzer-output");
2038 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smith1d489cf2012-11-01 04:30:05 +00002039 CmdArgs.push_back(A->getValue());
Daniel Dunbard8fc0f22009-05-22 00:38:15 +00002040 else
2041 CmdArgs.push_back("plist");
Daniel Dunbar1d460332009-03-18 10:01:51 +00002042
Ted Kremenek0647a7b2010-03-22 22:32:05 +00002043 // Disable the presentation of standard compiler warnings when
2044 // using --analyze. We only want to show static analyzer diagnostics
2045 // or frontend errors.
2046 CmdArgs.push_back("-w");
2047
Daniel Dunbar1d460332009-03-18 10:01:51 +00002048 // Add -Xanalyzer arguments when running as analyzer.
2049 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump1eb44332009-09-09 15:08:12 +00002050 }
2051
Daniel Dunbare2fd6642009-09-10 01:21:12 +00002052 CheckCodeGenerationOptions(D, Args);
2053
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002054 bool PIE = getToolChain().isPIEDefault();
2055 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002056 bool IsPICLevelTwo = PIC;
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002057
Alexey Samsonovdb68e5a2013-04-09 12:28:19 +00002058 // For the PIC and PIE flag options, this logic is different from the
2059 // legacy logic in very old versions of GCC, as that logic was just
2060 // a bug no one had ever fixed. This logic is both more rational and
2061 // consistent with GCC's new logic now that the bugs are fixed. The last
2062 // argument relating to either PIC or PIE wins, and no other argument is
2063 // used. If the last argument is any flavor of the '-fno-...' arguments,
2064 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2065 // at the same level.
2066 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2067 options::OPT_fpic, options::OPT_fno_pic,
2068 options::OPT_fPIE, options::OPT_fno_PIE,
2069 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002070 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2071 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002072 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonovdb68e5a2013-04-09 12:28:19 +00002073 if (LastPICArg) {
2074 Option O = LastPICArg->getOption();
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00002075 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2076 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2077 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2078 PIC = PIE || O.matches(options::OPT_fPIC) ||
2079 O.matches(options::OPT_fpic);
2080 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2081 O.matches(options::OPT_fPIC);
2082 } else {
2083 PIE = PIC = false;
2084 }
2085 }
Chandler Carruth5e219cf2012-04-08 16:40:35 +00002086 }
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002087
2088 // Inroduce a Darwin-specific hack. If the default is PIC but the flags
2089 // specified while enabling PIC enabled level 1 PIC, just force it back to
2090 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2091 // informal testing).
2092 if (PIC && getToolChain().getTriple().isOSDarwin())
2093 IsPICLevelTwo |= getToolChain().isPICDefault();
2094
Chandler Carruth5e219cf2012-04-08 16:40:35 +00002095 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2096 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbar7a0c0642012-10-15 22:23:53 +00002097 llvm::Triple Triple(TripleStr);
Eric Christopher6c7db892013-02-18 01:16:37 +00002098 if (KernelOrKext &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00002099 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002100 PIC = PIE = false;
Chandler Carruth5e219cf2012-04-08 16:40:35 +00002101 if (Args.hasArg(options::OPT_static))
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002102 PIC = PIE = false;
Chandler Carruth5e219cf2012-04-08 16:40:35 +00002103
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002104 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2105 // This is a very special mode. It trumps the other modes, almost no one
2106 // uses it, and it isn't even valid on any OS but Darwin.
2107 if (!getToolChain().getTriple().isOSDarwin())
2108 D.Diag(diag::err_drv_unsupported_opt_for_target)
2109 << A->getSpelling() << getToolChain().getTriple().str();
2110
2111 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2112
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002113 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002114 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbarbc85be82009-04-29 18:32:25 +00002115
Chandler Carruth7ce816a2012-11-19 03:52:03 +00002116 // Only a forced PIC mode can cause the actual compile to have PIC defines
2117 // etc., no flags are sufficient. This behavior was selected to closely
2118 // match that of llvm-gcc and Apple GCC before that.
2119 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2120 CmdArgs.push_back("-pic-level");
2121 CmdArgs.push_back("2");
2122 }
2123 } else {
2124 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2125 // handled in Clang's IRGen by the -pie-level flag.
2126 CmdArgs.push_back("-mrelocation-model");
2127 CmdArgs.push_back(PIC ? "pic" : "static");
2128
2129 if (PIC) {
2130 CmdArgs.push_back("-pic-level");
2131 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2132 if (PIE) {
2133 CmdArgs.push_back("-pie-level");
2134 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2135 }
2136 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00002137 }
Chandler Carruth5e219cf2012-04-08 16:40:35 +00002138
Tanya Lattner59876c22009-11-04 01:18:09 +00002139 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2140 options::OPT_fno_merge_all_constants))
Chris Lattnerf44a1a02011-04-08 18:06:54 +00002141 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00002142
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002143 // LLVM Code Generator Options.
2144
Daniel Dunbar17d3fea2011-02-09 17:54:19 +00002145 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2146 CmdArgs.push_back("-mregparm");
Richard Smith1d489cf2012-11-01 04:30:05 +00002147 CmdArgs.push_back(A->getValue());
Daniel Dunbar17d3fea2011-02-09 17:54:19 +00002148 }
2149
Nick Lewyckyfdf137b2013-06-25 01:49:44 +00002150 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2151 options::OPT_freg_struct_return)) {
Eli Bendersky8f4269a2013-07-24 22:20:49 +00002152 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCallb8b52972013-06-18 02:46:29 +00002153 D.Diag(diag::err_drv_unsupported_opt_for_target)
2154 << A->getSpelling() << getToolChain().getTriple().str();
2155 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2156 CmdArgs.push_back("-fpcc-struct-return");
2157 } else {
2158 assert(A->getOption().matches(options::OPT_freg_struct_return));
2159 CmdArgs.push_back("-freg-struct-return");
2160 }
2161 }
2162
Roman Divackycfe9af22011-03-01 17:40:53 +00002163 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2164 CmdArgs.push_back("-mrtd");
2165
Rafael Espindola6af27ec2011-12-14 21:02:23 +00002166 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002167 CmdArgs.push_back("-mdisable-fp-elim");
2168 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2169 options::OPT_fno_zero_initialized_in_bss))
2170 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb82e1172013-04-24 18:09:54 +00002171
2172 bool OFastEnabled = isOptimizationLevelFast(Args);
2173 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2174 // enabled. This alias option is being used to simplify the hasFlag logic.
2175 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2176 options::OPT_fstrict_aliasing;
2177 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Daniel Dunbar398c6102011-02-04 02:20:39 +00002178 options::OPT_fno_strict_aliasing,
2179 getToolChain().IsStrictAliasingDefault()))
Dan Gohman4d5625e2010-10-14 22:36:56 +00002180 CmdArgs.push_back("-relaxed-aliasing");
Manman Renb37a73d2013-04-04 21:53:22 +00002181 if (Args.hasArg(options::OPT_fstruct_path_tbaa))
2182 CmdArgs.push_back("-struct-path-tbaa");
Chandler Carruth82fe6ae2012-03-27 23:58:37 +00002183 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2184 false))
2185 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1db772b2012-01-23 08:29:12 +00002186 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2187 options::OPT_fno_optimize_sibling_calls))
2188 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar1b718482010-05-14 22:00:22 +00002189
Eric Christopher31056272013-04-04 06:29:47 +00002190 // Handle segmented stacks.
2191 if (Args.hasArg(options::OPT_fsplit_stack))
2192 CmdArgs.push_back("-split-stacks");
Chad Rosierb82e1172013-04-24 18:09:54 +00002193
2194 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2195 // This alias option is being used to simplify the getLastArg logic.
2196 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2197 options::OPT_ffast_math;
Eric Christopher31056272013-04-04 06:29:47 +00002198
Chandler Carruthabf07a72012-01-02 14:19:45 +00002199 // Handle various floating point optimization flags, mapping them to the
2200 // appropriate LLVM code generation flags. The pattern for all of these is to
2201 // default off the codegen optimizations, and if any flag enables them and no
2202 // flag disables them after the flag enabling them, enable the codegen
2203 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb82e1172013-04-24 18:09:54 +00002204 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002205 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002206 options::OPT_ffinite_math_only,
2207 options::OPT_fno_finite_math_only,
2208 options::OPT_fhonor_infinities,
2209 options::OPT_fno_honor_infinities))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002210 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2211 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002212 A->getOption().getID() != options::OPT_fhonor_infinities)
2213 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb82e1172013-04-24 18:09:54 +00002214 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002215 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002216 options::OPT_ffinite_math_only,
2217 options::OPT_fno_finite_math_only,
2218 options::OPT_fhonor_nans,
2219 options::OPT_fno_honor_nans))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002220 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2221 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002222 A->getOption().getID() != options::OPT_fhonor_nans)
2223 CmdArgs.push_back("-menable-no-nans");
2224
Benjamin Kramer769aa2d2012-05-02 14:55:48 +00002225 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2226 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb82e1172013-04-24 18:09:54 +00002227 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002228 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002229 options::OPT_fmath_errno,
Chandler Carruthb69557e2013-05-18 20:47:36 +00002230 options::OPT_fno_math_errno)) {
2231 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2232 // However, turning *off* -ffast_math merely restores the toolchain default
2233 // (which may be false).
2234 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2235 A->getOption().getID() == options::OPT_ffast_math ||
2236 A->getOption().getID() == options::OPT_Ofast)
2237 MathErrno = false;
2238 else if (A->getOption().getID() == options::OPT_fmath_errno)
2239 MathErrno = true;
2240 }
Chandler Carruth4f50c502012-04-26 02:10:51 +00002241 if (MathErrno)
2242 CmdArgs.push_back("-fmath-errno");
Chandler Carruthabf07a72012-01-02 14:19:45 +00002243
2244 // There are several flags which require disabling very specific
2245 // optimizations. Any of these being disabled forces us to turn off the
2246 // entire set of LLVM optimizations, so collect them through all the flag
2247 // madness.
2248 bool AssociativeMath = false;
Chad Rosierb82e1172013-04-24 18:09:54 +00002249 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002250 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002251 options::OPT_funsafe_math_optimizations,
2252 options::OPT_fno_unsafe_math_optimizations,
2253 options::OPT_fassociative_math,
2254 options::OPT_fno_associative_math))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002255 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2256 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002257 A->getOption().getID() != options::OPT_fno_associative_math)
2258 AssociativeMath = true;
2259 bool ReciprocalMath = false;
Chad Rosierb82e1172013-04-24 18:09:54 +00002260 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002261 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002262 options::OPT_funsafe_math_optimizations,
2263 options::OPT_fno_unsafe_math_optimizations,
2264 options::OPT_freciprocal_math,
2265 options::OPT_fno_reciprocal_math))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002266 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2267 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002268 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2269 ReciprocalMath = true;
2270 bool SignedZeros = true;
Chad Rosierb82e1172013-04-24 18:09:54 +00002271 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002272 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002273 options::OPT_funsafe_math_optimizations,
2274 options::OPT_fno_unsafe_math_optimizations,
2275 options::OPT_fsigned_zeros,
2276 options::OPT_fno_signed_zeros))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002277 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2278 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002279 A->getOption().getID() != options::OPT_fsigned_zeros)
2280 SignedZeros = false;
2281 bool TrappingMath = true;
Chad Rosierb82e1172013-04-24 18:09:54 +00002282 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002283 options::OPT_fno_fast_math,
Chandler Carruthabf07a72012-01-02 14:19:45 +00002284 options::OPT_funsafe_math_optimizations,
2285 options::OPT_fno_unsafe_math_optimizations,
2286 options::OPT_ftrapping_math,
2287 options::OPT_fno_trapping_math))
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002288 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2289 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruthabf07a72012-01-02 14:19:45 +00002290 A->getOption().getID() != options::OPT_ftrapping_math)
2291 TrappingMath = false;
2292 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2293 !TrappingMath)
2294 CmdArgs.push_back("-menable-unsafe-fp-math");
2295
Lang Hamesc9686712012-07-06 00:59:19 +00002296
2297 // Validate and pass through -fp-contract option.
Chad Rosierb82e1172013-04-24 18:09:54 +00002298 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002299 options::OPT_fno_fast_math,
Lang Hamesc9686712012-07-06 00:59:19 +00002300 options::OPT_ffp_contract)) {
2301 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smith1d489cf2012-11-01 04:30:05 +00002302 StringRef Val = A->getValue();
Lang Hamesc9686712012-07-06 00:59:19 +00002303 if (Val == "fast" || Val == "on" || Val == "off") {
2304 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2305 } else {
2306 D.Diag(diag::err_drv_unsupported_option_argument)
2307 << A->getOption().getName() << Val;
2308 }
Chad Rosierb82e1172013-04-24 18:09:54 +00002309 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2310 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesc9686712012-07-06 00:59:19 +00002311 // If fast-math is set then set the fp-contract mode to fast.
2312 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2313 }
2314 }
2315
Bob Wilson455e72e2012-07-19 03:52:53 +00002316 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2317 // and if we find them, tell the frontend to provide the appropriate
2318 // preprocessor macros. This is distinct from enabling any optimizations as
2319 // these options induce language changes which must survive serialization
2320 // and deserialization, etc.
Chad Rosierb82e1172013-04-24 18:09:54 +00002321 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2322 options::OPT_fno_fast_math))
2323 if (!A->getOption().matches(options::OPT_fno_fast_math))
2324 CmdArgs.push_back("-ffast-math");
Chad Rosier80ecf5e2012-09-25 22:03:25 +00002325 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2326 if (A->getOption().matches(options::OPT_ffinite_math_only))
2327 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruthabf07a72012-01-02 14:19:45 +00002328
Daniel Dunbar1b718482010-05-14 22:00:22 +00002329 // Decide whether to use verbose asm. Verbose assembly is the default on
2330 // toolchains which have the integrated assembler on by default.
2331 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2332 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Michael J. Spencer20249a12010-10-21 03:16:25 +00002333 IsVerboseAsmDefault) ||
Daniel Dunbar1b718482010-05-14 22:00:22 +00002334 Args.hasArg(options::OPT_dA))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002335 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar1b718482010-05-14 22:00:22 +00002336
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002337 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2338 CmdArgs.push_back("-mdebug-pass");
2339 CmdArgs.push_back("Structure");
2340 }
2341 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2342 CmdArgs.push_back("-mdebug-pass");
2343 CmdArgs.push_back("Arguments");
2344 }
2345
John McCalld0c2ec42010-02-19 02:45:38 +00002346 // Enable -mconstructor-aliases except on darwin, where we have to
2347 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson905c45f2011-10-14 05:03:44 +00002348 if (!getToolChain().getTriple().isOSDarwin())
John McCalld0c2ec42010-02-19 02:45:38 +00002349 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00002350
John McCall32096692011-03-18 02:56:14 +00002351 // Darwin's kernel doesn't support guard variables; just die if we
2352 // try to use them.
Bob Wilson905c45f2011-10-14 05:03:44 +00002353 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall32096692011-03-18 02:56:14 +00002354 CmdArgs.push_back("-fforbid-guard-variables");
2355
Douglas Gregor6f755502011-02-01 15:15:22 +00002356 if (Args.hasArg(options::OPT_mms_bitfields)) {
2357 CmdArgs.push_back("-mms-bitfields");
2358 }
John McCalld0c2ec42010-02-19 02:45:38 +00002359
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00002360 // This is a coarse approximation of what llvm-gcc actually does, both
2361 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2362 // complicated ways.
2363 bool AsynchronousUnwindTables =
2364 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2365 options::OPT_fno_asynchronous_unwind_tables,
2366 getToolChain().IsUnwindTablesDefault() &&
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00002367 !KernelOrKext);
Daniel Dunbar6bea73b2009-09-16 06:17:29 +00002368 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2369 AsynchronousUnwindTables))
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002370 CmdArgs.push_back("-munwind-tables");
2371
Chandler Carrutha6b25812012-11-21 23:40:23 +00002372 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola8af669f2012-06-19 01:26:10 +00002373
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002374 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2375 CmdArgs.push_back("-mlimit-float-precision");
Richard Smith1d489cf2012-11-01 04:30:05 +00002376 CmdArgs.push_back(A->getValue());
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002377 }
Daniel Dunbarbc85be82009-04-29 18:32:25 +00002378
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002379 // FIXME: Handle -mtune=.
2380 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbarbc85be82009-04-29 18:32:25 +00002381
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00002382 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbarf219e7c2009-11-29 07:18:39 +00002383 CmdArgs.push_back("-mcode-model");
Richard Smith1d489cf2012-11-01 04:30:05 +00002384 CmdArgs.push_back(A->getValue());
Benjamin Kramer8e9ef0d2009-08-05 14:30:52 +00002385 }
2386
Rafael Espindolab330e402013-08-20 22:12:08 +00002387 // Add the target cpu
2388 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2389 llvm::Triple ETriple(ETripleStr);
2390 std::string CPU = getCPUName(Args, ETriple);
2391 if (!CPU.empty()) {
2392 CmdArgs.push_back("-target-cpu");
2393 CmdArgs.push_back(Args.MakeArgString(CPU));
2394 }
2395
Rafael Espindola5389b842013-08-21 21:59:03 +00002396 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2397 CmdArgs.push_back("-mfpmath");
2398 CmdArgs.push_back(A->getValue());
2399 }
2400
Rafael Espindola146dbbf2013-08-21 16:39:20 +00002401 // Add the target features
2402 getTargetFeatures(D, ETriple, Args, CmdArgs);
2403
Rafael Espindolab330e402013-08-20 22:12:08 +00002404 // Add target specific flags.
Eli Bendersky8f4269a2013-07-24 22:20:49 +00002405 switch(getToolChain().getArch()) {
Daniel Dunbar6acda162009-09-09 22:33:08 +00002406 default:
2407 break;
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002408
Daniel Dunbarb163ef72009-09-10 04:57:17 +00002409 case llvm::Triple::arm:
2410 case llvm::Triple::thumb:
Daniel Dunbarfa41d692011-03-17 17:10:06 +00002411 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbarb163ef72009-09-10 04:57:17 +00002412 break;
2413
Eric Christophered734732010-03-02 02:41:08 +00002414 case llvm::Triple::mips:
2415 case llvm::Triple::mipsel:
Akira Hatanaka7ec02582011-09-21 02:13:07 +00002416 case llvm::Triple::mips64:
2417 case llvm::Triple::mips64el:
Eric Christophered734732010-03-02 02:41:08 +00002418 AddMIPSTargetArgs(Args, CmdArgs);
2419 break;
2420
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002421 case llvm::Triple::sparc:
2422 AddSparcTargetArgs(Args, CmdArgs);
2423 break;
2424
Daniel Dunbar6acda162009-09-09 22:33:08 +00002425 case llvm::Triple::x86:
2426 case llvm::Triple::x86_64:
2427 AddX86TargetArgs(Args, CmdArgs);
2428 break;
Tony Linthicum96319392011-12-12 21:14:55 +00002429
2430 case llvm::Triple::hexagon:
2431 AddHexagonTargetArgs(Args, CmdArgs);
2432 break;
Daniel Dunbarbc85be82009-04-29 18:32:25 +00002433 }
2434
Hans Wennborgb3574792013-08-08 00:17:41 +00002435 // Add clang-cl arguments.
2436 if (getToolChain().getDriver().IsCLMode())
2437 AddClangCLArgs(Args, CmdArgs);
2438
Daniel Dunbarc176bc62010-08-11 23:07:47 +00002439 // Pass the linker version in use.
2440 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2441 CmdArgs.push_back("-target-linker-version");
Richard Smith1d489cf2012-11-01 04:30:05 +00002442 CmdArgs.push_back(A->getValue());
Daniel Dunbarc176bc62010-08-11 23:07:47 +00002443 }
2444
Eric Christopherd3e22df2013-04-03 01:58:53 +00002445 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbar1ad66482010-07-01 01:31:45 +00002446 CmdArgs.push_back("-momit-leaf-frame-pointer");
2447
Daniel Dunbarb30575c2010-05-12 18:19:58 +00002448 // Explicitly error on some things we know we don't support and can't just
2449 // ignore.
2450 types::ID InputType = Inputs[0].getType();
Daniel Dunbare94db472010-09-24 19:39:37 +00002451 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2452 Arg *Unsupported;
Daniel Dunbare94db472010-09-24 19:39:37 +00002453 if (types::isCXX(InputType) &&
Bob Wilson905c45f2011-10-14 05:03:44 +00002454 getToolChain().getTriple().isOSDarwin() &&
Eli Bendersky8f4269a2013-07-24 22:20:49 +00002455 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilsona544aee2011-08-13 23:48:55 +00002456 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2457 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner5f9e2722011-07-23 10:55:15 +00002458 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbare94db472010-09-24 19:39:37 +00002459 << Unsupported->getOption().getName();
2460 }
Daniel Dunbarb30575c2010-05-12 18:19:58 +00002461 }
2462
Daniel Dunbar1d460332009-03-18 10:01:51 +00002463 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbarf7c16d92010-08-24 22:44:13 +00002464 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosier2b819102011-08-02 17:58:04 +00002465 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbar322c29f2011-02-02 21:11:35 +00002466 CmdArgs.push_back("-header-include-file");
2467 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2468 D.CCPrintHeadersFilename : "-");
2469 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00002470 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump1eb44332009-09-09 15:08:12 +00002471 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002472
Chad Rosier2b819102011-08-02 17:58:04 +00002473 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbarc8a22b02011-04-07 18:01:20 +00002474 CmdArgs.push_back("-diagnostic-log-file");
2475 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2476 D.CCLogDiagnosticsFilename : "-");
2477 }
2478
Eric Christopherc706c8e2013-02-05 07:29:57 +00002479 // Use the last option from "-g" group. "-gline-tables-only"
2480 // is preserved, all other debug options are substituted with "-g".
Rafael Espindola18f36d92010-03-07 04:46:18 +00002481 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonova9cd83b2012-05-29 08:10:34 +00002482 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Eric Christopherc706c8e2013-02-05 07:29:57 +00002483 if (A->getOption().matches(options::OPT_gline_tables_only))
Alexey Samsonova9cd83b2012-05-29 08:10:34 +00002484 CmdArgs.push_back("-gline-tables-only");
Manman Renfc0f91c2013-06-19 01:46:49 +00002485 else if (A->getOption().matches(options::OPT_gdwarf_2))
2486 CmdArgs.push_back("-gdwarf-2");
2487 else if (A->getOption().matches(options::OPT_gdwarf_3))
2488 CmdArgs.push_back("-gdwarf-3");
2489 else if (A->getOption().matches(options::OPT_gdwarf_4))
2490 CmdArgs.push_back("-gdwarf-4");
Eric Christopherc706c8e2013-02-05 07:29:57 +00002491 else if (!A->getOption().matches(options::OPT_g0) &&
Manman Ren8ed38d82013-07-02 23:15:25 +00002492 !A->getOption().matches(options::OPT_ggdb0)) {
2493 // Default is dwarf-2 for darwin.
2494 if (getToolChain().getTriple().isOSDarwin())
2495 CmdArgs.push_back("-gdwarf-2");
2496 else
2497 CmdArgs.push_back("-g");
2498 }
Alexey Samsonova9cd83b2012-05-29 08:10:34 +00002499 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00002500
Alexey Samsonov7f326072012-06-21 08:22:39 +00002501 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2502 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christopherda3301e2012-10-18 21:52:18 +00002503 if (Args.hasArg(options::OPT_gcolumn_info))
2504 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonov7f326072012-06-21 08:22:39 +00002505
Eric Christopher0f43a6d2013-09-13 22:37:55 +00002506 // FIXME: Move backend command line options to the module.
Eric Christopherc706c8e2013-02-05 07:29:57 +00002507 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2508 // splitting and extraction.
Eric Christopherf870e122013-02-21 22:35:05 +00002509 // FIXME: Currently only works on Linux.
Cameron Esfahani57b1da12013-09-14 01:09:11 +00002510 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherf870e122013-02-21 22:35:05 +00002511 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopherc706c8e2013-02-05 07:29:57 +00002512 CmdArgs.push_back("-g");
2513 CmdArgs.push_back("-backend-option");
2514 CmdArgs.push_back("-split-dwarf=Enable");
2515 }
2516
Eric Christopher0f43a6d2013-09-13 22:37:55 +00002517 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2518 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2519 CmdArgs.push_back("-backend-option");
2520 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2521 }
Eric Christopher3e8ac1b2013-06-18 00:03:50 +00002522
2523 Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2524
Rafael Espindola9cf933a2010-05-06 21:06:04 +00002525 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2526 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2527
Chris Lattner7255a2d2010-06-22 00:03:40 +00002528 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2529
Nick Lewyckye8ba8d72011-04-21 23:44:07 +00002530 if (Args.hasArg(options::OPT_ftest_coverage) ||
2531 Args.hasArg(options::OPT_coverage))
2532 CmdArgs.push_back("-femit-coverage-notes");
2533 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2534 Args.hasArg(options::OPT_coverage))
2535 CmdArgs.push_back("-femit-coverage-data");
2536
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002537 if (C.getArgs().hasArg(options::OPT_c) ||
2538 C.getArgs().hasArg(options::OPT_S)) {
2539 if (Output.isFilename()) {
Nick Lewycky3dc05412011-05-05 00:08:20 +00002540 CmdArgs.push_back("-coverage-file");
Eric Christopher025b3d42013-02-22 00:24:40 +00002541 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky0f815f12013-03-07 08:28:53 +00002542 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolaa2148242013-08-10 01:40:10 +00002543 SmallString<128> Pwd;
2544 if (!llvm::sys::fs::current_path(Pwd)) {
2545 llvm::sys::path::append(Pwd, CoverageFilename.str());
2546 CoverageFilename.swap(Pwd);
Nick Lewycky0f815f12013-03-07 08:28:53 +00002547 }
2548 }
Eric Christopher025b3d42013-02-22 00:24:40 +00002549 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002550 }
2551 }
2552
Daniel Dunbara268fc02011-10-11 18:20:10 +00002553 // Pass options for controlling the default header search paths.
2554 if (Args.hasArg(options::OPT_nostdinc)) {
2555 CmdArgs.push_back("-nostdsysteminc");
2556 CmdArgs.push_back("-nobuiltininc");
2557 } else {
Daniel Dunbar92d6d402011-10-11 18:20:16 +00002558 if (Args.hasArg(options::OPT_nostdlibinc))
2559 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbara268fc02011-10-11 18:20:10 +00002560 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2561 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2562 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00002563
Daniel Dunbar5f122322009-12-15 01:02:52 +00002564 // Pass the path to compiler resource files.
Daniel Dunbar5f122322009-12-15 01:02:52 +00002565 CmdArgs.push_back("-resource-dir");
Daniel Dunbar225c4172010-01-20 02:35:16 +00002566 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar2ac9fc22009-04-07 21:42:00 +00002567
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00002568 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2569
Ted Kremenek30660a82012-03-06 20:06:33 +00002570 bool ARCMTEnabled = false;
Argyrios Kyrtzidisdce3ce32013-09-17 19:14:29 +00002571 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00002572 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00002573 options::OPT_ccc_arcmt_modify,
2574 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenek30660a82012-03-06 20:06:33 +00002575 ARCMTEnabled = true;
John McCall8f0e8d22011-06-15 23:25:17 +00002576 switch (A->getOption().getID()) {
2577 default:
2578 llvm_unreachable("missed a case");
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00002579 case options::OPT_ccc_arcmt_check:
John McCall8f0e8d22011-06-15 23:25:17 +00002580 CmdArgs.push_back("-arcmt-check");
2581 break;
Argyrios Kyrtzidis72ac1202011-07-07 04:00:39 +00002582 case options::OPT_ccc_arcmt_modify:
John McCall8f0e8d22011-06-15 23:25:17 +00002583 CmdArgs.push_back("-arcmt-modify");
2584 break;
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00002585 case options::OPT_ccc_arcmt_migrate:
2586 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenek30660a82012-03-06 20:06:33 +00002587 CmdArgs.push_back("-mt-migrate-directory");
Richard Smith1d489cf2012-11-01 04:30:05 +00002588 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidis7ee20492011-07-19 17:20:03 +00002589
2590 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2591 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis69325d52011-07-09 20:00:58 +00002592 break;
John McCall8f0e8d22011-06-15 23:25:17 +00002593 }
2594 }
Argyrios Kyrtzidisf75ece42013-06-24 19:01:18 +00002595 } else {
2596 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2597 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2598 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCall8f0e8d22011-06-15 23:25:17 +00002599 }
Eric Christopher88b7cf02011-08-19 00:30:14 +00002600
Ted Kremenek30660a82012-03-06 20:06:33 +00002601 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2602 if (ARCMTEnabled) {
2603 D.Diag(diag::err_drv_argument_not_allowed_with)
2604 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2605 }
2606 CmdArgs.push_back("-mt-migrate-directory");
Richard Smith1d489cf2012-11-01 04:30:05 +00002607 CmdArgs.push_back(A->getValue());
Ted Kremenek30660a82012-03-06 20:06:33 +00002608
2609 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand4129992013-07-09 16:59:14 +00002610 options::OPT_objcmt_migrate_subscripting,
2611 options::OPT_objcmt_migrate_property)) {
Ted Kremenek30660a82012-03-06 20:06:33 +00002612 // None specified, means enable them all.
2613 CmdArgs.push_back("-objcmt-migrate-literals");
2614 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand4129992013-07-09 16:59:14 +00002615 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenek30660a82012-03-06 20:06:33 +00002616 } else {
2617 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2618 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand4129992013-07-09 16:59:14 +00002619 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenek30660a82012-03-06 20:06:33 +00002620 }
2621 }
2622
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002623 // Add preprocessing options like -I, -D, etc. if we are using the
2624 // preprocessor.
2625 //
2626 // FIXME: Support -fpreprocessed
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002627 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier9d718632013-01-24 19:14:47 +00002628 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002629
Rafael Espindola19d9d2e2011-07-21 23:40:37 +00002630 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2631 // that "The compiler can only warn and ignore the option if not recognized".
2632 // When building with ccache, it will pass -D options to clang even on
2633 // preprocessed inputs and configure concludes that -fPIC is not supported.
2634 Args.ClaimAllArgs(options::OPT_D);
2635
Rafael Espindola55ee1eb2013-08-27 16:58:15 +00002636 // Manually translate -O4 to -O3; let clang reject others.
2637 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2638 if (A->getOption().matches(options::OPT_O4)) {
2639 CmdArgs.push_back("-O3");
2640 D.Diag(diag::warn_O4_is_O3);
2641 } else {
2642 A->render(Args, CmdArgs);
2643 }
2644 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00002645
Chad Rosierb2c08872012-12-12 20:06:31 +00002646 // Don't warn about unused -flto. This can happen when we're preprocessing or
2647 // precompiling.
2648 Args.ClaimAllArgs(options::OPT_flto);
2649
Daniel Dunbar6e8371e2009-10-29 02:24:45 +00002650 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremeneke8cf7d12012-07-07 05:53:30 +00002651 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2652 CmdArgs.push_back("-pedantic");
Daniel Dunbar6e8371e2009-10-29 02:24:45 +00002653 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002654 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbard573d262009-04-07 22:13:21 +00002655
2656 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgadbb4552013-07-31 16:57:56 +00002657 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbard573d262009-04-07 22:13:21 +00002658 //
2659 // If a std is supplied, only add -trigraphs if it follows the
2660 // option.
2661 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2662 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes528365d2009-10-16 14:28:06 +00002663 if (types::isCXX(InputType))
Daniel Dunbar294691e2009-11-04 06:24:38 +00002664 CmdArgs.push_back("-std=c++98");
Nuno Lopes528365d2009-10-16 14:28:06 +00002665 else
Daniel Dunbar294691e2009-11-04 06:24:38 +00002666 CmdArgs.push_back("-std=c89");
Daniel Dunbard573d262009-04-07 22:13:21 +00002667 else
2668 Std->render(Args, CmdArgs);
2669
Daniel Dunbar0e100312010-06-14 21:23:08 +00002670 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2671 options::OPT_trigraphs))
2672 if (A != Std)
Daniel Dunbard573d262009-04-07 22:13:21 +00002673 A->render(Args, CmdArgs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002674 } else {
2675 // Honor -std-default.
Daniel Dunbar4a5290e2010-01-29 21:03:02 +00002676 //
2677 // FIXME: Clang doesn't correctly handle -std= when the input language
2678 // doesn't match. For the time being just ignore this for C++ inputs;
2679 // eventually we want to do all the standard defaulting here instead of
2680 // splitting it between the driver and clang -cc1.
2681 if (!types::isCXX(InputType))
Nico Weber50f88b92012-08-30 02:08:31 +00002682 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2683 "-std=", /*Joined=*/true);
2684 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2685 CmdArgs.push_back("-std=c++11");
2686
Daniel Dunbard573d262009-04-07 22:13:21 +00002687 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbara3ff2022009-04-26 01:10:38 +00002688 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00002689
Richard Smithe9813b32013-09-04 22:50:31 +00002690 // GCC's behavior for -Wwrite-strings is a bit strange:
2691 // * In C, this "warning flag" changes the types of string literals from
2692 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2693 // for the discarded qualifier.
2694 // * In C++, this is just a normal warning flag.
2695 //
2696 // Implementing this warning correctly in C is hard, so we follow GCC's
2697 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2698 // a non-const char* in C, rather than using this crude hack.
2699 if (!types::isCXX(InputType)) {
2700 // FIXME: This should behave just like a warning flag, and thus should also
2701 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
2702 Arg *WriteStrings =
2703 Args.getLastArg(options::OPT_Wwrite_strings,
2704 options::OPT_Wno_write_strings, options::OPT_w);
2705 if (WriteStrings &&
2706 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
2707 CmdArgs.push_back("-fconst-strings");
Chandler Carruth50465d12011-04-23 06:30:43 +00002708 }
2709
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00002710 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruthf8c247d2011-04-23 19:48:40 +00002711 // during C++ compilation, which it is by default. GCC keeps this define even
2712 // in the presence of '-w', match this behavior bug-for-bug.
2713 if (types::isCXX(InputType) &&
2714 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2715 true)) {
2716 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth1cfe3c32011-04-23 09:27:53 +00002717 }
2718
Chandler Carruthc304ba32010-05-22 02:21:53 +00002719 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2720 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2721 if (Asm->getOption().matches(options::OPT_fasm))
2722 CmdArgs.push_back("-fgnu-keywords");
2723 else
2724 CmdArgs.push_back("-fno-gnu-keywords");
2725 }
2726
Rafael Espindola61b1efe2011-05-02 17:43:32 +00002727 if (ShouldDisableCFI(Args, getToolChain()))
2728 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
Rafael Espindolaf24a1512011-04-30 18:35:43 +00002729
Nick Lewyckyea523d72011-10-17 23:05:52 +00002730 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2731 CmdArgs.push_back("-fno-dwarf-directory-asm");
2732
Daniel Dunbarf4910132013-04-16 18:21:19 +00002733 if (ShouldDisableAutolink(Args, getToolChain()))
2734 CmdArgs.push_back("-fno-autolink");
2735
Chandler Carruthd566df62012-12-17 21:40:04 +00002736 // Add in -fdebug-compilation-dir if necessary.
2737 addDebugCompDirArg(Args, CmdArgs);
Nick Lewycky7c4fd912011-10-21 02:32:14 +00002738
Richard Smithc18c4232011-11-21 19:36:32 +00002739 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2740 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbar1d460332009-03-18 10:01:51 +00002741 CmdArgs.push_back("-ftemplate-depth");
Richard Smith1d489cf2012-11-01 04:30:05 +00002742 CmdArgs.push_back(A->getValue());
Daniel Dunbar1d460332009-03-18 10:01:51 +00002743 }
2744
Richard Smithc18c4232011-11-21 19:36:32 +00002745 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2746 CmdArgs.push_back("-fconstexpr-depth");
Richard Smith1d489cf2012-11-01 04:30:05 +00002747 CmdArgs.push_back(A->getValue());
Richard Smithc18c4232011-11-21 19:36:32 +00002748 }
2749
Richard Smithe7565632013-05-08 02:12:03 +00002750 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2751 CmdArgs.push_back("-fconstexpr-steps");
2752 CmdArgs.push_back(A->getValue());
2753 }
2754
Richard Smith9e738cc2013-02-22 01:59:51 +00002755 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2756 CmdArgs.push_back("-fbracket-depth");
2757 CmdArgs.push_back(A->getValue());
2758 }
2759
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00002760 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2761 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas2e4fd6d2012-05-04 08:08:37 +00002762 if (A->getNumValues()) {
Richard Smith1d489cf2012-11-01 04:30:05 +00002763 StringRef bytes = A->getValue();
Jean-Daniel Dupas2e4fd6d2012-05-04 08:08:37 +00002764 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2765 } else
2766 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00002767 }
2768
Nuno Lopesb3198a82012-05-08 22:10:46 +00002769
Michael J. Spencerc6357102012-10-22 22:13:48 +00002770 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar66861e02009-11-20 22:21:36 +00002771 CmdArgs.push_back("-relocatable-pch");
Mike Stump1eb44332009-09-09 15:08:12 +00002772
Daniel Dunbar294691e2009-11-04 06:24:38 +00002773 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2774 CmdArgs.push_back("-fconstant-string-class");
Richard Smith1d489cf2012-11-01 04:30:05 +00002775 CmdArgs.push_back(A->getValue());
Daniel Dunbar294691e2009-11-04 06:24:38 +00002776 }
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002777
Chris Lattner124fca52010-01-09 21:54:33 +00002778 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2779 CmdArgs.push_back("-ftabstop");
Richard Smith1d489cf2012-11-01 04:30:05 +00002780 CmdArgs.push_back(A->getValue());
Chris Lattner124fca52010-01-09 21:54:33 +00002781 }
2782
Chris Lattner0f0c9632010-04-07 20:49:23 +00002783 CmdArgs.push_back("-ferror-limit");
2784 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smith1d489cf2012-11-01 04:30:05 +00002785 CmdArgs.push_back(A->getValue());
Chris Lattner0f0c9632010-04-07 20:49:23 +00002786 else
2787 CmdArgs.push_back("19");
Douglas Gregor575cf372010-04-20 07:18:24 +00002788
Chandler Carruthc40f73c2010-05-06 04:55:18 +00002789 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2790 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smith1d489cf2012-11-01 04:30:05 +00002791 CmdArgs.push_back(A->getValue());
Chandler Carruthc40f73c2010-05-06 04:55:18 +00002792 }
2793
2794 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2795 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smith1d489cf2012-11-01 04:30:05 +00002796 CmdArgs.push_back(A->getValue());
Chandler Carruthc40f73c2010-05-06 04:55:18 +00002797 }
2798
Richard Smith08d6e032011-12-16 19:06:07 +00002799 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2800 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smith1d489cf2012-11-01 04:30:05 +00002801 CmdArgs.push_back(A->getValue());
Richard Smith08d6e032011-12-16 19:06:07 +00002802 }
2803
Daniel Dunbar55efe142009-11-04 06:24:47 +00002804 // Pass -fmessage-length=.
Daniel Dunbara28690e2009-11-30 08:40:54 +00002805 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar55efe142009-11-04 06:24:47 +00002806 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00002807 CmdArgs.push_back(A->getValue());
Daniel Dunbar55efe142009-11-04 06:24:47 +00002808 } else {
2809 // If -fmessage-length=N was not specified, determine whether this is a
2810 // terminal and, if so, implicitly define -fmessage-length appropriately.
2811 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002812 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar55efe142009-11-04 06:24:47 +00002813 }
2814
John McCalla880b192013-02-19 01:57:35 +00002815 // -fvisibility= and -fvisibility-ms-compat are of a piece.
2816 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2817 options::OPT_fvisibility_ms_compat)) {
2818 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2819 CmdArgs.push_back("-fvisibility");
2820 CmdArgs.push_back(A->getValue());
2821 } else {
2822 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2823 CmdArgs.push_back("-fvisibility");
2824 CmdArgs.push_back("hidden");
2825 CmdArgs.push_back("-ftype-visibility");
2826 CmdArgs.push_back("default");
2827 }
Daniel Dunbarba8d8612009-12-03 18:42:11 +00002828 }
2829
Douglas Gregor7cf84d62010-06-15 17:05:35 +00002830 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002831
Hans Wennborgde981f32012-06-28 08:01:44 +00002832 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2833
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00002834 // -fhosted is default.
Chad Rosierafc4baa2012-03-26 22:04:46 +00002835 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2836 KernelOrKext)
Daniel Dunbar0a80ba72010-03-20 04:52:14 +00002837 CmdArgs.push_back("-ffreestanding");
2838
Daniel Dunbarba8d8612009-12-03 18:42:11 +00002839 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00002840 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00002841 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Devang Patelc69e1cf2010-09-30 19:05:55 +00002842 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
Devang Patel033be8b2011-11-04 20:05:58 +00002843 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
Eric Christophere88c4512011-10-25 07:13:06 +00002844 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidt9e0b6472013-07-03 15:36:02 +00002845 // AltiVec language extensions aren't relevant for assembling.
2846 if (!isa<PreprocessJobAction>(JA) ||
2847 Output.getType() != types::TY_PP_Asm)
2848 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu246b6aa2012-06-26 18:18:47 +00002849 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2850 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier4574c3d2012-03-13 23:45:51 +00002851
Alexey Samsonov1b8f12d2013-08-19 09:14:21 +00002852 const SanitizerArgs &Sanitize = D.getOrParseSanitizerArgs(Args);
Alexey Samsonov8bdc92c2013-08-09 07:42:13 +00002853 Sanitize.addArgs(getToolChain(), Args, CmdArgs);
Richard Smithc4dabad2012-11-05 22:04:41 +00002854
Will Dietz2d382d12012-12-30 20:53:28 +00002855 if (!Args.hasFlag(options::OPT_fsanitize_recover,
2856 options::OPT_fno_sanitize_recover,
2857 true))
2858 CmdArgs.push_back("-fno-sanitize-recover");
2859
Chad Rosier78d85b12013-01-29 23:31:22 +00002860 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
2861 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
2862 options::OPT_fno_sanitize_undefined_trap_on_error, false))
2863 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
2864
Eric Christopher98654c92013-02-19 06:16:53 +00002865 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier4574c3d2012-03-13 23:45:51 +00002866 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Bendersky8f4269a2013-07-24 22:20:49 +00002867 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00002868 getToolChain().getArch() == llvm::Triple::ppc64 ||
2869 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier4574c3d2012-03-13 23:45:51 +00002870 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00002871 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier4574c3d2012-03-13 23:45:51 +00002872
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00002873 if (getToolChain().SupportsProfiling())
2874 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar8c6fa842010-03-16 16:57:46 +00002875
2876 // -flax-vector-conversions is default.
2877 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2878 options::OPT_fno_lax_vector_conversions))
2879 CmdArgs.push_back("-fno-lax-vector-conversions");
2880
Fariborz Jahanianb466d012011-01-07 01:05:02 +00002881 if (Args.getLastArg(options::OPT_fapple_kext))
2882 CmdArgs.push_back("-fapple-kext");
2883
David Blaikie940152f2012-06-14 18:55:27 +00002884 if (Args.hasFlag(options::OPT_frewrite_includes,
2885 options::OPT_fno_rewrite_includes, false))
2886 CmdArgs.push_back("-frewrite-includes");
2887
Fariborz Jahanian34e65772009-05-22 20:17:16 +00002888 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner182e0922009-04-21 05:34:31 +00002889 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregor4786c152010-08-19 20:24:43 +00002890 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00002891 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2892 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnall7f18e672010-09-17 18:29:54 +00002893
2894 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2895 CmdArgs.push_back("-ftrapv-handler");
Richard Smith1d489cf2012-11-01 04:30:05 +00002896 CmdArgs.push_back(A->getValue());
David Chisnall7f18e672010-09-17 18:29:54 +00002897 }
2898
Bob Wilson71fd6cc2012-02-03 06:27:22 +00002899 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng49af1f32011-04-08 21:37:45 +00002900
Chandler Carruth5adb5a82011-03-27 00:04:55 +00002901 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2902 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2903 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2904 options::OPT_fno_wrapv)) {
2905 if (A->getOption().matches(options::OPT_fwrapv))
2906 CmdArgs.push_back("-fwrapv");
2907 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2908 options::OPT_fno_strict_overflow)) {
2909 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2910 CmdArgs.push_back("-fwrapv");
2911 }
Daniel Dunbar3aaf0822009-04-07 21:51:40 +00002912 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruthb26404a2013-08-08 08:34:35 +00002913 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
2914 options::OPT_fno_unroll_loops);
Daniel Dunbar1d460332009-03-18 10:01:51 +00002915
Daniel Dunbar5345c392009-09-03 04:54:28 +00002916 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2917
Mahesha Sf3b52312012-10-27 07:47:56 +00002918
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00002919 // -stack-protector=0 is default.
2920 unsigned StackProtectorLevel = 0;
Bill Wendling45483f72009-06-28 07:36:13 +00002921 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2922 options::OPT_fstack_protector_all,
2923 options::OPT_fstack_protector)) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00002924 if (A->getOption().matches(options::OPT_fstack_protector))
2925 StackProtectorLevel = 1;
2926 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2927 StackProtectorLevel = 2;
Nico Weber2fef1112011-08-23 07:38:27 +00002928 } else {
2929 StackProtectorLevel =
2930 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2931 }
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00002932 if (StackProtectorLevel) {
2933 CmdArgs.push_back("-stack-protector");
Chris Lattner5f9e2722011-07-23 10:55:15 +00002934 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger53b43a72012-09-12 13:51:14 +00002935 }
Chad Rosiera7afeb02012-08-21 16:16:06 +00002936
Joerg Sonnenberger53b43a72012-09-12 13:51:14 +00002937 // --param ssp-buffer-size=
2938 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2939 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smith1d489cf2012-11-01 04:30:05 +00002940 StringRef Str((*it)->getValue());
Joerg Sonnenberger53b43a72012-09-12 13:51:14 +00002941 if (Str.startswith("ssp-buffer-size=")) {
2942 if (StackProtectorLevel) {
Chad Rosiera7afeb02012-08-21 16:16:06 +00002943 CmdArgs.push_back("-stack-protector-buffer-size");
2944 // FIXME: Verify the argument is a valid integer.
2945 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosiera7afeb02012-08-21 16:16:06 +00002946 }
Joerg Sonnenberger53b43a72012-09-12 13:51:14 +00002947 (*it)->claim();
Chad Rosiera7afeb02012-08-21 16:16:06 +00002948 }
Bill Wendling45483f72009-06-28 07:36:13 +00002949 }
2950
Nick Lewycky4e785c92011-12-06 03:33:03 +00002951 // Translate -mstackrealign
2952 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2953 false)) {
2954 CmdArgs.push_back("-backend-option");
2955 CmdArgs.push_back("-force-align-stack");
2956 }
2957 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2958 false)) {
2959 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2960 }
2961
Joerg Sonnenbergere9d11db2011-12-05 23:05:23 +00002962 if (Args.hasArg(options::OPT_mstack_alignment)) {
2963 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2964 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopher1a584022011-05-02 21:18:22 +00002965 }
Chad Rosier586a0612012-11-29 00:42:06 +00002966 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golin02ab7d32013-08-24 14:44:41 +00002967 if (!KernelOrKext) {
Renato Golinb69f9e02013-08-28 23:56:07 +00002968 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2969 options::OPT_munaligned_access)) {
2970 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
2971 CmdArgs.push_back("-backend-option");
2972 CmdArgs.push_back("-arm-strict-align");
2973 } else {
2974 CmdArgs.push_back("-backend-option");
2975 CmdArgs.push_back("-arm-no-strict-align");
2976 }
Renato Golin02ab7d32013-08-24 14:44:41 +00002977 }
Chad Rosier7e293272012-11-09 17:29:19 +00002978 }
Eric Christopher88b7cf02011-08-19 00:30:14 +00002979
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00002980 // Forward -f options with positive and negative forms; we translate
2981 // these by hand.
2982
Fariborz Jahanianb466d012011-01-07 01:05:02 +00002983 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar2843c192011-02-04 17:24:47 +00002984 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahanianb466d012011-01-07 01:05:02 +00002985 CmdArgs.push_back("-fapple-kext");
2986 if (!Args.hasArg(options::OPT_fbuiltin))
2987 CmdArgs.push_back("-fno-builtin");
Chad Rosier3d265502012-03-26 21:29:17 +00002988 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahanianb466d012011-01-07 01:05:02 +00002989 }
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00002990 // -fbuiltin is default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00002991 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar53e84842009-11-19 04:55:23 +00002992 CmdArgs.push_back("-fno-builtin");
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00002993
Nuno Lopesfc284482009-12-16 16:59:22 +00002994 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2995 options::OPT_fno_assume_sane_operator_new))
2996 CmdArgs.push_back("-fno-assume-sane-operator-new");
2997
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00002998 // -fblocks=0 is default.
2999 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnalle6533ff2011-02-28 17:11:43 +00003000 getToolChain().IsBlocksDefault()) ||
3001 (Args.hasArg(options::OPT_fgnu_runtime) &&
3002 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3003 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar9e5cc6b2009-11-17 08:07:36 +00003004 CmdArgs.push_back("-fblocks");
John McCall13db5cf2011-09-09 20:41:01 +00003005
3006 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3007 !getToolChain().hasBlocksRuntime())
3008 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall5e530af2009-11-17 19:33:30 +00003009 }
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00003010
Douglas Gregor64554ba2012-01-18 15:19:58 +00003011 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3012 // users must also pass -fcxx-modules. The latter flag will disappear once the
3013 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorf43b7212013-01-16 01:23:41 +00003014 bool HaveModules = false;
Douglas Gregor64554ba2012-01-18 15:19:58 +00003015 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3016 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3017 options::OPT_fno_cxx_modules,
3018 false);
Douglas Gregorf43b7212013-01-16 01:23:41 +00003019 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor64554ba2012-01-18 15:19:58 +00003020 CmdArgs.push_back("-fmodules");
Douglas Gregorf43b7212013-01-16 01:23:41 +00003021 HaveModules = true;
3022 }
3023 }
3024
Daniel Jasper056ec122013-08-05 20:26:17 +00003025 // -fmodule-maps enables module map processing (off by default) for header
3026 // checking. It is implied by -fmodules.
3027 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3028 false)) {
3029 CmdArgs.push_back("-fmodule-maps");
3030 }
3031
Douglas Gregor953a61f2013-02-07 19:01:24 +00003032 // If a module path was provided, pass it along. Otherwise, use a temporary
3033 // directory.
3034 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3035 A->claim();
3036 if (HaveModules) {
3037 A->render(Args, CmdArgs);
3038 }
3039 } else if (HaveModules) {
3040 SmallString<128> DefaultModuleCache;
3041 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3042 DefaultModuleCache);
Douglas Gregor892b6fb2013-03-21 21:48:48 +00003043 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3044 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
Douglas Gregor250172a2013-02-07 22:59:12 +00003045 const char Arg[] = "-fmodules-cache-path=";
3046 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3047 Arg, Arg + strlen(Arg));
Douglas Gregor953a61f2013-02-07 19:01:24 +00003048 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3049 }
3050
3051 // Pass through all -fmodules-ignore-macro arguments.
3052 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregord44d2872013-03-25 21:19:16 +00003053 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3054 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor953a61f2013-02-07 19:01:24 +00003055
John McCall32579cf2010-04-09 19:12:06 +00003056 // -faccess-control is default.
John McCall7002f4c2010-04-09 19:03:51 +00003057 if (Args.hasFlag(options::OPT_fno_access_control,
3058 options::OPT_faccess_control,
John McCall32579cf2010-04-09 19:12:06 +00003059 false))
John McCall7002f4c2010-04-09 19:03:51 +00003060 CmdArgs.push_back("-fno-access-control");
John McCall3ddd6e02010-03-17 01:32:13 +00003061
Anders Carlssona4c24752010-11-21 00:09:52 +00003062 // -felide-constructors is the default.
3063 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3064 options::OPT_felide_constructors,
3065 false))
3066 CmdArgs.push_back("-fno-elide-constructors");
3067
Daniel Dunbar0be42c42009-11-17 07:06:20 +00003068 // -frtti is default.
Chad Rosierafc4baa2012-03-26 22:04:46 +00003069 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smithc4dabad2012-11-05 22:04:41 +00003070 KernelOrKext) {
Daniel Dunbar53e84842009-11-19 04:55:23 +00003071 CmdArgs.push_back("-fno-rtti");
Mike Stump738f8c22009-07-31 23:15:31 +00003072
Richard Smithc4dabad2012-11-05 22:04:41 +00003073 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonovbb1071c2012-11-06 15:09:03 +00003074 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumi03c60762012-11-06 22:02:00 +00003075 std::string NoRttiArg =
Richard Smithc4dabad2012-11-05 22:04:41 +00003076 Args.getLastArg(options::OPT_mkernel,
3077 options::OPT_fapple_kext,
Richard Smith04fd3822012-11-06 01:12:02 +00003078 options::OPT_fno_rtti)->getAsString(Args);
Richard Smithc4dabad2012-11-05 22:04:41 +00003079 D.Diag(diag::err_drv_argument_not_allowed_with)
3080 << "-fsanitize=vptr" << NoRttiArg;
3081 }
3082 }
3083
Tony Linthicum96319392011-12-12 21:14:55 +00003084 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00003085 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum96319392011-12-12 21:14:55 +00003086 options::OPT_fno_short_enums,
Eli Bendersky8f4269a2013-07-24 22:20:49 +00003087 getToolChain().getArch() ==
Tony Linthicum96319392011-12-12 21:14:55 +00003088 llvm::Triple::hexagon))
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00003089 CmdArgs.push_back("-fshort-enums");
3090
Daniel Dunbar1f95e652009-11-17 06:37:03 +00003091 // -fsigned-char is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00003092 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbar1f95e652009-11-17 06:37:03 +00003093 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar76743522009-11-29 02:39:08 +00003094 CmdArgs.push_back("-fno-signed-char");
Eli Friedman5a779732009-06-05 07:21:14 +00003095
Anders Carlssona508b7d2010-02-06 23:23:06 +00003096 // -fthreadsafe-static is default.
Michael J. Spencer20249a12010-10-21 03:16:25 +00003097 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssona508b7d2010-02-06 23:23:06 +00003098 options::OPT_fno_threadsafe_statics))
3099 CmdArgs.push_back("-fno-threadsafe-statics");
3100
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00003101 // -fuse-cxa-atexit is default.
Chad Rosierafc4baa2012-03-26 22:04:46 +00003102 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3103 options::OPT_fno_use_cxa_atexit,
3104 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
Tony Linthicum96319392011-12-12 21:14:55 +00003105 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
Eli Bendersky8f4269a2013-07-24 22:20:49 +00003106 getToolChain().getArch() != llvm::Triple::hexagon) ||
Chad Rosierafc4baa2012-03-26 22:04:46 +00003107 KernelOrKext)
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00003108 CmdArgs.push_back("-fno-use-cxa-atexit");
3109
Daniel Dunbar0be42c42009-11-17 07:06:20 +00003110 // -fms-extensions=0 is default.
Daniel Dunbar6d2eb4d2009-11-25 10:14:30 +00003111 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Daniel Dunbar0be42c42009-11-17 07:06:20 +00003112 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3113 CmdArgs.push_back("-fms-extensions");
3114
Francois Pichetae556082011-09-17 04:32:15 +00003115 // -fms-compatibility=0 is default.
Douglas Gregorba97b6e2011-10-24 15:49:38 +00003116 if (Args.hasFlag(options::OPT_fms_compatibility,
3117 options::OPT_fno_ms_compatibility,
3118 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3119 Args.hasFlag(options::OPT_fms_extensions,
3120 options::OPT_fno_ms_extensions,
3121 true))))
Francois Pichetae556082011-09-17 04:32:15 +00003122 CmdArgs.push_back("-fms-compatibility");
3123
Reid Kleckner8c64c182013-09-18 00:33:59 +00003124 // -fmsc-version=1700 is default.
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003125 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3126 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3127 Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00003128 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003129 if (msc_ver.empty())
Reid Kleckner8c64c182013-09-18 00:33:59 +00003130 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003131 else
3132 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3133 }
3134
3135
Eric Christophercfc01e42013-02-18 00:38:31 +00003136 // -fno-borland-extensions is default.
Dawn Perchik400b6072010-09-02 23:59:25 +00003137 if (Args.hasFlag(options::OPT_fborland_extensions,
3138 options::OPT_fno_borland_extensions, false))
3139 CmdArgs.push_back("-fborland-extensions");
3140
Francois Pichet8efcc012011-09-01 16:38:08 +00003141 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3142 // needs it.
Francois Pichet8387e2a2011-04-22 22:18:13 +00003143 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3144 options::OPT_fno_delayed_template_parsing,
Francois Pichet8efcc012011-09-01 16:38:08 +00003145 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
Francois Pichet805bc1f2011-08-26 00:22:34 +00003146 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet8387e2a2011-04-22 22:18:13 +00003147
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00003148 // -fgnu-keywords default varies depending on language; only pass if
3149 // specified.
3150 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbar40788d92010-04-24 17:56:39 +00003151 options::OPT_fno_gnu_keywords))
3152 A->render(Args, CmdArgs);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00003153
Rafael Espindola01ba8542011-06-02 17:30:53 +00003154 if (Args.hasFlag(options::OPT_fgnu89_inline,
3155 options::OPT_fno_gnu89_inline,
3156 false))
Rafael Espindolafb3f4aa2011-06-02 16:13:27 +00003157 CmdArgs.push_back("-fgnu89-inline");
3158
Chad Rosierfc055f92012-03-15 22:31:42 +00003159 if (Args.hasArg(options::OPT_fno_inline))
3160 CmdArgs.push_back("-fno-inline");
3161
Chad Rosier634a4b12012-03-06 21:17:19 +00003162 if (Args.hasArg(options::OPT_fno_inline_functions))
3163 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier250008b2012-03-06 18:49:20 +00003164
John McCall260611a2012-06-20 06:18:46 +00003165 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall9f084a32011-07-06 00:26:06 +00003166
John McCall260611a2012-06-20 06:18:46 +00003167 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3168 // legacy is the default.
3169 if (objcRuntime.isNonFragile()) {
David Chisnall3c3ccd22011-09-30 13:32:35 +00003170 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3171 options::OPT_fno_objc_legacy_dispatch,
David Chisnall2c7886d2012-07-04 11:52:24 +00003172 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Bendersky8f4269a2013-07-24 22:20:49 +00003173 getToolChain().getArch()))) {
David Chisnall3c3ccd22011-09-30 13:32:35 +00003174 if (getToolChain().UseObjCMixedDispatch())
3175 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3176 else
3177 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3178 }
3179 }
3180
Nico Weberdf423542012-03-09 21:19:44 +00003181 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
3182 // if the nonfragile objc abi is used.
Fariborz Jahaniane51fe092012-04-09 18:58:55 +00003183 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
David Chisnall3c3ccd22011-09-30 13:32:35 +00003184 CmdArgs.push_back("-fobjc-default-synthesize-properties");
3185 }
3186
Fariborz Jahanian3d145f62012-11-15 19:02:45 +00003187 // -fencode-extended-block-signature=1 is default.
3188 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3189 CmdArgs.push_back("-fencode-extended-block-signature");
3190 }
3191
John McCall9f084a32011-07-06 00:26:06 +00003192 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3193 // NOTE: This logic is duplicated in ToolChains.cpp.
3194 bool ARC = isObjCAutoRefCount(Args);
3195 if (ARC) {
John McCall0a7dd782012-08-21 02:47:43 +00003196 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis5840dd92012-02-29 03:43:52 +00003197
John McCall9f084a32011-07-06 00:26:06 +00003198 CmdArgs.push_back("-fobjc-arc");
3199
Chandler Carruth7ffa0322011-11-04 07:34:47 +00003200 // FIXME: It seems like this entire block, and several around it should be
3201 // wrapped in isObjC, but for now we just use it here as this is where it
3202 // was being used previously.
3203 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3204 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3205 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3206 else
3207 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3208 }
3209
John McCall9f084a32011-07-06 00:26:06 +00003210 // Allow the user to enable full exceptions code emission.
3211 // We define off for Objective-CC, on for Objective-C++.
3212 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3213 options::OPT_fno_objc_arc_exceptions,
3214 /*default*/ types::isCXX(InputType)))
3215 CmdArgs.push_back("-fobjc-arc-exceptions");
3216 }
3217
3218 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3219 // rewriter.
John McCall260611a2012-06-20 06:18:46 +00003220 if (rewriteKind != RK_None)
John McCall9f084a32011-07-06 00:26:06 +00003221 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher88b7cf02011-08-19 00:30:14 +00003222
John McCall9f084a32011-07-06 00:26:06 +00003223 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3224 // takes precedence.
3225 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3226 if (!GCArg)
3227 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3228 if (GCArg) {
3229 if (ARC) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00003230 D.Diag(diag::err_drv_objc_gc_arr)
John McCall9f084a32011-07-06 00:26:06 +00003231 << GCArg->getAsString(Args);
3232 } else if (getToolChain().SupportsObjCGC()) {
3233 GCArg->render(Args, CmdArgs);
3234 } else {
3235 // FIXME: We should move this to a hard error.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003236 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall9f084a32011-07-06 00:26:06 +00003237 << GCArg->getAsString(Args);
3238 }
3239 }
3240
John McCalld71315c2011-06-22 00:53:57 +00003241 // Add exception args.
3242 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall260611a2012-06-20 06:18:46 +00003243 KernelOrKext, objcRuntime, CmdArgs);
John McCalld71315c2011-06-22 00:53:57 +00003244
3245 if (getToolChain().UseSjLjExceptions())
3246 CmdArgs.push_back("-fsjlj-exceptions");
3247
3248 // C++ "sane" operator new.
Daniel Dunbar984eb862010-02-01 21:07:25 +00003249 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3250 options::OPT_fno_assume_sane_operator_new))
3251 CmdArgs.push_back("-fno-assume-sane-operator-new");
3252
Daniel Dunbarf35f14d2010-04-27 15:34:57 +00003253 // -fconstant-cfstrings is default, and may be subject to argument translation
3254 // on Darwin.
3255 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3256 options::OPT_fno_constant_cfstrings) ||
3257 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3258 options::OPT_mno_constant_cfstrings))
3259 CmdArgs.push_back("-fno-constant-cfstrings");
3260
John Thompsona6fda122009-11-05 20:14:16 +00003261 // -fshort-wchar default varies depending on platform; only
3262 // pass if specified.
Daniel Dunbar1744a352010-04-27 15:35:03 +00003263 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3264 A->render(Args, CmdArgs);
John Thompsona6fda122009-11-05 20:14:16 +00003265
Hans Wennborgb087a5d2013-07-31 23:39:13 +00003266 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003267 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbar82d00682009-04-07 23:51:44 +00003268 options::OPT_fno_pascal_strings,
Daniel Dunbar82d00682009-04-07 23:51:44 +00003269 false))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00003270 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi125b4cb2011-02-17 08:50:50 +00003271
Daniel Dunbar88934e82011-10-05 21:04:55 +00003272 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3273 // -fno-pack-struct doesn't apply to -fpack-struct=.
3274 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloy8049c442012-05-02 07:56:14 +00003275 std::string PackStructStr = "-fpack-struct=";
Richard Smith1d489cf2012-11-01 04:30:05 +00003276 PackStructStr += A->getValue();
James Molloy8049c442012-05-02 07:56:14 +00003277 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar88934e82011-10-05 21:04:55 +00003278 } else if (Args.hasFlag(options::OPT_fpack_struct,
3279 options::OPT_fno_pack_struct, false)) {
James Molloy8049c442012-05-02 07:56:14 +00003280 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar88934e82011-10-05 21:04:55 +00003281 }
3282
Robert Lytton5f15f4d2013-08-13 09:43:10 +00003283 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahanianb466d012011-01-07 01:05:02 +00003284 if (!Args.hasArg(options::OPT_fcommon))
3285 CmdArgs.push_back("-fno-common");
Chad Rosierec09b3e2012-03-26 21:35:40 +00003286 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahanianb466d012011-01-07 01:05:02 +00003287 }
Daniel Dunbar88934e82011-10-05 21:04:55 +00003288
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00003289 // -fcommon is default, only pass non-default.
Fariborz Jahanianb466d012011-01-07 01:05:02 +00003290 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbar48d1ef72009-04-07 21:16:11 +00003291 CmdArgs.push_back("-fno-common");
3292
Daniel Dunbar70d3c922009-04-15 02:37:43 +00003293 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar06205ca2010-10-15 22:30:42 +00003294 // -funsigned-bitfields.
Mike Stump1eb44332009-09-09 15:08:12 +00003295 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar70d3c922009-04-15 02:37:43 +00003296 options::OPT_funsigned_bitfields))
Chris Lattner5f9e2722011-07-23 10:55:15 +00003297 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar70d3c922009-04-15 02:37:43 +00003298 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3299
Daniel Dunbar06205ca2010-10-15 22:30:42 +00003300 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3301 if (!Args.hasFlag(options::OPT_ffor_scope,
3302 options::OPT_fno_for_scope))
Chris Lattner5f9e2722011-07-23 10:55:15 +00003303 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar06205ca2010-10-15 22:30:42 +00003304 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3305
Jeffrey Yasskin0ea22fd2010-06-08 04:56:20 +00003306 // -fcaret-diagnostics is default.
3307 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3308 options::OPT_fno_caret_diagnostics, true))
3309 CmdArgs.push_back("-fno-caret-diagnostics");
3310
Daniel Dunbar49138fc2009-04-19 21:09:34 +00003311 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump1eb44332009-09-09 15:08:12 +00003312 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar49138fc2009-04-19 21:09:34 +00003313 options::OPT_fno_diagnostics_fixit_info))
3314 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher88b7cf02011-08-19 00:30:14 +00003315
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00003316 // Enable -fdiagnostics-show-option by default.
Mike Stump1eb44332009-09-09 15:08:12 +00003317 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00003318 options::OPT_fno_diagnostics_show_option))
3319 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar838be482009-11-04 06:24:57 +00003320
Chris Lattner6fbe8392010-05-04 21:55:25 +00003321 if (const Arg *A =
3322 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3323 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smith1d489cf2012-11-01 04:30:05 +00003324 CmdArgs.push_back(A->getValue());
Chris Lattner6fbe8392010-05-04 21:55:25 +00003325 }
Daniel Dunbarca0e0542010-08-24 16:47:49 +00003326
Douglas Gregorc9471b02011-05-21 17:07:29 +00003327 if (const Arg *A =
3328 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3329 CmdArgs.push_back("-fdiagnostics-format");
Richard Smith1d489cf2012-11-01 04:30:05 +00003330 CmdArgs.push_back(A->getValue());
Douglas Gregorc9471b02011-05-21 17:07:29 +00003331 }
3332
Chandler Carruthabaca7a2011-03-27 01:50:55 +00003333 if (Arg *A = Args.getLastArg(
3334 options::OPT_fdiagnostics_show_note_include_stack,
3335 options::OPT_fno_diagnostics_show_note_include_stack)) {
3336 if (A->getOption().matches(
3337 options::OPT_fdiagnostics_show_note_include_stack))
3338 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3339 else
3340 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3341 }
3342
Daniel Dunbar838be482009-11-04 06:24:57 +00003343 // Color diagnostics are the default, unless the terminal doesn't support
3344 // them.
Nico Weber9753d462013-04-17 21:52:44 +00003345 // Support both clang's -f[no-]color-diagnostics and gcc's
3346 // -f[no-]diagnostics-colors[=never|always|auto].
3347 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3348 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3349 it != ie; ++it) {
3350 const Option &O = (*it)->getOption();
3351 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3352 !O.matches(options::OPT_fdiagnostics_color) &&
3353 !O.matches(options::OPT_fno_color_diagnostics) &&
3354 !O.matches(options::OPT_fno_diagnostics_color) &&
3355 !O.matches(options::OPT_fdiagnostics_color_EQ))
3356 continue;
3357
3358 (*it)->claim();
3359 if (O.matches(options::OPT_fcolor_diagnostics) ||
3360 O.matches(options::OPT_fdiagnostics_color)) {
3361 ShowColors = Colors_On;
3362 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3363 O.matches(options::OPT_fno_diagnostics_color)) {
3364 ShowColors = Colors_Off;
3365 } else {
3366 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3367 StringRef value((*it)->getValue());
3368 if (value == "always")
3369 ShowColors = Colors_On;
3370 else if (value == "never")
3371 ShowColors = Colors_Off;
3372 else if (value == "auto")
3373 ShowColors = Colors_Auto;
3374 else
3375 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3376 << ("-fdiagnostics-color=" + value).str();
3377 }
3378 }
3379 if (ShowColors == Colors_On ||
3380 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar838be482009-11-04 06:24:57 +00003381 CmdArgs.push_back("-fcolor-diagnostics");
3382
Nico Rieck2956ef42013-09-11 00:38:02 +00003383 if (Args.hasArg(options::OPT_fansi_escape_codes))
3384 CmdArgs.push_back("-fansi-escape-codes");
3385
Daniel Dunbar75eb1d62009-06-08 21:13:54 +00003386 if (!Args.hasFlag(options::OPT_fshow_source_location,
3387 options::OPT_fno_show_source_location))
3388 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar9e820ee2009-04-16 06:32:38 +00003389
Douglas Gregorc9471b02011-05-21 17:07:29 +00003390 if (!Args.hasFlag(options::OPT_fshow_column,
3391 options::OPT_fno_show_column,
3392 true))
3393 CmdArgs.push_back("-fno-show-column");
3394
Douglas Gregora0068fc2010-07-09 17:35:33 +00003395 if (!Args.hasFlag(options::OPT_fspell_checking,
3396 options::OPT_fno_spell_checking))
3397 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarca0e0542010-08-24 16:47:49 +00003398
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00003399
Chad Rosier15490fd2012-12-05 21:08:21 +00003400 // -fno-asm-blocks is default.
3401 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3402 false))
3403 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar25b26eb2010-10-18 22:49:46 +00003404
Arnold Schwaighofer99662a12013-08-13 15:46:23 +00003405 // Enable vectorization per default according to the optimization level
3406 // selected. For optimization levels that want vectorization we use the alias
3407 // option to simplify the hasFlag logic.
3408 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3409 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier31422792013-04-24 18:29:59 +00003410 options::OPT_fvectorize;
Chad Rosier31422792013-04-24 18:29:59 +00003411 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkelcf5691e2013-08-28 05:21:45 +00003412 options::OPT_fno_vectorize, EnableVec))
Chad Rosierc04d0932012-12-11 17:12:28 +00003413 CmdArgs.push_back("-vectorize-loops");
Chad Rosierc04d0932012-12-11 17:12:28 +00003414
Rafael Espindolad8360612013-08-01 23:56:42 +00003415 // -fslp-vectorize is default.
3416 if (Args.hasFlag(options::OPT_fslp_vectorize,
3417 options::OPT_fno_slp_vectorize, true))
Nadav Rotem50ea9632013-04-15 04:57:18 +00003418 CmdArgs.push_back("-vectorize-slp");
Hal Finkel443c9992012-12-11 19:59:32 +00003419
Nadav Rotem3c6a9b02013-04-15 05:38:41 +00003420 // -fno-slp-vectorize-aggressive is default.
3421 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyfdf137b2013-06-25 01:49:44 +00003422 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem3c6a9b02013-04-15 05:38:41 +00003423 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem3c6a9b02013-04-15 05:38:41 +00003424
Jeffrey Yasskin5edbdcc2010-06-11 05:57:47 +00003425 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3426 A->render(Args, CmdArgs);
3427
Daniel Dunbar7695fba2009-04-19 21:20:32 +00003428 // -fdollars-in-identifiers default varies depending on platform and
3429 // language; only pass if specified.
Mike Stump1eb44332009-09-09 15:08:12 +00003430 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbar7695fba2009-04-19 21:20:32 +00003431 options::OPT_fno_dollars_in_identifiers)) {
3432 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar8663b182009-12-16 20:10:18 +00003433 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00003434 else
Daniel Dunbar8663b182009-12-16 20:10:18 +00003435 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbar7695fba2009-04-19 21:20:32 +00003436 }
3437
Daniel Dunbare027a4b2009-05-22 19:02:20 +00003438 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3439 // practical purposes.
Mike Stump1eb44332009-09-09 15:08:12 +00003440 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbare027a4b2009-05-22 19:02:20 +00003441 options::OPT_fno_unit_at_a_time)) {
3442 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner5f9e2722011-07-23 10:55:15 +00003443 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbare027a4b2009-05-22 19:02:20 +00003444 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00003445
Eli Friedman19bda3a2011-11-02 01:53:16 +00003446 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3447 options::OPT_fno_apple_pragma_pack, false))
3448 CmdArgs.push_back("-fapple-pragma-pack");
3449
Eli Benderskyf3ecf892013-07-24 18:20:14 +00003450 // le32-specific flags:
3451 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3452 // by default.
3453 if (getToolChain().getArch() == llvm::Triple::le32) {
3454 CmdArgs.push_back("-fno-math-builtin");
3455 }
3456
Daniel Dunbar2ba91572009-09-10 03:37:02 +00003457 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00003458 //
Daniel Dunbar8ff5b282009-12-11 23:00:49 +00003459 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00003460#if 0
Bob Wilson905c45f2011-10-14 05:03:44 +00003461 if (getToolChain().getTriple().isOSDarwin() &&
Eli Bendersky8f4269a2013-07-24 22:20:49 +00003462 (getToolChain().getArch() == llvm::Triple::arm ||
3463 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ba91572009-09-10 03:37:02 +00003464 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3465 CmdArgs.push_back("-fno-builtin-strcat");
3466 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3467 CmdArgs.push_back("-fno-builtin-strcpy");
3468 }
Daniel Dunbarf84a4a42009-09-10 04:57:27 +00003469#endif
Daniel Dunbar2ba91572009-09-10 03:37:02 +00003470
Daniel Dunbard98750f2011-03-18 21:23:40 +00003471 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump1eb44332009-09-09 15:08:12 +00003472 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbard98750f2011-03-18 21:23:40 +00003473 options::OPT_traditional_cpp)) {
3474 if (isa<PreprocessJobAction>(JA))
3475 CmdArgs.push_back("-traditional-cpp");
Eric Christopher88b7cf02011-08-19 00:30:14 +00003476 else
Chris Lattner5f9e2722011-07-23 10:55:15 +00003477 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbard98750f2011-03-18 21:23:40 +00003478 }
Eli Friedmanceb5c5b2009-07-14 21:58:17 +00003479
Daniel Dunbar1d460332009-03-18 10:01:51 +00003480 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnerd82df3a2009-04-12 01:56:53 +00003481 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremenek36f6e302011-11-11 00:07:43 +00003482
3483 // Handle serialized diagnostics.
3484 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3485 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smith1d489cf2012-11-01 04:30:05 +00003486 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremenek36f6e302011-11-11 00:07:43 +00003487 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00003488
Ted Kremenek127ff2e2012-09-13 06:41:18 +00003489 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3490 CmdArgs.push_back("-fretain-comments-from-system-headers");
3491
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +00003492 // Forward -fcomment-block-commands to -cc1.
3493 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenko6fd7d302013-04-10 15:35:17 +00003494 // Forward -fparse-all-comments to -cc1.
3495 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +00003496
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00003497 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3498 // parser.
Daniel Dunbar1d460332009-03-18 10:01:51 +00003499 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00003500 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3501 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00003502 (*it)->claim();
Daniel Dunbarfb36d212010-04-17 06:10:00 +00003503
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00003504 // We translate this by hand to the -cc1 argument, since nightly test uses
3505 // it and developers have been trained to spell it with -mllvm.
Richard Smith1d489cf2012-11-01 04:30:05 +00003506 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00003507 CmdArgs.push_back("-disable-llvm-optzns");
3508 else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00003509 (*it)->render(Args, CmdArgs);
Daniel Dunbar3f87fb02010-04-15 06:09:03 +00003510 }
Daniel Dunbar1d460332009-03-18 10:01:51 +00003511
Daniel Dunbarcd8e4c42009-03-30 06:36:42 +00003512 if (Output.getType() == types::TY_Dependencies) {
3513 // Handled with other dependency code.
Daniel Dunbar115a7922009-03-19 07:29:38 +00003514 } else if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003515 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00003516 CmdArgs.push_back(Output.getFilename());
3517 } else {
3518 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003519 }
3520
Daniel Dunbar1d460332009-03-18 10:01:51 +00003521 for (InputInfoList::const_iterator
3522 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3523 const InputInfo &II = *it;
3524 CmdArgs.push_back("-x");
Fariborz Jahaniana5ee0892012-09-28 19:05:17 +00003525 if (Args.hasArg(options::OPT_rewrite_objc))
3526 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3527 else
3528 CmdArgs.push_back(types::getTypeName(II.getType()));
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003529 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00003530 CmdArgs.push_back(II.getFilename());
Daniel Dunbar1d460332009-03-18 10:01:51 +00003531 else
Daniel Dunbar115a7922009-03-19 07:29:38 +00003532 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbar1d460332009-03-18 10:01:51 +00003533 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003534
Chris Lattnere6113de2009-11-03 19:50:27 +00003535 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3536
Daniel Dunbara001c1c2010-07-18 21:16:15 +00003537 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00003538
3539 // Optionally embed the -cc1 level arguments into the debug info, for build
3540 // analysis.
3541 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar6e900472010-06-04 18:47:06 +00003542 ArgStringList OriginalArgs;
3543 for (ArgList::const_iterator it = Args.begin(),
3544 ie = Args.end(); it != ie; ++it)
3545 (*it)->render(Args, OriginalArgs);
Daniel Dunbarca0e0542010-08-24 16:47:49 +00003546
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00003547 SmallString<256> Flags;
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00003548 Flags += Exec;
Daniel Dunbar6e900472010-06-04 18:47:06 +00003549 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00003550 Flags += " ";
Daniel Dunbar6e900472010-06-04 18:47:06 +00003551 Flags += OriginalArgs[i];
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +00003552 }
3553 CmdArgs.push_back("-dwarf-debug-flags");
3554 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3555 }
3556
Eric Christopher80190392013-02-22 20:12:52 +00003557 // Add the split debug info name to the command lines here so we
3558 // can propagate it to the backend.
3559 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00003560 getToolChain().getTriple().isOSLinux() &&
Eric Christopherff971d72013-02-22 23:50:16 +00003561 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopher80190392013-02-22 20:12:52 +00003562 const char *SplitDwarfOut;
3563 if (SplitDwarf) {
3564 CmdArgs.push_back("-split-dwarf-file");
3565 SplitDwarfOut = SplitDebugName(Args, Inputs);
3566 CmdArgs.push_back(SplitDwarfOut);
3567 }
3568
3569 // Finally add the compile command to the compilation.
Hans Wennborgc8ba0a02013-09-19 20:32:16 +00003570 if (Args.hasArg(options::OPT__SLASH_fallback)) {
3571 tools::visualstudio::Compile CL(getToolChain());
3572 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3573 LinkingOutput);
3574 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3575 } else {
3576 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3577 }
3578
Daniel Dunbara880db02009-03-23 19:03:36 +00003579
Eric Christopherff971d72013-02-22 23:50:16 +00003580 // Handle the debug info splitting at object creation time if we're
3581 // creating an object.
Eric Christopher59320e72013-02-21 22:35:01 +00003582 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherff971d72013-02-22 23:50:16 +00003583 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopher80190392013-02-22 20:12:52 +00003584 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher59320e72013-02-21 22:35:01 +00003585
Roman Divackybe4c8702011-02-10 16:52:03 +00003586 if (Arg *A = Args.getLastArg(options::OPT_pg))
3587 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner5f9e2722011-07-23 10:55:15 +00003588 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divackybe4c8702011-02-10 16:52:03 +00003589 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer20249a12010-10-21 03:16:25 +00003590
Daniel Dunbar68fb4692009-04-03 20:51:31 +00003591 // Claim some arguments which clang supports automatically.
3592
Daniel Dunbarf4046862010-04-15 06:18:42 +00003593 // -fpch-preprocess is used with gcc to add a special marker in the output to
3594 // include the PCH file. Clang's PTH solution is completely transparent, so we
3595 // do not need to deal with it at all.
Daniel Dunbar68fb4692009-04-03 20:51:31 +00003596 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003597
Daniel Dunbara880db02009-03-23 19:03:36 +00003598 // Claim some arguments which clang doesn't support, but we don't
3599 // care to warn the user about.
Daniel Dunbarcdd96862009-11-25 11:53:23 +00003600 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3601 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola035ff0c2011-02-28 23:29:45 +00003602
Rafael Espindola6155fbe2013-09-04 19:37:35 +00003603 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindola9c094fb2011-03-01 05:25:27 +00003604 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00003605}
3606
John McCall260611a2012-06-20 06:18:46 +00003607/// Add options related to the Objective-C runtime/ABI.
3608///
3609/// Returns true if the runtime is non-fragile.
3610ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3611 ArgStringList &cmdArgs,
3612 RewriteKind rewriteKind) const {
3613 // Look for the controlling runtime option.
3614 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3615 options::OPT_fgnu_runtime,
3616 options::OPT_fobjc_runtime_EQ);
3617
3618 // Just forward -fobjc-runtime= to the frontend. This supercedes
3619 // options about fragility.
3620 if (runtimeArg &&
3621 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3622 ObjCRuntime runtime;
Richard Smith1d489cf2012-11-01 04:30:05 +00003623 StringRef value = runtimeArg->getValue();
John McCall260611a2012-06-20 06:18:46 +00003624 if (runtime.tryParse(value)) {
3625 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3626 << value;
3627 }
3628
3629 runtimeArg->render(args, cmdArgs);
3630 return runtime;
3631 }
3632
3633 // Otherwise, we'll need the ABI "version". Version numbers are
3634 // slightly confusing for historical reasons:
3635 // 1 - Traditional "fragile" ABI
3636 // 2 - Non-fragile ABI, version 1
3637 // 3 - Non-fragile ABI, version 2
3638 unsigned objcABIVersion = 1;
3639 // If -fobjc-abi-version= is present, use that to set the version.
3640 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00003641 StringRef value = abiArg->getValue();
John McCall260611a2012-06-20 06:18:46 +00003642 if (value == "1")
3643 objcABIVersion = 1;
3644 else if (value == "2")
3645 objcABIVersion = 2;
3646 else if (value == "3")
3647 objcABIVersion = 3;
3648 else
3649 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3650 << value;
3651 } else {
3652 // Otherwise, determine if we are using the non-fragile ABI.
3653 bool nonFragileABIIsDefault =
3654 (rewriteKind == RK_NonFragile ||
3655 (rewriteKind == RK_None &&
3656 getToolChain().IsObjCNonFragileABIDefault()));
3657 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3658 options::OPT_fno_objc_nonfragile_abi,
3659 nonFragileABIIsDefault)) {
3660 // Determine the non-fragile ABI version to use.
3661#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3662 unsigned nonFragileABIVersion = 1;
3663#else
3664 unsigned nonFragileABIVersion = 2;
3665#endif
3666
3667 if (Arg *abiArg = args.getLastArg(
3668 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00003669 StringRef value = abiArg->getValue();
John McCall260611a2012-06-20 06:18:46 +00003670 if (value == "1")
3671 nonFragileABIVersion = 1;
3672 else if (value == "2")
3673 nonFragileABIVersion = 2;
3674 else
3675 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3676 << value;
3677 }
3678
3679 objcABIVersion = 1 + nonFragileABIVersion;
3680 } else {
3681 objcABIVersion = 1;
3682 }
3683 }
3684
3685 // We don't actually care about the ABI version other than whether
3686 // it's non-fragile.
3687 bool isNonFragile = objcABIVersion != 1;
3688
3689 // If we have no runtime argument, ask the toolchain for its default runtime.
3690 // However, the rewriter only really supports the Mac runtime, so assume that.
3691 ObjCRuntime runtime;
3692 if (!runtimeArg) {
3693 switch (rewriteKind) {
3694 case RK_None:
3695 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3696 break;
3697 case RK_Fragile:
3698 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3699 break;
3700 case RK_NonFragile:
3701 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3702 break;
3703 }
3704
3705 // -fnext-runtime
3706 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3707 // On Darwin, make this use the default behavior for the toolchain.
3708 if (getToolChain().getTriple().isOSDarwin()) {
3709 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3710
3711 // Otherwise, build for a generic macosx port.
3712 } else {
3713 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3714 }
3715
3716 // -fgnu-runtime
3717 } else {
3718 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnalla422cd02012-07-04 10:37:03 +00003719 // Legacy behaviour is to target the gnustep runtime if we are i
3720 // non-fragile mode or the GCC runtime in fragile mode.
3721 if (isNonFragile)
David Chisnall891dac72012-10-16 15:11:55 +00003722 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnalla422cd02012-07-04 10:37:03 +00003723 else
3724 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall260611a2012-06-20 06:18:46 +00003725 }
3726
3727 cmdArgs.push_back(args.MakeArgString(
3728 "-fobjc-runtime=" + runtime.getAsString()));
3729 return runtime;
3730}
3731
Hans Wennborgb3574792013-08-08 00:17:41 +00003732void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3733 unsigned RTOptionID = options::OPT__SLASH_MT;
3734
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00003735 if (Args.hasArg(options::OPT__SLASH_LDd))
3736 // The /LDd option implies /MTd. The dependent lib part can be overridden,
3737 // but defining _DEBUG is sticky.
3738 RTOptionID = options::OPT__SLASH_MTd;
3739
Hans Wennborg76da1782013-09-18 22:26:39 +00003740 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborgb3574792013-08-08 00:17:41 +00003741 RTOptionID = A->getOption().getID();
Hans Wennborg42ade492013-09-11 16:38:41 +00003742
Hans Wennborgb3574792013-08-08 00:17:41 +00003743 switch(RTOptionID) {
3744 case options::OPT__SLASH_MD:
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00003745 if (Args.hasArg(options::OPT__SLASH_LDd))
3746 CmdArgs.push_back("-D_DEBUG");
Hans Wennborgb3574792013-08-08 00:17:41 +00003747 CmdArgs.push_back("-D_MT");
3748 CmdArgs.push_back("-D_DLL");
3749 CmdArgs.push_back("--dependent-lib=msvcrt");
3750 break;
3751 case options::OPT__SLASH_MDd:
3752 CmdArgs.push_back("-D_DEBUG");
3753 CmdArgs.push_back("-D_MT");
3754 CmdArgs.push_back("-D_DLL");
3755 CmdArgs.push_back("--dependent-lib=msvcrtd");
3756 break;
3757 case options::OPT__SLASH_MT:
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00003758 if (Args.hasArg(options::OPT__SLASH_LDd))
3759 CmdArgs.push_back("-D_DEBUG");
Hans Wennborgb3574792013-08-08 00:17:41 +00003760 CmdArgs.push_back("-D_MT");
3761 CmdArgs.push_back("--dependent-lib=libcmt");
3762 break;
3763 case options::OPT__SLASH_MTd:
3764 CmdArgs.push_back("-D_DEBUG");
3765 CmdArgs.push_back("-D_MT");
3766 CmdArgs.push_back("--dependent-lib=libcmtd");
3767 break;
3768 default:
3769 llvm_unreachable("Unexpected option ID.");
3770 }
3771
Reid Klecknera32c5232013-08-08 19:33:10 +00003772 // This provides POSIX compatibility (maps 'open' to '_open'), which most
3773 // users want. The /Za flag to cl.exe turns this off, but it's not
3774 // implemented in clang.
3775 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborgf0f98912013-08-08 19:54:30 +00003776
3777 // FIXME: Make this default for the win32 triple.
3778 CmdArgs.push_back("-cxx-abi");
3779 CmdArgs.push_back("microsoft");
Hans Wennborg708002e2013-08-09 00:32:23 +00003780
3781 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3782 A->render(Args, CmdArgs);
Hans Wennborgb6475522013-09-10 01:07:07 +00003783
3784 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3785 CmdArgs.push_back("-fdiagnostics-format");
3786 CmdArgs.push_back("msvc");
3787 }
Hans Wennborgb3574792013-08-08 00:17:41 +00003788}
3789
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003790void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003791 const InputInfo &Output,
3792 const InputInfoList &Inputs,
3793 const ArgList &Args,
3794 const char *LinkingOutput) const {
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003795 ArgStringList CmdArgs;
3796
3797 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3798 const InputInfo &Input = Inputs[0];
3799
Rafael Espindoladbe80d92010-11-17 22:13:25 +00003800 // Don't warn about "clang -w -c foo.s"
3801 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00003802 // and "clang -emit-llvm -c foo.s"
3803 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindoladbe80d92010-11-17 22:13:25 +00003804
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003805 // Invoke ourselves in -cc1as mode.
3806 //
3807 // FIXME: Implement custom jobs for internal actions.
3808 CmdArgs.push_back("-cc1as");
3809
3810 // Add the "effective" target triple.
3811 CmdArgs.push_back("-triple");
Chad Rosier61ab80a2011-09-20 20:44:06 +00003812 std::string TripleStr =
3813 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003814 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3815
3816 // Set the output mode, we currently only expect to be used as a real
3817 // assembler.
3818 CmdArgs.push_back("-filetype");
3819 CmdArgs.push_back("obj");
3820
Eric Christopher27e2b982012-12-18 00:31:10 +00003821 // Set the main file name, so that debug info works even with
3822 // -save-temps or preprocessed assembly.
3823 CmdArgs.push_back("-main-file-name");
3824 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
3825
Rafael Espindolab330e402013-08-20 22:12:08 +00003826 // Add the target cpu
Rafael Espindola146dbbf2013-08-21 16:39:20 +00003827 const llvm::Triple &Triple = getToolChain().getTriple();
3828 std::string CPU = getCPUName(Args, Triple);
Rafael Espindolab330e402013-08-20 22:12:08 +00003829 if (!CPU.empty()) {
3830 CmdArgs.push_back("-target-cpu");
3831 CmdArgs.push_back(Args.MakeArgString(CPU));
3832 }
3833
Rafael Espindola146dbbf2013-08-21 16:39:20 +00003834 // Add the target features
3835 const Driver &D = getToolChain().getDriver();
3836 getTargetFeatures(D, Triple, Args, CmdArgs);
Jim Grosbachfc308292012-02-10 20:37:10 +00003837
Daniel Dunbar7f6f8c82011-03-17 17:37:29 +00003838 // Ignore explicit -force_cpusubtype_ALL option.
3839 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003840
Eric Christopher8f0a4032012-01-10 00:38:01 +00003841 // Determine the original source input.
3842 const Action *SourceAction = &JA;
3843 while (SourceAction->getKind() != Action::InputClass) {
3844 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3845 SourceAction = SourceAction->getInputs()[0];
3846 }
3847
Chandler Carruthd566df62012-12-17 21:40:04 +00003848 // Forward -g and handle debug info related flags, assuming we are dealing
3849 // with an actual assembly file.
Eric Christopher8f0a4032012-01-10 00:38:01 +00003850 if (SourceAction->getType() == types::TY_Asm ||
3851 SourceAction->getType() == types::TY_PP_Asm) {
3852 Args.ClaimAllArgs(options::OPT_g_Group);
3853 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3854 if (!A->getOption().matches(options::OPT_g0))
3855 CmdArgs.push_back("-g");
Chandler Carruthd566df62012-12-17 21:40:04 +00003856
3857 // Add the -fdebug-compilation-dir flag if needed.
3858 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderby02341792013-01-17 21:38:06 +00003859
3860 // Set the AT_producer to the clang version when using the integrated
3861 // assembler on assembly source files.
3862 CmdArgs.push_back("-dwarf-debug-producer");
3863 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopher8f0a4032012-01-10 00:38:01 +00003864 }
Kevin Enderby567003e2011-12-22 19:31:58 +00003865
3866 // Optionally embed the -cc1as level arguments into the debug info, for build
3867 // analysis.
3868 if (getToolChain().UseDwarfDebugFlags()) {
3869 ArgStringList OriginalArgs;
3870 for (ArgList::const_iterator it = Args.begin(),
3871 ie = Args.end(); it != ie; ++it)
3872 (*it)->render(Args, OriginalArgs);
3873
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00003874 SmallString<256> Flags;
Kevin Enderby567003e2011-12-22 19:31:58 +00003875 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3876 Flags += Exec;
3877 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3878 Flags += " ";
3879 Flags += OriginalArgs[i];
3880 }
3881 CmdArgs.push_back("-dwarf-debug-flags");
3882 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3883 }
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003884
3885 // FIXME: Add -static support, once we have it.
3886
David Blaikie73168db2013-07-25 21:19:01 +00003887 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
3888 getToolChain().getDriver());
3889
Daniel Dunbar3df23252011-04-29 17:53:18 +00003890 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003891
3892 assert(Output.isFilename() && "Unexpected lipo output.");
3893 CmdArgs.push_back("-o");
3894 CmdArgs.push_back(Output.getFilename());
3895
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003896 assert(Input.isFilename() && "Invalid input.");
3897 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003898
Daniel Dunbara001c1c2010-07-18 21:16:15 +00003899 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00003900 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher708d72a2013-04-10 21:30:40 +00003901
3902 // Handle the debug info splitting at object creation time if we're
3903 // creating an object.
3904 // TODO: Currently only works on linux with newer objcopy.
3905 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00003906 getToolChain().getTriple().isOSLinux())
Eric Christopher708d72a2013-04-10 21:30:40 +00003907 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
3908 SplitDebugName(Args, Inputs));
Daniel Dunbar20a9aa52010-05-20 21:30:13 +00003909}
3910
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003911void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003912 const InputInfo &Output,
3913 const InputInfoList &Inputs,
Daniel Dunbar1d460332009-03-18 10:01:51 +00003914 const ArgList &Args,
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003915 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00003916 const Driver &D = getToolChain().getDriver();
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003917 ArgStringList CmdArgs;
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00003918
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003919 for (ArgList::const_iterator
Daniel Dunbar1d460332009-03-18 10:01:51 +00003920 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003921 Arg *A = *it;
Michael J. Spencer91e06da2012-10-19 22:37:06 +00003922 if (forwardToGCC(A->getOption())) {
Daniel Dunbar2dffe2d2010-08-03 16:14:14 +00003923 // Don't forward any -g arguments to assembly steps.
3924 if (isa<AssembleJobAction>(JA) &&
3925 A->getOption().matches(options::OPT_g_Group))
3926 continue;
3927
NAKAMURA Takumi3c6c8222013-08-19 11:51:51 +00003928 // Don't forward any -W arguments to assembly and link steps.
3929 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
3930 A->getOption().matches(options::OPT_W_Group))
3931 continue;
3932
Daniel Dunbar75877192009-03-19 07:55:12 +00003933 // It is unfortunate that we have to claim here, as this means
3934 // we will basically never report anything interesting for
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00003935 // platforms using a generic gcc, even if we are just using gcc
3936 // to get to the assembler.
Daniel Dunbar75877192009-03-19 07:55:12 +00003937 A->claim();
Daniel Dunbar1d460332009-03-18 10:01:51 +00003938 A->render(Args, CmdArgs);
Daniel Dunbar75877192009-03-19 07:55:12 +00003939 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003940 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00003941
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00003942 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003943
3944 // If using a driver driver, force the arch.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00003945 llvm::Triple::ArchType Arch = getToolChain().getArch();
Bob Wilson905c45f2011-10-14 05:03:44 +00003946 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003947 CmdArgs.push_back("-arch");
Daniel Dunbarbf54a062009-04-01 20:33:11 +00003948
3949 // FIXME: Remove these special cases.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00003950 if (Arch == llvm::Triple::ppc)
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00003951 CmdArgs.push_back("ppc");
Rafael Espindola64f7ad92012-10-07 04:44:33 +00003952 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00003953 CmdArgs.push_back("ppc64");
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00003954 else if (Arch == llvm::Triple::ppc64le)
3955 CmdArgs.push_back("ppc64le");
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00003956 else
Rafael Espindola64f7ad92012-10-07 04:44:33 +00003957 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003958 }
3959
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00003960 // Try to force gcc to match the tool chain we want, if we recognize
3961 // the arch.
Daniel Dunbar7cfe31a2009-05-22 02:21:04 +00003962 //
3963 // FIXME: The triple class should directly provide the information we want
3964 // here.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00003965 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00003966 CmdArgs.push_back("-m32");
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00003967 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
3968 Arch == llvm::Triple::ppc64le)
Daniel Dunbar6ecc7a92009-05-02 21:41:52 +00003969 CmdArgs.push_back("-m64");
3970
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00003971 if (Output.isFilename()) {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003972 CmdArgs.push_back("-o");
Daniel Dunbar115a7922009-03-19 07:29:38 +00003973 CmdArgs.push_back(Output.getFilename());
3974 } else {
3975 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003976 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar115a7922009-03-19 07:29:38 +00003977 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003978
Tony Linthicum96319392011-12-12 21:14:55 +00003979 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3980 options::OPT_Xassembler);
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00003981
3982 // Only pass -x if gcc will understand it; otherwise hope gcc
3983 // understands the suffix correctly. The main use case this would go
3984 // wrong in is for linker inputs if they happened to have an odd
3985 // suffix; really the only way to get this to happen is a command
3986 // like '-x foobar a.c' which will treat a.c like a linker input.
3987 //
3988 // FIXME: For the linker case specifically, can we safely convert
3989 // inputs into '-Wl,' options?
3990 for (InputInfoList::const_iterator
3991 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3992 const InputInfo &II = *it;
Daniel Dunbara8304f62009-05-02 20:14:53 +00003993
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00003994 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00003995 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3996 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner5f9e2722011-07-23 10:55:15 +00003997 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00003998 << getToolChain().getTripleString();
Daniel Dunbar5915fbf2009-09-01 16:57:46 +00003999 else if (II.getType() == types::TY_AST)
Chris Lattner5f9e2722011-07-23 10:55:15 +00004000 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar88137642009-09-09 22:32:48 +00004001 << getToolChain().getTripleString();
Douglas Gregorc544ba02013-03-27 16:47:18 +00004002 else if (II.getType() == types::TY_ModuleFile)
4003 D.Diag(diag::err_drv_no_module_support)
4004 << getToolChain().getTripleString();
Daniel Dunbara8304f62009-05-02 20:14:53 +00004005
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004006 if (types::canTypeBeUserSpecified(II.getType())) {
4007 CmdArgs.push_back("-x");
4008 CmdArgs.push_back(types::getTypeName(II.getType()));
4009 }
4010
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004011 if (II.isFilename())
Daniel Dunbar115a7922009-03-19 07:29:38 +00004012 CmdArgs.push_back(II.getFilename());
Daniel Dunbar48f99942010-09-25 18:10:05 +00004013 else {
4014 const Arg &A = II.getInputArg();
4015
4016 // Reverse translate some rewritten options.
4017 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4018 CmdArgs.push_back("-lstdc++");
4019 continue;
4020 }
4021
Daniel Dunbar115a7922009-03-19 07:29:38 +00004022 // Don't render as input, we need gcc to do the translations.
Daniel Dunbar48f99942010-09-25 18:10:05 +00004023 A.render(Args, CmdArgs);
4024 }
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004025 }
4026
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +00004027 const std::string customGCCName = D.getCCCGenericGCCName();
4028 const char *GCCName;
4029 if (!customGCCName.empty())
4030 GCCName = customGCCName.c_str();
Hans Wennborg76b86c22013-07-18 20:29:38 +00004031 else if (D.CCCIsCXX()) {
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +00004032 GCCName = "g++";
Dylan Noblesmithb8a3e812011-04-09 13:31:59 +00004033 } else
4034 GCCName = "gcc";
4035
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004036 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004037 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004038 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00004039}
4040
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004041void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4042 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004043 CmdArgs.push_back("-E");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00004044}
4045
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004046void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4047 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004048 // The type is good enough.
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00004049}
4050
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004051void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4052 ArgStringList &CmdArgs) const {
Daniel Dunbar64952502010-02-11 03:16:21 +00004053 const Driver &D = getToolChain().getDriver();
4054
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004055 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar6c6424b2010-06-07 23:28:45 +00004056 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4057 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004058 CmdArgs.push_back("-c");
Daniel Dunbar64952502010-02-11 03:16:21 +00004059 else {
4060 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner5f9e2722011-07-23 10:55:15 +00004061 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbar64952502010-02-11 03:16:21 +00004062 << getTypeName(JA.getType());
Michael J. Spencer20249a12010-10-21 03:16:25 +00004063
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004064 CmdArgs.push_back("-S");
Daniel Dunbar64952502010-02-11 03:16:21 +00004065 }
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00004066}
4067
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004068void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4069 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004070 CmdArgs.push_back("-c");
Daniel Dunbar47ac7d22009-03-18 06:00:36 +00004071}
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004072
Daniel Dunbar82b51cc2010-01-25 22:35:08 +00004073void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4074 ArgStringList &CmdArgs) const {
Daniel Dunbarb488c1d2009-03-18 08:07:30 +00004075 // The types are (hopefully) good enough.
4076}
4077
Tony Linthicum96319392011-12-12 21:14:55 +00004078// Hexagon tools start.
4079void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4080 ArgStringList &CmdArgs) const {
4081
4082}
4083void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4084 const InputInfo &Output,
4085 const InputInfoList &Inputs,
4086 const ArgList &Args,
4087 const char *LinkingOutput) const {
4088
4089 const Driver &D = getToolChain().getDriver();
4090 ArgStringList CmdArgs;
4091
4092 std::string MarchString = "-march=";
Matthew Curtis67814152012-12-06 14:16:43 +00004093 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum96319392011-12-12 21:14:55 +00004094 CmdArgs.push_back(Args.MakeArgString(MarchString));
4095
4096 RenderExtraToolArgs(JA, CmdArgs);
4097
4098 if (Output.isFilename()) {
4099 CmdArgs.push_back("-o");
4100 CmdArgs.push_back(Output.getFilename());
4101 } else {
4102 assert(Output.isNothing() && "Unexpected output");
4103 CmdArgs.push_back("-fsyntax-only");
4104 }
4105
Matthew Curtis33c95f12012-12-06 17:49:03 +00004106 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4107 if (!SmallDataThreshold.empty())
4108 CmdArgs.push_back(
4109 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum96319392011-12-12 21:14:55 +00004110
Matthew Curtis3d8d4222012-12-07 17:23:04 +00004111 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4112 options::OPT_Xassembler);
4113
Tony Linthicum96319392011-12-12 21:14:55 +00004114 // Only pass -x if gcc will understand it; otherwise hope gcc
4115 // understands the suffix correctly. The main use case this would go
4116 // wrong in is for linker inputs if they happened to have an odd
4117 // suffix; really the only way to get this to happen is a command
4118 // like '-x foobar a.c' which will treat a.c like a linker input.
4119 //
4120 // FIXME: For the linker case specifically, can we safely convert
4121 // inputs into '-Wl,' options?
4122 for (InputInfoList::const_iterator
4123 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4124 const InputInfo &II = *it;
4125
4126 // Don't try to pass LLVM or AST inputs to a generic gcc.
4127 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4128 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4129 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4130 << getToolChain().getTripleString();
4131 else if (II.getType() == types::TY_AST)
4132 D.Diag(clang::diag::err_drv_no_ast_support)
4133 << getToolChain().getTripleString();
Douglas Gregorc544ba02013-03-27 16:47:18 +00004134 else if (II.getType() == types::TY_ModuleFile)
4135 D.Diag(diag::err_drv_no_module_support)
4136 << getToolChain().getTripleString();
Tony Linthicum96319392011-12-12 21:14:55 +00004137
4138 if (II.isFilename())
4139 CmdArgs.push_back(II.getFilename());
4140 else
4141 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4142 II.getInputArg().render(Args, CmdArgs);
4143 }
4144
4145 const char *GCCName = "hexagon-as";
4146 const char *Exec =
4147 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4148 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4149
4150}
4151void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4152 ArgStringList &CmdArgs) const {
4153 // The types are (hopefully) good enough.
4154}
4155
4156void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4157 const InputInfo &Output,
4158 const InputInfoList &Inputs,
4159 const ArgList &Args,
4160 const char *LinkingOutput) const {
4161
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004162 const toolchains::Hexagon_TC& ToolChain =
4163 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4164 const Driver &D = ToolChain.getDriver();
4165
Tony Linthicum96319392011-12-12 21:14:55 +00004166 ArgStringList CmdArgs;
4167
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004168 //----------------------------------------------------------------------------
4169 //
4170 //----------------------------------------------------------------------------
4171 bool hasStaticArg = Args.hasArg(options::OPT_static);
4172 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtis33c95f12012-12-06 17:49:03 +00004173 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004174 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4175 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4176 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4177 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum96319392011-12-12 21:14:55 +00004178
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004179 //----------------------------------------------------------------------------
4180 // Silence warnings for various options
4181 //----------------------------------------------------------------------------
Tony Linthicum96319392011-12-12 21:14:55 +00004182
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004183 Args.ClaimAllArgs(options::OPT_g_Group);
4184 Args.ClaimAllArgs(options::OPT_emit_llvm);
4185 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4186 // handled somewhere else.
4187 Args.ClaimAllArgs(options::OPT_static_libgcc);
4188
4189 //----------------------------------------------------------------------------
4190 //
4191 //----------------------------------------------------------------------------
4192 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4193 e = ToolChain.ExtraOpts.end();
4194 i != e; ++i)
4195 CmdArgs.push_back(i->c_str());
Tony Linthicum96319392011-12-12 21:14:55 +00004196
Matthew Curtis67814152012-12-06 14:16:43 +00004197 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4198 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop43115d42012-01-13 20:37:10 +00004199
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004200 if (buildingLib) {
4201 CmdArgs.push_back("-shared");
4202 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4203 // hexagon-gcc does
Tony Linthicum96319392011-12-12 21:14:55 +00004204 }
4205
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004206 if (hasStaticArg)
4207 CmdArgs.push_back("-static");
Tony Linthicum96319392011-12-12 21:14:55 +00004208
Matthew Curtis33c95f12012-12-06 17:49:03 +00004209 if (buildPIE && !buildingLib)
4210 CmdArgs.push_back("-pie");
4211
4212 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4213 if (!SmallDataThreshold.empty()) {
4214 CmdArgs.push_back(
4215 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4216 }
4217
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004218 //----------------------------------------------------------------------------
4219 //
4220 //----------------------------------------------------------------------------
4221 CmdArgs.push_back("-o");
4222 CmdArgs.push_back(Output.getFilename());
Tony Linthicum96319392011-12-12 21:14:55 +00004223
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004224 const std::string MarchSuffix = "/" + MarchString;
4225 const std::string G0Suffix = "/G0";
4226 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4227 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4228 + "/";
4229 const std::string StartFilesDir = RootDir
4230 + "hexagon/lib"
4231 + (buildingLib
4232 ? MarchG0Suffix : MarchSuffix);
4233
4234 //----------------------------------------------------------------------------
4235 // moslib
4236 //----------------------------------------------------------------------------
4237 std::vector<std::string> oslibs;
4238 bool hasStandalone= false;
4239
4240 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4241 ie = Args.filtered_end(); it != ie; ++it) {
4242 (*it)->claim();
4243 oslibs.push_back((*it)->getValue());
4244 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum96319392011-12-12 21:14:55 +00004245 }
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004246 if (oslibs.empty()) {
4247 oslibs.push_back("standalone");
4248 hasStandalone = true;
4249 }
Tony Linthicum96319392011-12-12 21:14:55 +00004250
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004251 //----------------------------------------------------------------------------
4252 // Start Files
4253 //----------------------------------------------------------------------------
4254 if (incStdLib && incStartFiles) {
4255
4256 if (!buildingLib) {
4257 if (hasStandalone) {
4258 CmdArgs.push_back(
4259 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4260 }
4261 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4262 }
4263 std::string initObj = useShared ? "/initS.o" : "/init.o";
4264 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4265 }
4266
4267 //----------------------------------------------------------------------------
4268 // Library Search Paths
4269 //----------------------------------------------------------------------------
4270 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4271 for (ToolChain::path_list::const_iterator
4272 i = LibPaths.begin(),
4273 e = LibPaths.end();
4274 i != e;
4275 ++i)
4276 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4277
4278 //----------------------------------------------------------------------------
4279 //
4280 //----------------------------------------------------------------------------
4281 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4282 Args.AddAllArgs(CmdArgs, options::OPT_e);
4283 Args.AddAllArgs(CmdArgs, options::OPT_s);
4284 Args.AddAllArgs(CmdArgs, options::OPT_t);
4285 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4286
4287 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4288
4289 //----------------------------------------------------------------------------
4290 // Libraries
4291 //----------------------------------------------------------------------------
4292 if (incStdLib && incDefLibs) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00004293 if (D.CCCIsCXX()) {
Matthew Curtis5fdf3502012-12-06 15:46:07 +00004294 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4295 CmdArgs.push_back("-lm");
4296 }
4297
4298 CmdArgs.push_back("--start-group");
4299
4300 if (!buildingLib) {
4301 for(std::vector<std::string>::iterator i = oslibs.begin(),
4302 e = oslibs.end(); i != e; ++i)
4303 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4304 CmdArgs.push_back("-lc");
4305 }
4306 CmdArgs.push_back("-lgcc");
4307
4308 CmdArgs.push_back("--end-group");
4309 }
4310
4311 //----------------------------------------------------------------------------
4312 // End files
4313 //----------------------------------------------------------------------------
4314 if (incStdLib && incStartFiles) {
4315 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4316 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4317 }
4318
4319 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4320 C.addCommand(
4321 new Command(
4322 JA, *this,
4323 Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum96319392011-12-12 21:14:55 +00004324}
4325// Hexagon tools end.
4326
Rafael Espindolacfed8282012-10-31 18:51:07 +00004327llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4328 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4329 // archs which Darwin doesn't use.
4330
4331 // The matching this routine does is fairly pointless, since it is neither the
4332 // complete architecture list, nor a reasonable subset. The problem is that
4333 // historically the driver driver accepts this and also ties its -march=
4334 // handling to the architecture name, so we need to be careful before removing
4335 // support for it.
4336
4337 // This code must be kept in sync with Clang's Darwin specific argument
4338 // translation.
4339
4340 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4341 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4342 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4343 .Case("ppc64", llvm::Triple::ppc64)
4344 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4345 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4346 llvm::Triple::x86)
4347 .Case("x86_64", llvm::Triple::x86_64)
4348 // This is derived from the driver driver.
Bob Wilson2503ebd2013-03-04 22:37:49 +00004349 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4350 .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4351 .Cases("armv7s", "xscale", llvm::Triple::arm)
Rafael Espindolacfed8282012-10-31 18:51:07 +00004352 .Case("r600", llvm::Triple::r600)
4353 .Case("nvptx", llvm::Triple::nvptx)
4354 .Case("nvptx64", llvm::Triple::nvptx64)
4355 .Case("amdil", llvm::Triple::amdil)
4356 .Case("spir", llvm::Triple::spir)
4357 .Default(llvm::Triple::UnknownArch);
4358}
Tony Linthicum96319392011-12-12 21:14:55 +00004359
Bob Wilson66b8a662012-11-23 06:14:39 +00004360const char *Clang::getBaseInputName(const ArgList &Args,
4361 const InputInfoList &Inputs) {
Michael J. Spencer472ccff2010-12-18 00:19:12 +00004362 return Args.MakeArgString(
4363 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004364}
4365
Bob Wilson66b8a662012-11-23 06:14:39 +00004366const char *Clang::getBaseInputStem(const ArgList &Args,
4367 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004368 const char *Str = getBaseInputName(Args, Inputs);
4369
Chris Lattner657ca662011-01-16 08:14:11 +00004370 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar88137642009-09-09 22:32:48 +00004371 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004372
4373 return Str;
4374}
4375
Bob Wilson66b8a662012-11-23 06:14:39 +00004376const char *Clang::getDependencyFileName(const ArgList &Args,
4377 const InputInfoList &Inputs) {
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004378 // FIXME: Think about this more.
4379 std::string Res;
4380
4381 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smith1d489cf2012-11-01 04:30:05 +00004382 std::string Str(OutputOpt->getValue());
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004383 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier30601782011-08-17 23:08:45 +00004384 } else {
Bob Wilson66b8a662012-11-23 06:14:39 +00004385 Res = getBaseInputStem(Args, Inputs);
Chad Rosier30601782011-08-17 23:08:45 +00004386 }
Daniel Dunbar88137642009-09-09 22:32:48 +00004387 return Args.MakeArgString(Res + ".d");
Daniel Dunbara3ec60e2009-03-29 18:40:18 +00004388}
4389
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004390void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004391 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004392 const InputInfoList &Inputs,
4393 const ArgList &Args,
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004394 const char *LinkingOutput) const {
4395 ArgStringList CmdArgs;
4396
4397 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4398 const InputInfo &Input = Inputs[0];
4399
Daniel Dunbar34bac1f2011-04-12 23:59:20 +00004400 // Determine the original source input.
4401 const Action *SourceAction = &JA;
4402 while (SourceAction->getKind() != Action::InputClass) {
4403 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4404 SourceAction = SourceAction->getInputs()[0];
4405 }
4406
4407 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher88b7cf02011-08-19 00:30:14 +00004408 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbar34bac1f2011-04-12 23:59:20 +00004409 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar8e4fea62009-04-01 00:27:44 +00004410 if (Args.hasArg(options::OPT_gstabs))
4411 CmdArgs.push_back("--gstabs");
4412 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson591ff152011-11-02 05:10:45 +00004413 CmdArgs.push_back("-g");
Daniel Dunbar8e4fea62009-04-01 00:27:44 +00004414 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004415
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004416 // Derived from asm spec.
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00004417 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004418
Daniel Dunbarf5438e32010-07-22 01:47:22 +00004419 // Use -force_cpusubtype_ALL on x86 by default.
Eli Bendersky8f4269a2013-07-24 22:20:49 +00004420 if (getToolChain().getArch() == llvm::Triple::x86 ||
4421 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbarcc6f8032009-09-09 18:36:27 +00004422 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4423 CmdArgs.push_back("-force_cpusubtype_ALL");
4424
Eli Bendersky8f4269a2013-07-24 22:20:49 +00004425 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbar7a0c0642012-10-15 22:23:53 +00004426 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher59320e72013-02-21 22:35:01 +00004427 Args.hasArg(options::OPT_fapple_kext)) &&
Daniel Dunbar7a0c0642012-10-15 22:23:53 +00004428 (!getDarwinToolChain().isTargetIPhoneOS() ||
4429 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4430 Args.hasArg(options::OPT_static)))
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004431 CmdArgs.push_back("-static");
4432
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004433 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4434 options::OPT_Xassembler);
4435
4436 assert(Output.isFilename() && "Unexpected lipo output.");
4437 CmdArgs.push_back("-o");
4438 CmdArgs.push_back(Output.getFilename());
4439
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00004440 assert(Input.isFilename() && "Invalid input.");
4441 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004442
4443 // asm_final spec is empty.
4444
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004445 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004446 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004447 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8cac5f72009-03-20 16:06:39 +00004448}
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004449
David Blaikie99ba9e32011-12-20 02:48:34 +00004450void darwin::DarwinTool::anchor() {}
4451
Daniel Dunbarfbefe6b2009-09-09 18:36:20 +00004452void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4453 ArgStringList &CmdArgs) const {
Chris Lattner5f9e2722011-07-23 10:55:15 +00004454 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
Daniel Dunbareeff4062010-01-22 02:04:58 +00004455
Daniel Dunbar02633b52009-03-26 16:23:12 +00004456 // Derived from darwin_arch spec.
4457 CmdArgs.push_back("-arch");
Daniel Dunbareeff4062010-01-22 02:04:58 +00004458 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar78dbd582009-09-04 18:35:31 +00004459
Daniel Dunbareeff4062010-01-22 02:04:58 +00004460 // FIXME: Is this needed anymore?
4461 if (ArchName == "arm")
Daniel Dunbar78dbd582009-09-04 18:35:31 +00004462 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbar02633b52009-03-26 16:23:12 +00004463}
4464
Bill Wendling6acf8b42012-10-02 18:02:50 +00004465bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4466 // We only need to generate a temp path for LTO if we aren't compiling object
4467 // files. When compiling source files, we run 'dsymutil' after linking. We
4468 // don't run 'dsymutil' when compiling object files.
4469 for (InputInfoList::const_iterator
4470 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4471 if (it->getType() != types::TY_Object)
4472 return true;
4473
4474 return false;
4475}
4476
Daniel Dunbar748de8e2010-09-09 21:51:05 +00004477void darwin::Link::AddLinkArgs(Compilation &C,
4478 const ArgList &Args,
Bill Wendling6acf8b42012-10-02 18:02:50 +00004479 ArgStringList &CmdArgs,
4480 const InputInfoList &Inputs) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00004481 const Driver &D = getToolChain().getDriver();
Daniel Dunbarce911f52011-04-28 21:23:41 +00004482 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
Daniel Dunbar02633b52009-03-26 16:23:12 +00004483
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00004484 unsigned Version[3] = { 0, 0, 0 };
4485 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4486 bool HadExtra;
Richard Smith1d489cf2012-11-01 04:30:05 +00004487 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00004488 Version[1], Version[2], HadExtra) ||
4489 HadExtra)
Chris Lattner5f9e2722011-07-23 10:55:15 +00004490 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00004491 << A->getAsString(Args);
4492 }
4493
4494 // Newer linkers support -demangle, pass it if supported and not disabled by
4495 // the user.
Daniel Dunbard2d20882012-01-04 21:45:27 +00004496 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00004497 // Don't pass -demangle to ld_classic.
4498 //
4499 // FIXME: This is a temporary workaround, ld should be handling this.
4500 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4501 Args.hasArg(options::OPT_static));
Daniel Dunbar9ced7042010-09-07 17:50:41 +00004502 if (getToolChain().getArch() == llvm::Triple::x86) {
4503 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4504 options::OPT_Wl_COMMA),
4505 ie = Args.filtered_end(); it != ie; ++it) {
4506 const Arg *A = *it;
4507 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smith1d489cf2012-11-01 04:30:05 +00004508 if (StringRef(A->getValue(i)) == "-kext")
Daniel Dunbar9ced7042010-09-07 17:50:41 +00004509 UsesLdClassic = true;
4510 }
4511 }
Daniel Dunbarbcf1da82010-09-07 17:07:49 +00004512 if (!UsesLdClassic)
4513 CmdArgs.push_back("-demangle");
Daniel Dunbarb18dc5b2010-08-11 23:07:50 +00004514 }
4515
Bob Wilsonbd77c592013-08-02 22:25:34 +00004516 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4517 CmdArgs.push_back("-export_dynamic");
4518
Bill Wendlingc35f9082012-11-16 23:03:00 +00004519 // If we are using LTO, then automatically create a temporary file path for
4520 // the linker to use, so that it's lifetime will extend past a possible
4521 // dsymutil step.
4522 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4523 const char *TmpPath = C.getArgs().MakeArgString(
4524 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4525 C.addTempFile(TmpPath);
4526 CmdArgs.push_back("-object_path_lto");
4527 CmdArgs.push_back(TmpPath);
Daniel Dunbar5bfa6562011-06-21 20:55:11 +00004528 }
4529
Daniel Dunbar02633b52009-03-26 16:23:12 +00004530 // Derived from the "link" spec.
4531 Args.AddAllArgs(CmdArgs, options::OPT_static);
4532 if (!Args.hasArg(options::OPT_static))
4533 CmdArgs.push_back("-dynamic");
4534 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4535 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4536 // here. How do we wish to handle such things?
4537 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004538
Daniel Dunbar02633b52009-03-26 16:23:12 +00004539 if (!Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbara6d38492010-01-22 02:04:52 +00004540 AddDarwinArch(Args, CmdArgs);
Daniel Dunbara6d38492010-01-22 02:04:52 +00004541 // FIXME: Why do this only on this path?
Daniel Dunbar8917dd42010-01-22 03:37:33 +00004542 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004543
4544 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4545 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4546 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4547
4548 Arg *A;
4549 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4550 (A = Args.getLastArg(options::OPT_current__version)) ||
4551 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner5f9e2722011-07-23 10:55:15 +00004552 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbar02633b52009-03-26 16:23:12 +00004553 << A->getAsString(Args) << "-dynamiclib";
4554
4555 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4556 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4557 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4558 } else {
4559 CmdArgs.push_back("-dylib");
4560
4561 Arg *A;
4562 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4563 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4564 (A = Args.getLastArg(options::OPT_client__name)) ||
4565 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4566 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4567 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner5f9e2722011-07-23 10:55:15 +00004568 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar02633b52009-03-26 16:23:12 +00004569 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004570
Daniel Dunbar02633b52009-03-26 16:23:12 +00004571 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4572 "-dylib_compatibility_version");
4573 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4574 "-dylib_current_version");
4575
Daniel Dunbara6d38492010-01-22 02:04:52 +00004576 AddDarwinArch(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004577
4578 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4579 "-dylib_install_name");
4580 }
4581
4582 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4583 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4584 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Daniel Dunbarce911f52011-04-28 21:23:41 +00004585 if (DarwinTC.isTargetIPhoneOS())
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00004586 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004587 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4588 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4589 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4590 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4591 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4592 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar99ca47b2011-06-28 20:16:02 +00004593 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004594 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4595 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4596 Args.AddAllArgs(CmdArgs, options::OPT_init);
4597
Daniel Dunbarce911f52011-04-28 21:23:41 +00004598 // Add the deployment target.
Benjamin Kramer09c9a562012-03-10 20:55:36 +00004599 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
Daniel Dunbarb7f5ef72011-04-30 04:22:58 +00004600
4601 // If we had an explicit -mios-simulator-version-min argument, honor that,
4602 // otherwise use the traditional deployment targets. We can't just check the
4603 // is-sim attribute because existing code follows this path, and the linker
4604 // may not handle the argument.
4605 //
4606 // FIXME: We may be able to remove this, once we can verify no one depends on
4607 // it.
4608 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4609 CmdArgs.push_back("-ios_simulator_version_min");
4610 else if (DarwinTC.isTargetIPhoneOS())
4611 CmdArgs.push_back("-iphoneos_version_min");
4612 else
4613 CmdArgs.push_back("-macosx_version_min");
Benjamin Kramer09c9a562012-03-10 20:55:36 +00004614 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
Daniel Dunbarce911f52011-04-28 21:23:41 +00004615
Daniel Dunbar02633b52009-03-26 16:23:12 +00004616 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4617 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4618 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4619 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4620 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004621
Daniel Dunbar47e879d2010-07-13 23:31:40 +00004622 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4623 options::OPT_fno_pie,
4624 options::OPT_fno_PIE)) {
4625 if (A->getOption().matches(options::OPT_fpie) ||
4626 A->getOption().matches(options::OPT_fPIE))
4627 CmdArgs.push_back("-pie");
4628 else
4629 CmdArgs.push_back("-no_pie");
4630 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00004631
4632 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4633 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4634 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4635 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4636 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4637 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4638 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4639 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4640 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4641 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4642 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4643 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4644 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4645 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4646 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4647 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00004648
Daniel Dunbarcc957192011-05-02 21:03:47 +00004649 // Give --sysroot= preference, over the Apple specific behavior to also use
4650 // --isysroot as the syslibroot.
Sebastian Pop4762a2d2012-04-16 04:16:43 +00004651 StringRef sysroot = C.getSysRoot();
4652 if (sysroot != "") {
Daniel Dunbarcc957192011-05-02 21:03:47 +00004653 CmdArgs.push_back("-syslibroot");
Sebastian Pop4762a2d2012-04-16 04:16:43 +00004654 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbarcc957192011-05-02 21:03:47 +00004655 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4656 CmdArgs.push_back("-syslibroot");
Richard Smith1d489cf2012-11-01 04:30:05 +00004657 CmdArgs.push_back(A->getValue());
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00004658 }
4659
Daniel Dunbar02633b52009-03-26 16:23:12 +00004660 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4661 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4662 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4663 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4664 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbard82f8fa2009-09-04 18:35:41 +00004665 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004666 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4667 Args.AddAllArgs(CmdArgs, options::OPT_y);
4668 Args.AddLastArg(CmdArgs, options::OPT_w);
4669 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4670 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4671 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4672 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4673 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4674 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4675 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4676 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4677 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4678 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4679 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4680 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4681}
4682
4683void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004684 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004685 const InputInfoList &Inputs,
4686 const ArgList &Args,
Daniel Dunbar02633b52009-03-26 16:23:12 +00004687 const char *LinkingOutput) const {
4688 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbare0be8b12009-09-08 16:39:16 +00004689
Daniel Dunbar02633b52009-03-26 16:23:12 +00004690 // The logic here is derived from gcc's behavior; most of which
4691 // comes from specs (starting with link_command). Consult gcc for
4692 // more information.
Daniel Dunbar02633b52009-03-26 16:23:12 +00004693 ArgStringList CmdArgs;
4694
Argyrios Kyrtzidis22897172011-10-07 22:58:08 +00004695 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4696 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4697 options::OPT_ccc_arcmt_migrate)) {
4698 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4699 (*I)->claim();
4700 const char *Exec =
4701 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4702 CmdArgs.push_back(Output.getFilename());
4703 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4704 return;
4705 }
4706
Daniel Dunbar02633b52009-03-26 16:23:12 +00004707 // I'm not sure why this particular decomposition exists in gcc, but
4708 // we follow suite for ease of comparison.
Bill Wendling6acf8b42012-10-02 18:02:50 +00004709 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004710
Daniel Dunbar02633b52009-03-26 16:23:12 +00004711 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4712 Args.AddAllArgs(CmdArgs, options::OPT_s);
4713 Args.AddAllArgs(CmdArgs, options::OPT_t);
4714 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4715 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004716 Args.AddLastArg(CmdArgs, options::OPT_e);
4717 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4718 Args.AddAllArgs(CmdArgs, options::OPT_r);
4719
Daniel Dunbar270073c2010-10-18 22:08:36 +00004720 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4721 // members of static archive libraries which implement Objective-C classes or
4722 // categories.
4723 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4724 CmdArgs.push_back("-ObjC");
Michael J. Spencer20249a12010-10-21 03:16:25 +00004725
Daniel Dunbar02633b52009-03-26 16:23:12 +00004726 CmdArgs.push_back("-o");
4727 CmdArgs.push_back(Output.getFilename());
4728
Chad Rosier18937312012-05-16 23:45:12 +00004729 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbar02633b52009-03-26 16:23:12 +00004730 !Args.hasArg(options::OPT_nostartfiles)) {
4731 // Derived from startfile spec.
4732 if (Args.hasArg(options::OPT_dynamiclib)) {
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004733 // Derived from darwin_dylib1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00004734 if (getDarwinToolChain().isTargetIOSSimulator()) {
4735 // The simulator doesn't have a versioned crt1 file.
4736 CmdArgs.push_back("-ldylib1.o");
4737 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004738 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4739 CmdArgs.push_back("-ldylib1.o");
4740 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004741 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004742 CmdArgs.push_back("-ldylib1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004743 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004744 CmdArgs.push_back("-ldylib1.10.5.o");
4745 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00004746 } else {
4747 if (Args.hasArg(options::OPT_bundle)) {
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00004748 if (!Args.hasArg(options::OPT_static)) {
4749 // Derived from darwin_bundle1 spec.
Daniel Dunbar1051fc02011-04-01 21:02:42 +00004750 if (getDarwinToolChain().isTargetIOSSimulator()) {
4751 // The simulator doesn't have a versioned crt1 file.
4752 CmdArgs.push_back("-lbundle1.o");
4753 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004754 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4755 CmdArgs.push_back("-lbundle1.o");
4756 } else {
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004757 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004758 CmdArgs.push_back("-lbundle1.o");
4759 }
Daniel Dunbar8a8d8af2009-04-01 03:17:40 +00004760 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00004761 } else {
Daniel Dunbarbbe8e3e2011-03-01 18:49:30 +00004762 if (Args.hasArg(options::OPT_pg) &&
4763 getToolChain().SupportsProfiling()) {
Daniel Dunbar02633b52009-03-26 16:23:12 +00004764 if (Args.hasArg(options::OPT_static) ||
4765 Args.hasArg(options::OPT_object) ||
4766 Args.hasArg(options::OPT_preload)) {
4767 CmdArgs.push_back("-lgcrt0.o");
4768 } else {
4769 CmdArgs.push_back("-lgcrt1.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004770
Daniel Dunbar02633b52009-03-26 16:23:12 +00004771 // darwin_crt2 spec is empty.
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004772 }
Bob Wilson4e6e7912012-07-04 00:18:41 +00004773 // By default on OS X 10.8 and later, we don't link with a crt1.o
4774 // file and the linker knows to use _main as the entry point. But,
4775 // when compiling with -pg, we need to link with the gcrt1.o file,
4776 // so pass the -no_new_main option to tell the linker to use the
4777 // "start" symbol as the entry point.
Bob Wilson1fc6e4f2012-07-03 20:42:10 +00004778 if (getDarwinToolChain().isTargetMacOS() &&
4779 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4780 CmdArgs.push_back("-no_new_main");
Daniel Dunbar02633b52009-03-26 16:23:12 +00004781 } else {
4782 if (Args.hasArg(options::OPT_static) ||
4783 Args.hasArg(options::OPT_object) ||
4784 Args.hasArg(options::OPT_preload)) {
4785 CmdArgs.push_back("-lcrt0.o");
4786 } else {
4787 // Derived from darwin_crt1 spec.
Daniel Dunbar40355802011-03-31 17:12:33 +00004788 if (getDarwinToolChain().isTargetIOSSimulator()) {
4789 // The simulator doesn't have a versioned crt1 file.
4790 CmdArgs.push_back("-lcrt1.o");
4791 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004792 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4793 CmdArgs.push_back("-lcrt1.o");
Daniel Dunbar7a0c0642012-10-15 22:23:53 +00004794 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
Daniel Dunbarcacb0f02010-01-27 00:56:56 +00004795 CmdArgs.push_back("-lcrt1.3.1.o");
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004796 } else {
4797 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4798 CmdArgs.push_back("-lcrt1.o");
4799 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4800 CmdArgs.push_back("-lcrt1.10.5.o");
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004801 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004802 CmdArgs.push_back("-lcrt1.10.6.o");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004803
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004804 // darwin_crt2 spec is empty.
4805 }
Daniel Dunbar02633b52009-03-26 16:23:12 +00004806 }
4807 }
4808 }
4809 }
4810
Daniel Dunbarce3fdf22010-01-27 00:57:03 +00004811 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4812 Args.hasArg(options::OPT_shared_libgcc) &&
4813 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
Daniel Dunbar88137642009-09-09 22:32:48 +00004814 const char *Str =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004815 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
Daniel Dunbar88137642009-09-09 22:32:48 +00004816 CmdArgs.push_back(Str);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004817 }
4818 }
4819
4820 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004821
Daniel Dunbar02633b52009-03-26 16:23:12 +00004822 if (Args.hasArg(options::OPT_fopenmp))
4823 // This is more complicated in gcc...
4824 CmdArgs.push_back("-lgomp");
4825
Douglas Gregor04e326b2012-05-15 21:00:27 +00004826 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4827
Bob Wilson63d9f3c2012-05-15 18:57:39 +00004828 if (isObjCRuntimeLinked(Args) &&
4829 !Args.hasArg(options::OPT_nostdlib) &&
4830 !Args.hasArg(options::OPT_nodefaultlibs)) {
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004831 // Avoid linking compatibility stubs on i386 mac.
4832 if (!getDarwinToolChain().isTargetMacOS() ||
Rafael Espindola64f7ad92012-10-07 04:44:33 +00004833 getDarwinToolChain().getArch() != llvm::Triple::x86) {
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004834 // If we don't have ARC or subscripting runtime support, link in the
4835 // runtime stubs. We have to do this *before* adding any of the normal
4836 // linker inputs so that its initializer gets run first.
John McCall260611a2012-06-20 06:18:46 +00004837 ObjCRuntime runtime =
4838 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004839 // We use arclite library for both ARC and subscripting support.
John McCall0a7dd782012-08-21 02:47:43 +00004840 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
John McCall260611a2012-06-20 06:18:46 +00004841 !runtime.hasSubscripting())
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004842 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004843 }
Bob Wilson0b1c7152012-04-21 00:21:42 +00004844 CmdArgs.push_back("-framework");
4845 CmdArgs.push_back("Foundation");
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004846 // Link libobj.
4847 CmdArgs.push_back("-lobjc");
John McCall9f084a32011-07-06 00:26:06 +00004848 }
John McCallf85e1932011-06-15 23:02:42 +00004849
Daniel Dunbar02633b52009-03-26 16:23:12 +00004850 if (LinkingOutput) {
4851 CmdArgs.push_back("-arch_multiple");
4852 CmdArgs.push_back("-final_output");
4853 CmdArgs.push_back(LinkingOutput);
4854 }
4855
Daniel Dunbar02633b52009-03-26 16:23:12 +00004856 if (Args.hasArg(options::OPT_fnested_functions))
4857 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004858
Daniel Dunbar02633b52009-03-26 16:23:12 +00004859 if (!Args.hasArg(options::OPT_nostdlib) &&
4860 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00004861 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar132e35d2010-09-17 01:20:05 +00004862 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbaredfa02b2009-04-08 06:06:21 +00004863
Daniel Dunbar02633b52009-03-26 16:23:12 +00004864 // link_ssp spec is empty.
4865
Daniel Dunbar6cd41542009-09-18 08:15:03 +00004866 // Let the tool chain choose which runtime library to link.
4867 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbar02633b52009-03-26 16:23:12 +00004868 }
4869
Chad Rosier18937312012-05-16 23:45:12 +00004870 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbar02633b52009-03-26 16:23:12 +00004871 !Args.hasArg(options::OPT_nostartfiles)) {
4872 // endfile_spec is empty.
4873 }
4874
4875 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4876 Args.AddAllArgs(CmdArgs, options::OPT_F);
4877
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004878 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004879 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004880 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar02633b52009-03-26 16:23:12 +00004881}
4882
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004883void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004884 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004885 const InputInfoList &Inputs,
4886 const ArgList &Args,
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004887 const char *LinkingOutput) const {
4888 ArgStringList CmdArgs;
4889
4890 CmdArgs.push_back("-create");
4891 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbara428df82009-03-24 00:24:37 +00004892
4893 CmdArgs.push_back("-output");
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004894 CmdArgs.push_back(Output.getFilename());
Daniel Dunbara428df82009-03-24 00:24:37 +00004895
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004896 for (InputInfoList::const_iterator
4897 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4898 const InputInfo &II = *it;
4899 assert(II.isFilename() && "Unexpected lipo input.");
4900 CmdArgs.push_back(II.getFilename());
4901 }
Daniel Dunbarc21c4852009-04-08 23:54:23 +00004902 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004903 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004904 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarff7488d2009-03-20 00:52:38 +00004905}
Daniel Dunbar68a31d42009-03-31 17:45:15 +00004906
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00004907void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004908 const InputInfo &Output,
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00004909 const InputInfoList &Inputs,
4910 const ArgList &Args,
4911 const char *LinkingOutput) const {
4912 ArgStringList CmdArgs;
4913
Daniel Dunbar03e92302011-05-09 17:23:16 +00004914 CmdArgs.push_back("-o");
4915 CmdArgs.push_back(Output.getFilename());
4916
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00004917 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4918 const InputInfo &Input = Inputs[0];
4919 assert(Input.isFilename() && "Unexpected dsymutil input.");
4920 CmdArgs.push_back(Input.getFilename());
4921
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00004922 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00004923 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00004924 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar6e0f2542010-06-04 18:28:36 +00004925}
4926
Eric Christopherf8571862011-08-23 17:56:55 +00004927void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher27e2b982012-12-18 00:31:10 +00004928 const InputInfo &Output,
4929 const InputInfoList &Inputs,
4930 const ArgList &Args,
4931 const char *LinkingOutput) const {
Eric Christopherf8571862011-08-23 17:56:55 +00004932 ArgStringList CmdArgs;
4933 CmdArgs.push_back("--verify");
Eric Christopher1c79dc42012-02-06 19:13:09 +00004934 CmdArgs.push_back("--debug-info");
4935 CmdArgs.push_back("--eh-frame");
Eric Christopherb822f722012-02-06 19:43:51 +00004936 CmdArgs.push_back("--quiet");
Eric Christopherf8571862011-08-23 17:56:55 +00004937
4938 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4939 const InputInfo &Input = Inputs[0];
4940 assert(Input.isFilename() && "Unexpected verify input");
4941
4942 // Grabbing the output of the earlier dsymutil run.
4943 CmdArgs.push_back(Input.getFilename());
4944
4945 const char *Exec =
4946 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4947 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4948}
4949
David Chisnall31c46902012-02-15 13:39:01 +00004950void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4951 const InputInfo &Output,
4952 const InputInfoList &Inputs,
4953 const ArgList &Args,
4954 const char *LinkingOutput) const {
4955 ArgStringList CmdArgs;
4956
4957 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4958 options::OPT_Xassembler);
4959
4960 CmdArgs.push_back("-o");
4961 CmdArgs.push_back(Output.getFilename());
4962
4963 for (InputInfoList::const_iterator
4964 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4965 const InputInfo &II = *it;
4966 CmdArgs.push_back(II.getFilename());
4967 }
4968
4969 const char *Exec =
4970 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4971 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4972}
4973
4974
4975void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4976 const InputInfo &Output,
4977 const InputInfoList &Inputs,
4978 const ArgList &Args,
4979 const char *LinkingOutput) const {
4980 // FIXME: Find a real GCC, don't hard-code versions here
4981 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4982 const llvm::Triple &T = getToolChain().getTriple();
4983 std::string LibPath = "/usr/lib/";
4984 llvm::Triple::ArchType Arch = T.getArch();
4985 switch (Arch) {
4986 case llvm::Triple::x86:
4987 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4988 T.getOSName()).str() + "/4.5.2/";
4989 break;
4990 case llvm::Triple::x86_64:
4991 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4992 T.getOSName()).str();
4993 GCCLibPath += "/4.5.2/amd64/";
4994 LibPath += "amd64/";
4995 break;
4996 default:
4997 assert(0 && "Unsupported architecture");
4998 }
4999
5000 ArgStringList CmdArgs;
5001
David Chisnall41d476d2012-02-29 15:06:12 +00005002 // Demangle C++ names in errors
5003 CmdArgs.push_back("-C");
5004
David Chisnall31c46902012-02-15 13:39:01 +00005005 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5006 (!Args.hasArg(options::OPT_shared))) {
5007 CmdArgs.push_back("-e");
5008 CmdArgs.push_back("_start");
5009 }
5010
5011 if (Args.hasArg(options::OPT_static)) {
5012 CmdArgs.push_back("-Bstatic");
5013 CmdArgs.push_back("-dn");
5014 } else {
5015 CmdArgs.push_back("-Bdynamic");
5016 if (Args.hasArg(options::OPT_shared)) {
5017 CmdArgs.push_back("-shared");
5018 } else {
5019 CmdArgs.push_back("--dynamic-linker");
5020 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5021 }
5022 }
5023
5024 if (Output.isFilename()) {
5025 CmdArgs.push_back("-o");
5026 CmdArgs.push_back(Output.getFilename());
5027 } else {
5028 assert(Output.isNothing() && "Invalid output.");
5029 }
5030
5031 if (!Args.hasArg(options::OPT_nostdlib) &&
5032 !Args.hasArg(options::OPT_nostartfiles)) {
5033 if (!Args.hasArg(options::OPT_shared)) {
5034 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5035 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall165329c2012-02-28 17:10:04 +00005036 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnall31c46902012-02-15 13:39:01 +00005037 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5038 } else {
5039 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall165329c2012-02-28 17:10:04 +00005040 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5041 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnall31c46902012-02-15 13:39:01 +00005042 }
Hans Wennborg76b86c22013-07-18 20:29:38 +00005043 if (getToolChain().getDriver().CCCIsCXX())
David Chisnalle6dd6832012-03-13 14:14:54 +00005044 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnall31c46902012-02-15 13:39:01 +00005045 }
5046
5047 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5048
5049 Args.AddAllArgs(CmdArgs, options::OPT_L);
5050 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5051 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall165329c2012-02-28 17:10:04 +00005052 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnall31c46902012-02-15 13:39:01 +00005053
5054 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5055
5056 if (!Args.hasArg(options::OPT_nostdlib) &&
5057 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00005058 if (getToolChain().getDriver().CCCIsCXX())
David Chisnalle58e6f92012-04-10 11:49:50 +00005059 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnallb6229592012-02-15 18:24:31 +00005060 CmdArgs.push_back("-lgcc_s");
David Chisnall165329c2012-02-28 17:10:04 +00005061 if (!Args.hasArg(options::OPT_shared)) {
5062 CmdArgs.push_back("-lgcc");
David Chisnall31c46902012-02-15 13:39:01 +00005063 CmdArgs.push_back("-lc");
David Chisnall7dbefe12012-02-28 20:06:45 +00005064 CmdArgs.push_back("-lm");
David Chisnall165329c2012-02-28 17:10:04 +00005065 }
David Chisnall31c46902012-02-15 13:39:01 +00005066 }
5067
5068 if (!Args.hasArg(options::OPT_nostdlib) &&
5069 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall165329c2012-02-28 17:10:04 +00005070 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnall31c46902012-02-15 13:39:01 +00005071 }
David Chisnalld1ac03e2012-02-16 16:00:47 +00005072 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnall31c46902012-02-15 13:39:01 +00005073
5074 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5075
5076 const char *Exec =
5077 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5078 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5079}
5080
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005081void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005082 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00005083 const InputInfoList &Inputs,
5084 const ArgList &Args,
5085 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005086 ArgStringList CmdArgs;
5087
5088 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5089 options::OPT_Xassembler);
5090
5091 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005092 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005093
5094 for (InputInfoList::const_iterator
5095 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5096 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005097 CmdArgs.push_back(II.getFilename());
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005098 }
5099
5100 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005101 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005102 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005103}
5104
5105void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005106 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00005107 const InputInfoList &Inputs,
5108 const ArgList &Args,
5109 const char *LinkingOutput) const {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005110 ArgStringList CmdArgs;
5111
5112 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00005113 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005114 CmdArgs.push_back("-e");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00005115 CmdArgs.push_back("_start");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005116 }
5117
5118 if (Args.hasArg(options::OPT_static)) {
5119 CmdArgs.push_back("-Bstatic");
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00005120 CmdArgs.push_back("-dn");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005121 } else {
Edward O'Callaghan7adf9492009-10-15 07:44:07 +00005122// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005123 CmdArgs.push_back("-Bdynamic");
5124 if (Args.hasArg(options::OPT_shared)) {
5125 CmdArgs.push_back("-shared");
5126 } else {
Edward O'Callaghan3cecc192009-10-16 19:44:18 +00005127 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005128 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5129 }
5130 }
5131
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005132 if (Output.isFilename()) {
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005133 CmdArgs.push_back("-o");
5134 CmdArgs.push_back(Output.getFilename());
5135 } else {
5136 assert(Output.isNothing() && "Invalid output.");
5137 }
5138
5139 if (!Args.hasArg(options::OPT_nostdlib) &&
5140 !Args.hasArg(options::OPT_nostartfiles)) {
5141 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner38e317d2010-07-07 16:01:42 +00005142 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005143 getToolChain().GetFilePath("crt1.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00005144 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005145 getToolChain().GetFilePath("crti.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00005146 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005147 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005148 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00005149 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005150 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005151 }
Chris Lattner38e317d2010-07-07 16:01:42 +00005152 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005153 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005154 }
5155
Daniel Dunbar294691e2009-11-04 06:24:38 +00005156 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5157 + getToolChain().getTripleString()
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00005158 + "/4.2.4"));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005159
5160 Args.AddAllArgs(CmdArgs, options::OPT_L);
5161 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5162 Args.AddAllArgs(CmdArgs, options::OPT_e);
5163
Daniel Dunbar2008fee2010-09-17 00:24:54 +00005164 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005165
5166 if (!Args.hasArg(options::OPT_nostdlib) &&
5167 !Args.hasArg(options::OPT_nodefaultlibs)) {
5168 // FIXME: For some reason GCC passes -lgcc before adding
5169 // the default system libraries. Just mimic this for now.
5170 CmdArgs.push_back("-lgcc");
5171
5172 if (Args.hasArg(options::OPT_pthread))
5173 CmdArgs.push_back("-pthread");
5174 if (!Args.hasArg(options::OPT_shared))
5175 CmdArgs.push_back("-lc");
5176 CmdArgs.push_back("-lgcc");
5177 }
5178
5179 if (!Args.hasArg(options::OPT_nostdlib) &&
5180 !Args.hasArg(options::OPT_nostartfiles)) {
5181 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00005182 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005183 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005184 }
5185
Bill Wendling3f4be6f2011-06-27 19:15:03 +00005186 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00005187
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005188 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005189 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005190 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghane7925a02009-08-22 01:06:46 +00005191}
5192
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005193void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005194 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005195 const InputInfoList &Inputs,
5196 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00005197 const char *LinkingOutput) const {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005198 ArgStringList CmdArgs;
5199
5200 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5201 options::OPT_Xassembler);
5202
5203 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005204 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005205
5206 for (InputInfoList::const_iterator
5207 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5208 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005209 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005210 }
5211
5212 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005213 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005214 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005215}
5216
5217void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005218 const InputInfo &Output,
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005219 const InputInfoList &Inputs,
5220 const ArgList &Args,
5221 const char *LinkingOutput) const {
Daniel Dunbaree788e72009-12-21 18:54:17 +00005222 const Driver &D = getToolChain().getDriver();
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005223 ArgStringList CmdArgs;
5224
Rafael Espindola6cc2a682012-12-31 22:41:36 +00005225 // Silence warning for "clang -g foo.o -o foo"
5226 Args.ClaimAllArgs(options::OPT_g_Group);
5227 // and "clang -emit-llvm foo.o -o foo"
5228 Args.ClaimAllArgs(options::OPT_emit_llvm);
5229 // and for "clang -w foo.o -o foo". Other warning options are already
5230 // handled somewhere else.
5231 Args.ClaimAllArgs(options::OPT_w);
5232
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005233 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar294691e2009-11-04 06:24:38 +00005234 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005235 CmdArgs.push_back("-e");
5236 CmdArgs.push_back("__start");
5237 }
5238
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005239 if (Args.hasArg(options::OPT_static)) {
5240 CmdArgs.push_back("-Bstatic");
5241 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00005242 if (Args.hasArg(options::OPT_rdynamic))
5243 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005244 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005245 CmdArgs.push_back("-Bdynamic");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005246 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005247 CmdArgs.push_back("-shared");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005248 } else {
5249 CmdArgs.push_back("-dynamic-linker");
5250 CmdArgs.push_back("/usr/libexec/ld.so");
5251 }
5252 }
5253
Rafael Espindola9adba392013-06-05 04:28:55 +00005254 if (Args.hasArg(options::OPT_nopie))
5255 CmdArgs.push_back("-nopie");
5256
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005257 if (Output.isFilename()) {
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005258 CmdArgs.push_back("-o");
5259 CmdArgs.push_back(Output.getFilename());
5260 } else {
5261 assert(Output.isNothing() && "Invalid output.");
5262 }
5263
5264 if (!Args.hasArg(options::OPT_nostdlib) &&
5265 !Args.hasArg(options::OPT_nostartfiles)) {
5266 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman62d829a2011-12-15 02:15:56 +00005267 if (Args.hasArg(options::OPT_pg))
5268 CmdArgs.push_back(Args.MakeArgString(
5269 getToolChain().GetFilePath("gcrt0.o")));
5270 else
5271 CmdArgs.push_back(Args.MakeArgString(
5272 getToolChain().GetFilePath("crt0.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00005273 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005274 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005275 } else {
Chris Lattner38e317d2010-07-07 16:01:42 +00005276 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005277 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005278 }
5279 }
5280
Edward O'Callaghane7e18202009-10-28 15:13:08 +00005281 std::string Triple = getToolChain().getTripleString();
5282 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar294691e2009-11-04 06:24:38 +00005283 Triple.replace(0, 6, "amd64");
Daniel Dunbarf7fb31f2009-10-29 02:24:37 +00005284 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbar95c04572010-08-01 23:13:54 +00005285 "/4.2.1"));
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005286
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005287 Args.AddAllArgs(CmdArgs, options::OPT_L);
5288 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5289 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindola6cc2a682012-12-31 22:41:36 +00005290 Args.AddAllArgs(CmdArgs, options::OPT_s);
5291 Args.AddAllArgs(CmdArgs, options::OPT_t);
5292 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5293 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005294
Daniel Dunbar2008fee2010-09-17 00:24:54 +00005295 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005296
5297 if (!Args.hasArg(options::OPT_nostdlib) &&
5298 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00005299 if (D.CCCIsCXX()) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00005300 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman62d829a2011-12-15 02:15:56 +00005301 if (Args.hasArg(options::OPT_pg))
5302 CmdArgs.push_back("-lm_p");
5303 else
5304 CmdArgs.push_back("-lm");
Daniel Dunbar95c04572010-08-01 23:13:54 +00005305 }
5306
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005307 // FIXME: For some reason GCC passes -lgcc before adding
5308 // the default system libraries. Just mimic this for now.
5309 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005310
Eric Christopherdc6cc872012-09-13 06:32:34 +00005311 if (Args.hasArg(options::OPT_pthread)) {
5312 if (!Args.hasArg(options::OPT_shared) &&
5313 Args.hasArg(options::OPT_pg))
5314 CmdArgs.push_back("-lpthread_p");
5315 else
5316 CmdArgs.push_back("-lpthread");
5317 }
5318
Chandler Carruth657849c2011-12-17 22:32:42 +00005319 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopherdc6cc872012-09-13 06:32:34 +00005320 if (Args.hasArg(options::OPT_pg))
Eli Friedman62d829a2011-12-15 02:15:56 +00005321 CmdArgs.push_back("-lc_p");
5322 else
5323 CmdArgs.push_back("-lc");
Chandler Carruth657849c2011-12-17 22:32:42 +00005324 }
Eric Christopherdc6cc872012-09-13 06:32:34 +00005325
Daniel Dunbar2bbcf662009-08-03 01:28:59 +00005326 CmdArgs.push_back("-lgcc");
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005327 }
5328
5329 if (!Args.hasArg(options::OPT_nostdlib) &&
5330 !Args.hasArg(options::OPT_nostartfiles)) {
5331 if (!Args.hasArg(options::OPT_shared))
Chris Lattner38e317d2010-07-07 16:01:42 +00005332 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005333 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005334 else
Chris Lattner38e317d2010-07-07 16:01:42 +00005335 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005336 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005337 }
5338
5339 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005340 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005341 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00005342}
Ed Schoutenc66a5a32009-04-02 19:13:12 +00005343
Eli Friedman42f74f22012-08-08 23:57:20 +00005344void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5345 const InputInfo &Output,
5346 const InputInfoList &Inputs,
5347 const ArgList &Args,
5348 const char *LinkingOutput) const {
5349 ArgStringList CmdArgs;
5350
5351 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5352 options::OPT_Xassembler);
5353
5354 CmdArgs.push_back("-o");
5355 CmdArgs.push_back(Output.getFilename());
5356
5357 for (InputInfoList::const_iterator
5358 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5359 const InputInfo &II = *it;
5360 CmdArgs.push_back(II.getFilename());
5361 }
5362
5363 const char *Exec =
5364 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5365 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5366}
5367
5368void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5369 const InputInfo &Output,
5370 const InputInfoList &Inputs,
5371 const ArgList &Args,
5372 const char *LinkingOutput) const {
5373 const Driver &D = getToolChain().getDriver();
5374 ArgStringList CmdArgs;
5375
5376 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5377 (!Args.hasArg(options::OPT_shared))) {
5378 CmdArgs.push_back("-e");
5379 CmdArgs.push_back("__start");
5380 }
5381
5382 if (Args.hasArg(options::OPT_static)) {
5383 CmdArgs.push_back("-Bstatic");
5384 } else {
5385 if (Args.hasArg(options::OPT_rdynamic))
5386 CmdArgs.push_back("-export-dynamic");
5387 CmdArgs.push_back("--eh-frame-hdr");
5388 CmdArgs.push_back("-Bdynamic");
5389 if (Args.hasArg(options::OPT_shared)) {
5390 CmdArgs.push_back("-shared");
5391 } else {
5392 CmdArgs.push_back("-dynamic-linker");
5393 CmdArgs.push_back("/usr/libexec/ld.so");
5394 }
5395 }
5396
5397 if (Output.isFilename()) {
5398 CmdArgs.push_back("-o");
5399 CmdArgs.push_back(Output.getFilename());
5400 } else {
5401 assert(Output.isNothing() && "Invalid output.");
5402 }
5403
5404 if (!Args.hasArg(options::OPT_nostdlib) &&
5405 !Args.hasArg(options::OPT_nostartfiles)) {
5406 if (!Args.hasArg(options::OPT_shared)) {
5407 if (Args.hasArg(options::OPT_pg))
5408 CmdArgs.push_back(Args.MakeArgString(
5409 getToolChain().GetFilePath("gcrt0.o")));
5410 else
5411 CmdArgs.push_back(Args.MakeArgString(
5412 getToolChain().GetFilePath("crt0.o")));
5413 CmdArgs.push_back(Args.MakeArgString(
5414 getToolChain().GetFilePath("crtbegin.o")));
5415 } else {
5416 CmdArgs.push_back(Args.MakeArgString(
5417 getToolChain().GetFilePath("crtbeginS.o")));
5418 }
5419 }
5420
5421 Args.AddAllArgs(CmdArgs, options::OPT_L);
5422 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5423 Args.AddAllArgs(CmdArgs, options::OPT_e);
5424
5425 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5426
5427 if (!Args.hasArg(options::OPT_nostdlib) &&
5428 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00005429 if (D.CCCIsCXX()) {
Eli Friedman42f74f22012-08-08 23:57:20 +00005430 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5431 if (Args.hasArg(options::OPT_pg))
5432 CmdArgs.push_back("-lm_p");
5433 else
5434 CmdArgs.push_back("-lm");
5435 }
5436
Rafael Espindola3667bbe2012-10-23 17:07:31 +00005437 if (Args.hasArg(options::OPT_pthread)) {
5438 if (!Args.hasArg(options::OPT_shared) &&
5439 Args.hasArg(options::OPT_pg))
5440 CmdArgs.push_back("-lpthread_p");
5441 else
5442 CmdArgs.push_back("-lpthread");
5443 }
5444
Eli Friedman42f74f22012-08-08 23:57:20 +00005445 if (!Args.hasArg(options::OPT_shared)) {
5446 if (Args.hasArg(options::OPT_pg))
5447 CmdArgs.push_back("-lc_p");
5448 else
5449 CmdArgs.push_back("-lc");
5450 }
5451
5452 std::string myarch = "-lclang_rt.";
5453 const llvm::Triple &T = getToolChain().getTriple();
5454 llvm::Triple::ArchType Arch = T.getArch();
5455 switch (Arch) {
5456 case llvm::Triple::arm:
5457 myarch += ("arm");
5458 break;
5459 case llvm::Triple::x86:
5460 myarch += ("i386");
5461 break;
5462 case llvm::Triple::x86_64:
5463 myarch += ("amd64");
5464 break;
5465 default:
5466 assert(0 && "Unsupported architecture");
5467 }
5468 CmdArgs.push_back(Args.MakeArgString(myarch));
5469 }
5470
5471 if (!Args.hasArg(options::OPT_nostdlib) &&
5472 !Args.hasArg(options::OPT_nostartfiles)) {
5473 if (!Args.hasArg(options::OPT_shared))
5474 CmdArgs.push_back(Args.MakeArgString(
5475 getToolChain().GetFilePath("crtend.o")));
5476 else
5477 CmdArgs.push_back(Args.MakeArgString(
5478 getToolChain().GetFilePath("crtendS.o")));
5479 }
Eli Friedmanc9c48db2012-08-09 22:42:04 +00005480
5481 const char *Exec =
5482 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5483 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman42f74f22012-08-08 23:57:20 +00005484}
5485
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005486void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005487 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00005488 const InputInfoList &Inputs,
5489 const ArgList &Args,
Mike Stump1eb44332009-09-09 15:08:12 +00005490 const char *LinkingOutput) const {
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005491 ArgStringList CmdArgs;
5492
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005493 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5494 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc55da4b2012-09-05 21:32:44 +00005495 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005496 CmdArgs.push_back("--32");
Eric Christopherc55da4b2012-09-05 21:32:44 +00005497 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky3393cef2011-06-04 07:37:31 +00005498 CmdArgs.push_back("-a32");
Eric Christopherc55da4b2012-09-05 21:32:44 +00005499 else if (getToolChain().getArch() == llvm::Triple::mips ||
5500 getToolChain().getArch() == llvm::Triple::mipsel ||
5501 getToolChain().getArch() == llvm::Triple::mips64 ||
5502 getToolChain().getArch() == llvm::Triple::mips64el) {
5503 StringRef CPUName;
5504 StringRef ABIName;
Rafael Espindolab330e402013-08-20 22:12:08 +00005505 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer20249a12010-10-21 03:16:25 +00005506
Eric Christopherc55da4b2012-09-05 21:32:44 +00005507 CmdArgs.push_back("-march");
5508 CmdArgs.push_back(CPUName.data());
5509
Eric Christopherc55da4b2012-09-05 21:32:44 +00005510 CmdArgs.push_back("-mabi");
Simon Atanasyane9616a42013-02-27 14:55:49 +00005511 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc55da4b2012-09-05 21:32:44 +00005512
5513 if (getToolChain().getArch() == llvm::Triple::mips ||
5514 getToolChain().getArch() == llvm::Triple::mips64)
5515 CmdArgs.push_back("-EB");
5516 else
5517 CmdArgs.push_back("-EL");
5518
5519 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5520 options::OPT_fpic, options::OPT_fno_pic,
5521 options::OPT_fPIE, options::OPT_fno_PIE,
5522 options::OPT_fpie, options::OPT_fno_pie);
5523 if (LastPICArg &&
5524 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5525 LastPICArg->getOption().matches(options::OPT_fpic) ||
5526 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5527 LastPICArg->getOption().matches(options::OPT_fpie))) {
5528 CmdArgs.push_back("-KPIC");
5529 }
Rafael Espindola27fa2362012-12-13 04:17:14 +00005530 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5531 getToolChain().getArch() == llvm::Triple::thumb) {
5532 CmdArgs.push_back("-mfpu=softvfp");
5533 switch(getToolChain().getTriple().getEnvironment()) {
5534 case llvm::Triple::GNUEABI:
5535 case llvm::Triple::EABI:
Anton Korobeynikovb234e742013-03-18 07:59:20 +00005536 CmdArgs.push_back("-meabi=5");
Rafael Espindola27fa2362012-12-13 04:17:14 +00005537 break;
5538
5539 default:
5540 CmdArgs.push_back("-matpcs");
5541 }
Eric Christopherc55da4b2012-09-05 21:32:44 +00005542 }
Eric Christophered734732010-03-02 02:41:08 +00005543
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005544 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5545 options::OPT_Xassembler);
5546
5547 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005548 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005549
5550 for (InputInfoList::const_iterator
5551 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5552 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005553 CmdArgs.push_back(II.getFilename());
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005554 }
5555
Daniel Dunbarc21c4852009-04-08 23:54:23 +00005556 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00005557 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005558 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar68a31d42009-03-31 17:45:15 +00005559}
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005560
5561void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005562 const InputInfo &Output,
Daniel Dunbarc21c4852009-04-08 23:54:23 +00005563 const InputInfoList &Inputs,
5564 const ArgList &Args,
Daniel Dunbara8304f62009-05-02 20:14:53 +00005565 const char *LinkingOutput) const {
Roman Divacky94380162012-08-28 15:09:03 +00005566 const toolchains::FreeBSD& ToolChain =
5567 static_cast<const toolchains::FreeBSD&>(getToolChain());
5568 const Driver &D = ToolChain.getDriver();
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005569 ArgStringList CmdArgs;
David Chisnalldfa210b2012-07-29 15:24:44 +00005570
5571 // Silence warning for "clang -g foo.o -o foo"
5572 Args.ClaimAllArgs(options::OPT_g_Group);
5573 // and "clang -emit-llvm foo.o -o foo"
5574 Args.ClaimAllArgs(options::OPT_emit_llvm);
5575 // and for "clang -w foo.o -o foo". Other warning options are already
5576 // handled somewhere else.
5577 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005578
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00005579 if (!D.SysRoot.empty())
5580 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5581
Roman Divacky94380162012-08-28 15:09:03 +00005582 if (Args.hasArg(options::OPT_pie))
5583 CmdArgs.push_back("-pie");
5584
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005585 if (Args.hasArg(options::OPT_static)) {
5586 CmdArgs.push_back("-Bstatic");
5587 } else {
Rafael Espindola65ba55d2010-11-11 02:17:51 +00005588 if (Args.hasArg(options::OPT_rdynamic))
5589 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005590 CmdArgs.push_back("--eh-frame-hdr");
5591 if (Args.hasArg(options::OPT_shared)) {
5592 CmdArgs.push_back("-Bshareable");
5593 } else {
5594 CmdArgs.push_back("-dynamic-linker");
5595 CmdArgs.push_back("/libexec/ld-elf.so.1");
5596 }
Roman Divacky94380162012-08-28 15:09:03 +00005597 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5598 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnalldfa210b2012-07-29 15:24:44 +00005599 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5600 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5601 CmdArgs.push_back("--hash-style=both");
5602 }
5603 }
5604 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005605 }
5606
5607 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5608 // instruct ld in the base system to link 32-bit code.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00005609 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005610 CmdArgs.push_back("-m");
5611 CmdArgs.push_back("elf_i386_fbsd");
5612 }
5613
Rafael Espindola64f7ad92012-10-07 04:44:33 +00005614 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky000a6552011-06-04 07:40:24 +00005615 CmdArgs.push_back("-m");
Roman Divacky1052c1d2011-11-21 16:50:32 +00005616 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky000a6552011-06-04 07:40:24 +00005617 }
5618
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00005619 if (Output.isFilename()) {
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005620 CmdArgs.push_back("-o");
5621 CmdArgs.push_back(Output.getFilename());
5622 } else {
5623 assert(Output.isNothing() && "Invalid output.");
5624 }
5625
5626 if (!Args.hasArg(options::OPT_nostdlib) &&
5627 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divacky94380162012-08-28 15:09:03 +00005628 const char *crt1 = NULL;
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005629 if (!Args.hasArg(options::OPT_shared)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00005630 if (Args.hasArg(options::OPT_pg))
Roman Divacky94380162012-08-28 15:09:03 +00005631 crt1 = "gcrt1.o";
5632 else if (Args.hasArg(options::OPT_pie))
5633 crt1 = "Scrt1.o";
5634 else
5635 crt1 = "crt1.o";
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005636 }
Roman Divacky94380162012-08-28 15:09:03 +00005637 if (crt1)
5638 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5639
5640 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5641
5642 const char *crtbegin = NULL;
5643 if (Args.hasArg(options::OPT_static))
5644 crtbegin = "crtbeginT.o";
5645 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5646 crtbegin = "crtbeginS.o";
5647 else
5648 crtbegin = "crtbegin.o";
5649
5650 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005651 }
5652
5653 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divacky94380162012-08-28 15:09:03 +00005654 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Roman Divacky58e5ac92011-03-01 17:53:14 +00005655 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5656 i != e; ++i)
Chris Lattner5f9e2722011-07-23 10:55:15 +00005657 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005658 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5659 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnallc7363772010-08-15 22:58:12 +00005660 Args.AddAllArgs(CmdArgs, options::OPT_s);
5661 Args.AddAllArgs(CmdArgs, options::OPT_t);
5662 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5663 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005664
Roman Divacky94380162012-08-28 15:09:03 +00005665 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005666
5667 if (!Args.hasArg(options::OPT_nostdlib) &&
5668 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00005669 if (D.CCCIsCXX()) {
Roman Divacky94380162012-08-28 15:09:03 +00005670 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divackyc16bb762011-02-10 16:59:40 +00005671 if (Args.hasArg(options::OPT_pg))
5672 CmdArgs.push_back("-lm_p");
5673 else
5674 CmdArgs.push_back("-lm");
Daniel Dunbar20022632010-02-17 08:07:51 +00005675 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005676 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5677 // the default system libraries. Just mimic this for now.
Roman Divackyc16bb762011-02-10 16:59:40 +00005678 if (Args.hasArg(options::OPT_pg))
5679 CmdArgs.push_back("-lgcc_p");
5680 else
5681 CmdArgs.push_back("-lgcc");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005682 if (Args.hasArg(options::OPT_static)) {
5683 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00005684 } else if (Args.hasArg(options::OPT_pg)) {
5685 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005686 } else {
5687 CmdArgs.push_back("--as-needed");
5688 CmdArgs.push_back("-lgcc_s");
5689 CmdArgs.push_back("--no-as-needed");
5690 }
5691
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00005692 if (Args.hasArg(options::OPT_pthread)) {
Roman Divackyc16bb762011-02-10 16:59:40 +00005693 if (Args.hasArg(options::OPT_pg))
5694 CmdArgs.push_back("-lpthread_p");
5695 else
5696 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay24230262011-02-10 20:35:01 +00005697 }
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005698
Roman Divackyc16bb762011-02-10 16:59:40 +00005699 if (Args.hasArg(options::OPT_pg)) {
5700 if (Args.hasArg(options::OPT_shared))
5701 CmdArgs.push_back("-lc");
5702 else
5703 CmdArgs.push_back("-lc_p");
5704 CmdArgs.push_back("-lgcc_p");
5705 } else {
5706 CmdArgs.push_back("-lc");
5707 CmdArgs.push_back("-lgcc");
5708 }
5709
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005710 if (Args.hasArg(options::OPT_static)) {
5711 CmdArgs.push_back("-lgcc_eh");
Roman Divackyc16bb762011-02-10 16:59:40 +00005712 } else if (Args.hasArg(options::OPT_pg)) {
5713 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005714 } else {
5715 CmdArgs.push_back("--as-needed");
5716 CmdArgs.push_back("-lgcc_s");
5717 CmdArgs.push_back("--no-as-needed");
5718 }
5719 }
5720
5721 if (!Args.hasArg(options::OPT_nostdlib) &&
5722 !Args.hasArg(options::OPT_nostartfiles)) {
Roman Divackyf6513812012-09-07 13:36:21 +00005723 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Roman Divacky94380162012-08-28 15:09:03 +00005724 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackyf6513812012-09-07 13:36:21 +00005725 else
5726 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divacky94380162012-08-28 15:09:03 +00005727 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005728 }
5729
Roman Divacky94380162012-08-28 15:09:03 +00005730 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00005731
Daniel Dunbarc21c4852009-04-08 23:54:23 +00005732 const char *Exec =
Roman Divacky94380162012-08-28 15:09:03 +00005733 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00005734 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar008f54a2009-04-01 19:36:32 +00005735}
Daniel Dunbar11e1b402009-05-02 18:28:39 +00005736
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005737void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5738 const InputInfo &Output,
5739 const InputInfoList &Inputs,
5740 const ArgList &Args,
5741 const char *LinkingOutput) const {
5742 ArgStringList CmdArgs;
5743
5744 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5745 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenberger1bd91372012-01-26 22:27:52 +00005746 if (getToolChain().getArch() == llvm::Triple::x86)
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005747 CmdArgs.push_back("--32");
5748
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005749 // Set byte order explicitly
Rafael Espindola64f7ad92012-10-07 04:44:33 +00005750 if (getToolChain().getArch() == llvm::Triple::mips)
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005751 CmdArgs.push_back("-EB");
Rafael Espindola64f7ad92012-10-07 04:44:33 +00005752 else if (getToolChain().getArch() == llvm::Triple::mipsel)
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005753 CmdArgs.push_back("-EL");
5754
5755 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5756 options::OPT_Xassembler);
5757
5758 CmdArgs.push_back("-o");
5759 CmdArgs.push_back(Output.getFilename());
5760
5761 for (InputInfoList::const_iterator
5762 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5763 const InputInfo &II = *it;
5764 CmdArgs.push_back(II.getFilename());
5765 }
5766
David Chisnall5adcec12011-09-27 22:03:18 +00005767 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005768 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5769}
5770
5771void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5772 const InputInfo &Output,
5773 const InputInfoList &Inputs,
5774 const ArgList &Args,
5775 const char *LinkingOutput) const {
5776 const Driver &D = getToolChain().getDriver();
5777 ArgStringList CmdArgs;
5778
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00005779 if (!D.SysRoot.empty())
5780 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5781
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005782 if (Args.hasArg(options::OPT_static)) {
5783 CmdArgs.push_back("-Bstatic");
5784 } else {
5785 if (Args.hasArg(options::OPT_rdynamic))
5786 CmdArgs.push_back("-export-dynamic");
5787 CmdArgs.push_back("--eh-frame-hdr");
5788 if (Args.hasArg(options::OPT_shared)) {
5789 CmdArgs.push_back("-Bshareable");
5790 } else {
5791 CmdArgs.push_back("-dynamic-linker");
5792 CmdArgs.push_back("/libexec/ld.elf_so");
5793 }
5794 }
5795
5796 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5797 // instruct ld in the base system to link 32-bit code.
Joerg Sonnenberger1bd91372012-01-26 22:27:52 +00005798 if (getToolChain().getArch() == llvm::Triple::x86) {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005799 CmdArgs.push_back("-m");
5800 CmdArgs.push_back("elf_i386");
5801 }
5802
5803 if (Output.isFilename()) {
5804 CmdArgs.push_back("-o");
5805 CmdArgs.push_back(Output.getFilename());
5806 } else {
5807 assert(Output.isNothing() && "Invalid output.");
5808 }
5809
5810 if (!Args.hasArg(options::OPT_nostdlib) &&
5811 !Args.hasArg(options::OPT_nostartfiles)) {
5812 if (!Args.hasArg(options::OPT_shared)) {
5813 CmdArgs.push_back(Args.MakeArgString(
5814 getToolChain().GetFilePath("crt0.o")));
5815 CmdArgs.push_back(Args.MakeArgString(
5816 getToolChain().GetFilePath("crti.o")));
5817 CmdArgs.push_back(Args.MakeArgString(
5818 getToolChain().GetFilePath("crtbegin.o")));
5819 } else {
5820 CmdArgs.push_back(Args.MakeArgString(
5821 getToolChain().GetFilePath("crti.o")));
5822 CmdArgs.push_back(Args.MakeArgString(
5823 getToolChain().GetFilePath("crtbeginS.o")));
5824 }
5825 }
5826
5827 Args.AddAllArgs(CmdArgs, options::OPT_L);
5828 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5829 Args.AddAllArgs(CmdArgs, options::OPT_e);
5830 Args.AddAllArgs(CmdArgs, options::OPT_s);
5831 Args.AddAllArgs(CmdArgs, options::OPT_t);
5832 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5833 Args.AddAllArgs(CmdArgs, options::OPT_r);
5834
5835 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5836
5837 if (!Args.hasArg(options::OPT_nostdlib) &&
5838 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00005839 if (D.CCCIsCXX()) {
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005840 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5841 CmdArgs.push_back("-lm");
5842 }
5843 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5844 // the default system libraries. Just mimic this for now.
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005845 if (Args.hasArg(options::OPT_static)) {
5846 CmdArgs.push_back("-lgcc_eh");
5847 } else {
5848 CmdArgs.push_back("--as-needed");
5849 CmdArgs.push_back("-lgcc_s");
5850 CmdArgs.push_back("--no-as-needed");
5851 }
Joerg Sonnenbergerdb6393f2011-06-07 23:39:17 +00005852 CmdArgs.push_back("-lgcc");
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005853
5854 if (Args.hasArg(options::OPT_pthread))
5855 CmdArgs.push_back("-lpthread");
5856 CmdArgs.push_back("-lc");
5857
5858 CmdArgs.push_back("-lgcc");
5859 if (Args.hasArg(options::OPT_static)) {
5860 CmdArgs.push_back("-lgcc_eh");
5861 } else {
5862 CmdArgs.push_back("--as-needed");
5863 CmdArgs.push_back("-lgcc_s");
5864 CmdArgs.push_back("--no-as-needed");
5865 }
5866 }
5867
5868 if (!Args.hasArg(options::OPT_nostdlib) &&
5869 !Args.hasArg(options::OPT_nostartfiles)) {
5870 if (!Args.hasArg(options::OPT_shared))
5871 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5872 "crtend.o")));
5873 else
5874 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5875 "crtendS.o")));
5876 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5877 "crtn.o")));
5878 }
5879
Bill Wendling3f4be6f2011-06-27 19:15:03 +00005880 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00005881
David Chisnall5adcec12011-09-27 22:03:18 +00005882 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer8e50a962011-02-02 18:59:27 +00005883 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5884}
5885
Thomas Schwinge577bb0a2013-03-28 19:04:25 +00005886void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5887 const InputInfo &Output,
5888 const InputInfoList &Inputs,
5889 const ArgList &Args,
5890 const char *LinkingOutput) const {
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00005891 ArgStringList CmdArgs;
5892
5893 // Add --32/--64 to make sure we get the format we want.
5894 // This is incomplete
5895 if (getToolChain().getArch() == llvm::Triple::x86) {
5896 CmdArgs.push_back("--32");
5897 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5898 CmdArgs.push_back("--64");
Eli Friedman7972c882011-11-28 23:46:52 +00005899 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5900 CmdArgs.push_back("-a32");
5901 CmdArgs.push_back("-mppc");
5902 CmdArgs.push_back("-many");
5903 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5904 CmdArgs.push_back("-a64");
5905 CmdArgs.push_back("-mppc64");
5906 CmdArgs.push_back("-many");
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00005907 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
5908 CmdArgs.push_back("-a64");
5909 CmdArgs.push_back("-mppc64le");
5910 CmdArgs.push_back("-many");
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00005911 } else if (getToolChain().getArch() == llvm::Triple::arm) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00005912 StringRef MArch = getToolChain().getArchName();
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00005913 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5914 CmdArgs.push_back("-mfpu=neon");
Evgeniy Stepanov700c5082012-04-20 09:03:40 +00005915
5916 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5917 getToolChain().getTriple());
5918 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanoveca187e2012-04-24 09:05:31 +00005919
5920 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5921 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5922 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanakac85900f2011-11-30 19:31:38 +00005923 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5924 getToolChain().getArch() == llvm::Triple::mipsel ||
5925 getToolChain().getArch() == llvm::Triple::mips64 ||
5926 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan073a7802012-04-07 22:31:29 +00005927 StringRef CPUName;
5928 StringRef ABIName;
Rafael Espindolab330e402013-08-20 22:12:08 +00005929 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanakac85900f2011-11-30 19:31:38 +00005930
Simon Atanasyan073a7802012-04-07 22:31:29 +00005931 CmdArgs.push_back("-march");
5932 CmdArgs.push_back(CPUName.data());
5933
Simon Atanasyan073a7802012-04-07 22:31:29 +00005934 CmdArgs.push_back("-mabi");
Simon Atanasyane9616a42013-02-27 14:55:49 +00005935 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan5f0a1c12012-04-06 19:15:24 +00005936
5937 if (getToolChain().getArch() == llvm::Triple::mips ||
5938 getToolChain().getArch() == llvm::Triple::mips64)
5939 CmdArgs.push_back("-EB");
5940 else
5941 CmdArgs.push_back("-EL");
Simon Atanasyan1f0646e2012-05-29 19:07:33 +00005942
Simon Atanasyan9dbfc612013-04-30 07:47:13 +00005943 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
5944 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
5945 options::OPT_mno_micromips);
5946 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
5947 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
5948
Simon Atanasyan1f0646e2012-05-29 19:07:33 +00005949 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5950 options::OPT_fpic, options::OPT_fno_pic,
5951 options::OPT_fPIE, options::OPT_fno_PIE,
5952 options::OPT_fpie, options::OPT_fno_pie);
5953 if (LastPICArg &&
5954 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5955 LastPICArg->getOption().matches(options::OPT_fpic) ||
5956 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5957 LastPICArg->getOption().matches(options::OPT_fpie))) {
5958 CmdArgs.push_back("-KPIC");
5959 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00005960 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00005961 // Always pass an -march option, since our default of z10 is later
5962 // than the GNU assembler's default.
5963 StringRef CPUName = getSystemZTargetCPU(Args);
5964 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00005965 }
5966
5967 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5968 options::OPT_Xassembler);
5969
5970 CmdArgs.push_back("-o");
5971 CmdArgs.push_back(Output.getFilename());
5972
5973 for (InputInfoList::const_iterator
5974 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5975 const InputInfo &II = *it;
5976 CmdArgs.push_back(II.getFilename());
5977 }
5978
5979 const char *Exec =
5980 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5981 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopherc47b6f32013-06-05 23:58:15 +00005982
5983 // Handle the debug info splitting at object creation time if we're
5984 // creating an object.
5985 // TODO: Currently only works on linux with newer objcopy.
5986 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani57b1da12013-09-14 01:09:11 +00005987 getToolChain().getTriple().isOSLinux())
Eric Christopherc47b6f32013-06-05 23:58:15 +00005988 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
5989 SplitDebugName(Args, Inputs));
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00005990}
5991
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00005992static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5993 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chien94a71422012-09-02 09:30:11 +00005994 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth68f94db2013-03-04 02:07:55 +00005995 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
5996 Args.hasArg(options::OPT_static);
Hans Wennborg76b86c22013-07-18 20:29:38 +00005997 if (!D.CCCIsCXX())
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00005998 CmdArgs.push_back("-lgcc");
5999
Logan Chien529a73d2012-11-19 12:04:11 +00006000 if (StaticLibgcc || isAndroid) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00006001 if (D.CCCIsCXX())
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006002 CmdArgs.push_back("-lgcc");
6003 } else {
Hans Wennborg76b86c22013-07-18 20:29:38 +00006004 if (!D.CCCIsCXX())
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006005 CmdArgs.push_back("--as-needed");
6006 CmdArgs.push_back("-lgcc_s");
Hans Wennborg76b86c22013-07-18 20:29:38 +00006007 if (!D.CCCIsCXX())
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006008 CmdArgs.push_back("--no-as-needed");
6009 }
6010
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006011 if (StaticLibgcc && !isAndroid)
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006012 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg76b86c22013-07-18 20:29:38 +00006013 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006014 CmdArgs.push_back("-lgcc");
Logan Chien529a73d2012-11-19 12:04:11 +00006015
6016 // According to Android ABI, we have to link with libdl if we are
6017 // linking with non-static libgcc.
6018 //
6019 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6020 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6021 if (isAndroid && !StaticLibgcc)
6022 CmdArgs.push_back("-ldl");
Rafael Espindolaabf3ac72011-10-17 21:39:04 +00006023}
6024
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00006025static bool hasMipsN32ABIArg(const ArgList &Args) {
6026 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
Richard Smith1d489cf2012-11-01 04:30:05 +00006027 return A && (A->getValue() == StringRef("n32"));
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00006028}
6029
Peter Collingbournebdaa1342013-05-27 21:40:20 +00006030static StringRef getLinuxDynamicLinker(const ArgList &Args,
6031 const toolchains::Linux &ToolChain) {
6032 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6033 return "/system/bin/linker";
6034 else if (ToolChain.getArch() == llvm::Triple::x86)
6035 return "/lib/ld-linux.so.2";
6036 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6037 return "/lib/ld-linux-aarch64.so.1";
6038 else if (ToolChain.getArch() == llvm::Triple::arm ||
6039 ToolChain.getArch() == llvm::Triple::thumb) {
6040 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6041 return "/lib/ld-linux-armhf.so.3";
6042 else
6043 return "/lib/ld-linux.so.3";
6044 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6045 ToolChain.getArch() == llvm::Triple::mipsel)
6046 return "/lib/ld.so.1";
6047 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6048 ToolChain.getArch() == llvm::Triple::mips64el) {
6049 if (hasMipsN32ABIArg(Args))
6050 return "/lib32/ld.so.1";
6051 else
6052 return "/lib64/ld.so.1";
6053 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6054 return "/lib/ld.so.1";
6055 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00006056 ToolChain.getArch() == llvm::Triple::ppc64le ||
Peter Collingbournebdaa1342013-05-27 21:40:20 +00006057 ToolChain.getArch() == llvm::Triple::systemz)
6058 return "/lib64/ld64.so.1";
6059 else
6060 return "/lib64/ld-linux-x86-64.so.2";
6061}
6062
Thomas Schwinge577bb0a2013-03-28 19:04:25 +00006063void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6064 const InputInfo &Output,
6065 const InputInfoList &Inputs,
6066 const ArgList &Args,
6067 const char *LinkingOutput) const {
Rafael Espindolac1da9812010-11-07 20:14:31 +00006068 const toolchains::Linux& ToolChain =
6069 static_cast<const toolchains::Linux&>(getToolChain());
6070 const Driver &D = ToolChain.getDriver();
Rafael Espindola715852c2012-11-02 20:41:30 +00006071 const bool isAndroid =
6072 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Alexey Samsonov1b8f12d2013-08-19 09:14:21 +00006073 const SanitizerArgs &Sanitize = D.getOrParseSanitizerArgs(Args);
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00006074 const bool IsPIE =
6075 !Args.hasArg(options::OPT_shared) &&
Alexey Samsonov8bdc92c2013-08-09 07:42:13 +00006076 (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow(ToolChain));
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006077
Rafael Espindolac1da9812010-11-07 20:14:31 +00006078 ArgStringList CmdArgs;
6079
Rafael Espindola26f14c32010-11-15 18:28:16 +00006080 // Silence warning for "clang -g foo.o -o foo"
6081 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindola9c094fb2011-03-01 05:25:27 +00006082 // and "clang -emit-llvm foo.o -o foo"
6083 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnalldfa210b2012-07-29 15:24:44 +00006084 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindola7f6458b2010-11-17 20:37:10 +00006085 // handled somewhere else.
6086 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindola26f14c32010-11-15 18:28:16 +00006087
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00006088 if (!D.SysRoot.empty())
6089 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac1da9812010-11-07 20:14:31 +00006090
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00006091 if (IsPIE)
Rafael Espindolafdda1712010-11-17 22:26:15 +00006092 CmdArgs.push_back("-pie");
6093
Rafael Espindoladc1b76d2010-11-07 22:57:16 +00006094 if (Args.hasArg(options::OPT_rdynamic))
6095 CmdArgs.push_back("-export-dynamic");
6096
Rafael Espindolae0e6d3b2010-11-11 19:34:42 +00006097 if (Args.hasArg(options::OPT_s))
6098 CmdArgs.push_back("-s");
6099
Rafael Espindolac1da9812010-11-07 20:14:31 +00006100 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6101 e = ToolChain.ExtraOpts.end();
6102 i != e; ++i)
6103 CmdArgs.push_back(i->c_str());
6104
6105 if (!Args.hasArg(options::OPT_static)) {
6106 CmdArgs.push_back("--eh-frame-hdr");
6107 }
6108
6109 CmdArgs.push_back("-m");
6110 if (ToolChain.getArch() == llvm::Triple::x86)
6111 CmdArgs.push_back("elf_i386");
Tim Northoverc264e162013-01-31 12:13:10 +00006112 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6113 CmdArgs.push_back("aarch64linux");
Eric Christopher88b7cf02011-08-19 00:30:14 +00006114 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregorf0594d82011-03-06 19:11:49 +00006115 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00006116 CmdArgs.push_back("armelf_linux_eabi");
Ted Kremenek43ac2972011-04-05 22:04:27 +00006117 else if (ToolChain.getArch() == llvm::Triple::ppc)
6118 CmdArgs.push_back("elf32ppclinux");
6119 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6120 CmdArgs.push_back("elf64ppc");
Eli Friedman5bea4f62011-11-08 19:43:37 +00006121 else if (ToolChain.getArch() == llvm::Triple::mips)
6122 CmdArgs.push_back("elf32btsmip");
6123 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6124 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyanf4bd3292012-10-21 11:44:57 +00006125 else if (ToolChain.getArch() == llvm::Triple::mips64) {
6126 if (hasMipsN32ABIArg(Args))
6127 CmdArgs.push_back("elf32btsmipn32");
6128 else
6129 CmdArgs.push_back("elf64btsmip");
6130 }
6131 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6132 if (hasMipsN32ABIArg(Args))
6133 CmdArgs.push_back("elf32ltsmipn32");
6134 else
6135 CmdArgs.push_back("elf64ltsmip");
6136 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00006137 else if (ToolChain.getArch() == llvm::Triple::systemz)
6138 CmdArgs.push_back("elf64_s390");
Rafael Espindolac1da9812010-11-07 20:14:31 +00006139 else
6140 CmdArgs.push_back("elf_x86_64");
6141
6142 if (Args.hasArg(options::OPT_static)) {
Douglas Gregorf0594d82011-03-06 19:11:49 +00006143 if (ToolChain.getArch() == llvm::Triple::arm
6144 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac1da9812010-11-07 20:14:31 +00006145 CmdArgs.push_back("-Bstatic");
6146 else
6147 CmdArgs.push_back("-static");
6148 } else if (Args.hasArg(options::OPT_shared)) {
6149 CmdArgs.push_back("-shared");
Rafael Espindola715852c2012-11-02 20:41:30 +00006150 if (isAndroid) {
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006151 CmdArgs.push_back("-Bsymbolic");
6152 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00006153 }
6154
6155 if (ToolChain.getArch() == llvm::Triple::arm ||
Douglas Gregorf0594d82011-03-06 19:11:49 +00006156 ToolChain.getArch() == llvm::Triple::thumb ||
Rafael Espindolac1da9812010-11-07 20:14:31 +00006157 (!Args.hasArg(options::OPT_static) &&
6158 !Args.hasArg(options::OPT_shared))) {
6159 CmdArgs.push_back("-dynamic-linker");
Peter Collingbournebdaa1342013-05-27 21:40:20 +00006160 CmdArgs.push_back(Args.MakeArgString(
6161 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac1da9812010-11-07 20:14:31 +00006162 }
6163
6164 CmdArgs.push_back("-o");
6165 CmdArgs.push_back(Output.getFilename());
6166
Rafael Espindola49c64fd2010-12-01 01:52:43 +00006167 if (!Args.hasArg(options::OPT_nostdlib) &&
6168 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006169 if (!isAndroid) {
6170 const char *crt1 = NULL;
6171 if (!Args.hasArg(options::OPT_shared)){
Eric Christopher61f08682013-06-07 23:25:01 +00006172 if (Args.hasArg(options::OPT_pg))
6173 crt1 = "gcrt1.o";
6174 else if (IsPIE)
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006175 crt1 = "Scrt1.o";
6176 else
6177 crt1 = "crt1.o";
6178 }
6179 if (crt1)
6180 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac1da9812010-11-07 20:14:31 +00006181
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006182 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6183 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00006184
Rafael Espindola89414b32010-11-12 03:00:39 +00006185 const char *crtbegin;
6186 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006187 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanova92983d2012-09-10 10:30:12 +00006188 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006189 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00006190 else if (IsPIE)
Evgeniy Stepanova92983d2012-09-10 10:30:12 +00006191 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola89414b32010-11-12 03:00:39 +00006192 else
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006193 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola89414b32010-11-12 03:00:39 +00006194 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramere20e5082012-10-04 19:42:20 +00006195
6196 // Add crtfastmath.o if available and fast math is enabled.
6197 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola89414b32010-11-12 03:00:39 +00006198 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00006199
6200 Args.AddAllArgs(CmdArgs, options::OPT_L);
6201
6202 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6203
Roman Divacky58e5ac92011-03-01 17:53:14 +00006204 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6205 i != e; ++i)
Chris Lattner5f9e2722011-07-23 10:55:15 +00006206 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
Rafael Espindolac1da9812010-11-07 20:14:31 +00006207
Rafael Espindolac5151542012-04-09 23:53:34 +00006208 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6209 // as gold requires -plugin to come before any -plugin-opt that -Wl might
6210 // forward.
Rafael Espindola6155fbe2013-09-04 19:37:35 +00006211 if (D.IsUsingLTO(Args)) {
Rafael Espindolac5151542012-04-09 23:53:34 +00006212 CmdArgs.push_back("-plugin");
6213 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6214 CmdArgs.push_back(Args.MakeArgString(Plugin));
Chandler Carruth700d4e42013-01-13 11:46:33 +00006215
6216 // Try to pass driver level flags relevant to LTO code generation down to
6217 // the plugin.
6218
Rafael Espindolab330e402013-08-20 22:12:08 +00006219 // Handle flags for selecting CPU variants.
6220 std::string CPU = getCPUName(Args, ToolChain.getTriple());
6221 if (!CPU.empty()) {
Chandler Carruth700d4e42013-01-13 11:46:33 +00006222 CmdArgs.push_back(
Rafael Espindolab330e402013-08-20 22:12:08 +00006223 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6224 CPU));
6225 }
Rafael Espindolac5151542012-04-09 23:53:34 +00006226 }
6227
Chandler Carruth700d4e42013-01-13 11:46:33 +00006228
Nick Lewyckye276cfc2012-08-17 03:39:16 +00006229 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6230 CmdArgs.push_back("--no-demangle");
6231
Rafael Espindolac1da9812010-11-07 20:14:31 +00006232 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6233
Eric Christopher6716d942012-11-29 18:51:05 +00006234 // Call these before we add the C++ ABI library.
Richard Smithc4dabad2012-11-05 22:04:41 +00006235 if (Sanitize.needsUbsanRt())
Hans Wennborg76b86c22013-07-18 20:29:38 +00006236 addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
Richard Smith61a574f2013-03-20 23:49:07 +00006237 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
Sergey Matveev050309f2013-05-27 11:17:01 +00006238 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
Eric Christopher6716d942012-11-29 18:51:05 +00006239 if (Sanitize.needsAsanRt())
6240 addAsanRTLinux(getToolChain(), Args, CmdArgs);
6241 if (Sanitize.needsTsanRt())
6242 addTsanRTLinux(getToolChain(), Args, CmdArgs);
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +00006243 if (Sanitize.needsMsanRt())
6244 addMsanRTLinux(getToolChain(), Args, CmdArgs);
Sergey Matveev050309f2013-05-27 11:17:01 +00006245 if (Sanitize.needsLsanRt())
6246 addLsanRTLinux(getToolChain(), Args, CmdArgs);
Peter Collingbourne2eeed712013-08-07 22:47:34 +00006247 if (Sanitize.needsDfsanRt())
6248 addDfsanRTLinux(getToolChain(), Args, CmdArgs);
Richard Smith8e1cee62012-10-25 02:14:12 +00006249
Chandler Carruth80a393e2013-06-24 09:38:45 +00006250 // The profile runtime also needs access to system libraries.
6251 addProfileRTLinux(getToolChain(), Args, CmdArgs);
6252
Hans Wennborg76b86c22013-07-18 20:29:38 +00006253 if (D.CCCIsCXX() &&
Chandler Carruth2ba542c2012-05-14 18:31:18 +00006254 !Args.hasArg(options::OPT_nostdlib) &&
6255 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola19706f82011-10-17 22:14:51 +00006256 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6257 !Args.hasArg(options::OPT_static);
6258 if (OnlyLibstdcxxStatic)
6259 CmdArgs.push_back("-Bstatic");
Rafael Espindolac1da9812010-11-07 20:14:31 +00006260 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola19706f82011-10-17 22:14:51 +00006261 if (OnlyLibstdcxxStatic)
6262 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac1da9812010-11-07 20:14:31 +00006263 CmdArgs.push_back("-lm");
6264 }
6265
Rafael Espindola89414b32010-11-12 03:00:39 +00006266 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth2ba542c2012-05-14 18:31:18 +00006267 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6268 if (Args.hasArg(options::OPT_static))
6269 CmdArgs.push_back("--start-group");
Nick Lewycky80df0252011-06-04 06:27:06 +00006270
Chandler Carruthdf96e022013-01-17 13:19:29 +00006271 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6272 if (OpenMP) {
6273 CmdArgs.push_back("-lgomp");
6274
6275 // FIXME: Exclude this for platforms whith libgomp that doesn't require
6276 // librt. Most modern Linux platfroms require it, but some may not.
6277 CmdArgs.push_back("-lrt");
6278 }
6279
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006280 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
Rafael Espindola89414b32010-11-12 03:00:39 +00006281
Chandler Carruth2ba542c2012-05-14 18:31:18 +00006282 if (Args.hasArg(options::OPT_pthread) ||
Chandler Carruthdf96e022013-01-17 13:19:29 +00006283 Args.hasArg(options::OPT_pthreads) || OpenMP)
Chandler Carruth2ba542c2012-05-14 18:31:18 +00006284 CmdArgs.push_back("-lpthread");
6285
6286 CmdArgs.push_back("-lc");
6287
6288 if (Args.hasArg(options::OPT_static))
6289 CmdArgs.push_back("--end-group");
6290 else
6291 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6292 }
Rafael Espindolafdda1712010-11-17 22:26:15 +00006293
Rafael Espindola49c64fd2010-12-01 01:52:43 +00006294 if (!Args.hasArg(options::OPT_nostartfiles)) {
6295 const char *crtend;
Evgeniy Stepanova92983d2012-09-10 10:30:12 +00006296 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006297 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne52ca70d2013-04-09 04:35:11 +00006298 else if (IsPIE)
Evgeniy Stepanova92983d2012-09-10 10:30:12 +00006299 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola49c64fd2010-12-01 01:52:43 +00006300 else
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006301 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola89414b32010-11-12 03:00:39 +00006302
Rafael Espindola49c64fd2010-12-01 01:52:43 +00006303 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanova6ddc022012-04-25 08:59:22 +00006304 if (!isAndroid)
6305 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola49c64fd2010-12-01 01:52:43 +00006306 }
Rafael Espindolac1da9812010-11-07 20:14:31 +00006307 }
6308
Rafael Espindolac1da9812010-11-07 20:14:31 +00006309 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6310}
Rafael Espindolaba30bbe2010-08-10 00:25:48 +00006311
Chris Lattner38e317d2010-07-07 16:01:42 +00006312void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006313 const InputInfo &Output,
6314 const InputInfoList &Inputs,
6315 const ArgList &Args,
6316 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00006317 ArgStringList CmdArgs;
6318
6319 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6320 options::OPT_Xassembler);
6321
6322 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006323 CmdArgs.push_back(Output.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00006324
6325 for (InputInfoList::const_iterator
6326 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6327 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006328 CmdArgs.push_back(II.getFilename());
Chris Lattner38e317d2010-07-07 16:01:42 +00006329 }
6330
6331 const char *Exec =
Eli Friedman6d402dc2011-12-08 23:54:21 +00006332 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006333 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00006334}
6335
6336void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006337 const InputInfo &Output,
6338 const InputInfoList &Inputs,
6339 const ArgList &Args,
6340 const char *LinkingOutput) const {
Chris Lattner38e317d2010-07-07 16:01:42 +00006341 const Driver &D = getToolChain().getDriver();
6342 ArgStringList CmdArgs;
6343
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006344 if (Output.isFilename()) {
Chris Lattner38e317d2010-07-07 16:01:42 +00006345 CmdArgs.push_back("-o");
6346 CmdArgs.push_back(Output.getFilename());
6347 } else {
6348 assert(Output.isNothing() && "Invalid output.");
6349 }
6350
6351 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman6d402dc2011-12-08 23:54:21 +00006352 !Args.hasArg(options::OPT_nostartfiles)) {
6353 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6354 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6355 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6356 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6357 }
Chris Lattner38e317d2010-07-07 16:01:42 +00006358
6359 Args.AddAllArgs(CmdArgs, options::OPT_L);
6360 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6361 Args.AddAllArgs(CmdArgs, options::OPT_e);
6362
Daniel Dunbar2008fee2010-09-17 00:24:54 +00006363 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00006364
Eli Friedman6d402dc2011-12-08 23:54:21 +00006365 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6366
Chris Lattner38e317d2010-07-07 16:01:42 +00006367 if (!Args.hasArg(options::OPT_nostdlib) &&
6368 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg76b86c22013-07-18 20:29:38 +00006369 if (D.CCCIsCXX()) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00006370 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner38e317d2010-07-07 16:01:42 +00006371 CmdArgs.push_back("-lm");
6372 }
Chris Lattner38e317d2010-07-07 16:01:42 +00006373 }
6374
6375 if (!Args.hasArg(options::OPT_nostdlib) &&
6376 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman6d402dc2011-12-08 23:54:21 +00006377 if (Args.hasArg(options::OPT_pthread))
6378 CmdArgs.push_back("-lpthread");
6379 CmdArgs.push_back("-lc");
6380 CmdArgs.push_back("-lCompilerRT-Generic");
6381 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6382 CmdArgs.push_back(
Eric Christopher27e2b982012-12-18 00:31:10 +00006383 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00006384 }
6385
Eli Friedman6d402dc2011-12-08 23:54:21 +00006386 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006387 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner38e317d2010-07-07 16:01:42 +00006388}
6389
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006390/// DragonFly Tools
6391
6392// For now, DragonFly Assemble does just about the same as for
6393// FreeBSD, but this may change soon.
6394void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006395 const InputInfo &Output,
Daniel Dunbar294691e2009-11-04 06:24:38 +00006396 const InputInfoList &Inputs,
6397 const ArgList &Args,
6398 const char *LinkingOutput) const {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006399 ArgStringList CmdArgs;
6400
6401 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6402 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00006403 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006404 CmdArgs.push_back("--32");
6405
6406 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6407 options::OPT_Xassembler);
6408
6409 CmdArgs.push_back("-o");
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006410 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006411
6412 for (InputInfoList::const_iterator
6413 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6414 const InputInfo &II = *it;
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006415 CmdArgs.push_back(II.getFilename());
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006416 }
6417
6418 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00006419 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006420 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006421}
6422
6423void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006424 const InputInfo &Output,
6425 const InputInfoList &Inputs,
6426 const ArgList &Args,
6427 const char *LinkingOutput) const {
John McCall8cfb7202013-04-11 22:55:55 +00006428 bool UseGCC47 = false;
Daniel Dunbaree788e72009-12-21 18:54:17 +00006429 const Driver &D = getToolChain().getDriver();
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006430 ArgStringList CmdArgs;
6431
John McCall8cfb7202013-04-11 22:55:55 +00006432 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6433 UseGCC47 = false;
6434
Joerg Sonnenberger8ab2bdc2011-03-21 13:51:29 +00006435 if (!D.SysRoot.empty())
6436 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6437
John McCall8cfb7202013-04-11 22:55:55 +00006438 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006439 if (Args.hasArg(options::OPT_static)) {
6440 CmdArgs.push_back("-Bstatic");
6441 } else {
John McCall8cfb7202013-04-11 22:55:55 +00006442 if (Args.hasArg(options::OPT_rdynamic))
6443 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006444 if (Args.hasArg(options::OPT_shared))
6445 CmdArgs.push_back("-Bshareable");
6446 else {
6447 CmdArgs.push_back("-dynamic-linker");
6448 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6449 }
John McCall8cfb7202013-04-11 22:55:55 +00006450 CmdArgs.push_back("--hash-style=both");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006451 }
6452
6453 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6454 // instruct ld in the base system to link 32-bit code.
Rafael Espindola64f7ad92012-10-07 04:44:33 +00006455 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006456 CmdArgs.push_back("-m");
6457 CmdArgs.push_back("elf_i386");
6458 }
6459
Daniel Dunbar7c1e4652010-08-02 02:38:21 +00006460 if (Output.isFilename()) {
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006461 CmdArgs.push_back("-o");
6462 CmdArgs.push_back(Output.getFilename());
6463 } else {
6464 assert(Output.isNothing() && "Invalid output.");
6465 }
6466
6467 if (!Args.hasArg(options::OPT_nostdlib) &&
6468 !Args.hasArg(options::OPT_nostartfiles)) {
6469 if (!Args.hasArg(options::OPT_shared)) {
John McCall8cfb7202013-04-11 22:55:55 +00006470 if (Args.hasArg(options::OPT_pg))
6471 CmdArgs.push_back(Args.MakeArgString(
6472 getToolChain().GetFilePath("gcrt1.o")));
6473 else {
6474 if (Args.hasArg(options::OPT_pie))
6475 CmdArgs.push_back(Args.MakeArgString(
6476 getToolChain().GetFilePath("Scrt1.o")));
6477 else
6478 CmdArgs.push_back(Args.MakeArgString(
6479 getToolChain().GetFilePath("crt1.o")));
6480 }
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006481 }
John McCall8cfb7202013-04-11 22:55:55 +00006482 CmdArgs.push_back(Args.MakeArgString(
6483 getToolChain().GetFilePath("crti.o")));
6484 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6485 CmdArgs.push_back(Args.MakeArgString(
6486 getToolChain().GetFilePath("crtbeginS.o")));
6487 else
6488 CmdArgs.push_back(Args.MakeArgString(
6489 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006490 }
6491
6492 Args.AddAllArgs(CmdArgs, options::OPT_L);
6493 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6494 Args.AddAllArgs(CmdArgs, options::OPT_e);
6495
Daniel Dunbar2008fee2010-09-17 00:24:54 +00006496 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006497
6498 if (!Args.hasArg(options::OPT_nostdlib) &&
6499 !Args.hasArg(options::OPT_nodefaultlibs)) {
6500 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6501 // rpaths
John McCall8cfb7202013-04-11 22:55:55 +00006502 if (UseGCC47)
6503 CmdArgs.push_back("-L/usr/lib/gcc47");
6504 else
6505 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006506
6507 if (!Args.hasArg(options::OPT_static)) {
John McCall8cfb7202013-04-11 22:55:55 +00006508 if (UseGCC47) {
6509 CmdArgs.push_back("-rpath");
6510 CmdArgs.push_back("/usr/lib/gcc47");
6511 } else {
6512 CmdArgs.push_back("-rpath");
6513 CmdArgs.push_back("/usr/lib/gcc44");
6514 }
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006515 }
6516
Hans Wennborg76b86c22013-07-18 20:29:38 +00006517 if (D.CCCIsCXX()) {
Daniel Dunbar132e35d2010-09-17 01:20:05 +00006518 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola405861d2010-07-20 12:59:03 +00006519 CmdArgs.push_back("-lm");
6520 }
6521
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006522 if (Args.hasArg(options::OPT_pthread))
Mike Stump4d63f8b2009-10-31 20:11:46 +00006523 CmdArgs.push_back("-lpthread");
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006524
6525 if (!Args.hasArg(options::OPT_nolibc)) {
6526 CmdArgs.push_back("-lc");
6527 }
6528
John McCall8cfb7202013-04-11 22:55:55 +00006529 if (UseGCC47) {
6530 if (Args.hasArg(options::OPT_static) ||
6531 Args.hasArg(options::OPT_static_libgcc)) {
6532 CmdArgs.push_back("-lgcc");
6533 CmdArgs.push_back("-lgcc_eh");
6534 } else {
6535 if (Args.hasArg(options::OPT_shared_libgcc)) {
6536 CmdArgs.push_back("-lgcc_pic");
6537 if (!Args.hasArg(options::OPT_shared))
6538 CmdArgs.push_back("-lgcc");
6539 } else {
6540 CmdArgs.push_back("-lgcc");
6541 CmdArgs.push_back("--as-needed");
6542 CmdArgs.push_back("-lgcc_pic");
6543 CmdArgs.push_back("--no-as-needed");
6544 }
6545 }
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006546 } else {
John McCall8cfb7202013-04-11 22:55:55 +00006547 if (Args.hasArg(options::OPT_shared)) {
6548 CmdArgs.push_back("-lgcc_pic");
6549 } else {
6550 CmdArgs.push_back("-lgcc");
6551 }
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006552 }
6553 }
6554
6555 if (!Args.hasArg(options::OPT_nostdlib) &&
6556 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall8cfb7202013-04-11 22:55:55 +00006557 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner38e317d2010-07-07 16:01:42 +00006558 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00006559 getToolChain().GetFilePath("crtendS.o")));
John McCall8cfb7202013-04-11 22:55:55 +00006560 else
6561 CmdArgs.push_back(Args.MakeArgString(
6562 getToolChain().GetFilePath("crtend.o")));
Chris Lattner38e317d2010-07-07 16:01:42 +00006563 CmdArgs.push_back(Args.MakeArgString(
John McCall8cfb7202013-04-11 22:55:55 +00006564 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006565 }
6566
Bill Wendling3f4be6f2011-06-27 19:15:03 +00006567 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
Nick Lewycky2e95a6d2011-05-24 21:54:59 +00006568
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006569 const char *Exec =
Daniel Dunbar4a7e8892010-07-14 18:46:23 +00006570 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar2fe238e2010-08-02 02:38:28 +00006571 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar11e1b402009-05-02 18:28:39 +00006572}
Michael J. Spencerff58e362010-08-21 21:55:07 +00006573
6574void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6575 const InputInfo &Output,
6576 const InputInfoList &Inputs,
6577 const ArgList &Args,
6578 const char *LinkingOutput) const {
Michael J. Spencerff58e362010-08-21 21:55:07 +00006579 ArgStringList CmdArgs;
6580
6581 if (Output.isFilename()) {
Daniel Dunbare5a37f42010-09-17 00:45:02 +00006582 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6583 Output.getFilename()));
Michael J. Spencerff58e362010-08-21 21:55:07 +00006584 } else {
6585 assert(Output.isNothing() && "Invalid output.");
6586 }
6587
6588 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg746974d2013-08-09 17:38:42 +00006589 !Args.hasArg(options::OPT_nostartfiles) &&
6590 !C.getDriver().IsCLMode()) {
Michael J. Spencerff58e362010-08-21 21:55:07 +00006591 CmdArgs.push_back("-defaultlib:libcmt");
6592 }
6593
6594 CmdArgs.push_back("-nologo");
6595
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00006596 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6597
6598 if (DLL) {
6599 CmdArgs.push_back(Args.MakeArgString("-dll"));
6600
6601 SmallString<128> ImplibName(Output.getFilename());
6602 llvm::sys::path::replace_extension(ImplibName, "lib");
6603 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6604 ImplibName.str()));
6605 }
6606
Hans Wennborg3c4da0c2013-08-27 18:10:21 +00006607 if (getToolChain().getDriver().getOrParseSanitizerArgs(Args).needsAsanRt()) {
Hans Wennborg324cc032013-08-28 17:36:07 +00006608 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborg2ddffa12013-08-30 10:50:52 +00006609 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborg3c4da0c2013-08-27 18:10:21 +00006610 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00006611 llvm::sys::path::append(LibSanitizer, "lib", "windows");
6612 if (DLL) {
Timur Iskhodzhanove4814132013-09-11 11:45:31 +00006613 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
Hans Wennborg6d0a8d52013-09-10 20:18:04 +00006614 } else {
6615 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6616 }
6617 // FIXME: Handle 64-bit.
Hans Wennborg3c4da0c2013-08-27 18:10:21 +00006618 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6619 }
6620
Michael J. Spencera2284f52012-06-18 16:56:04 +00006621 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg5db95272013-08-13 23:38:57 +00006622 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencera2284f52012-06-18 16:56:04 +00006623
6624 // Add filenames immediately.
6625 for (InputInfoList::const_iterator
6626 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6627 if (it->isFilename())
6628 CmdArgs.push_back(it->getFilename());
Hans Wennborg2388b772013-08-14 01:24:35 +00006629 else
6630 it->getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencera2284f52012-06-18 16:56:04 +00006631 }
Michael J. Spencerff58e362010-08-21 21:55:07 +00006632
6633 const char *Exec =
Daniel Dunbar2008fee2010-09-17 00:24:54 +00006634 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerff58e362010-08-21 21:55:07 +00006635 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6636}
Hans Wennborgc8ba0a02013-09-19 20:32:16 +00006637
6638void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
6639 const InputInfo &Output,
6640 const InputInfoList &Inputs,
6641 const ArgList &Args,
6642 const char *LinkingOutput) const {
6643 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
6644}
6645
Hans Wennborgdc40bf92013-09-20 18:16:35 +00006646// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
6647// If one cannot be found, return FallbackName.
6648// We do this special search to prevent clang-cl from falling back onto itself
6649// if it's available as cl.exe on the path.
6650static std::string FindFallback(const char *FallbackName,
6651 const char *ClangProgramPath) {
6652 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
6653 if (!OptPath.hasValue())
6654 return FallbackName;
6655
6656#ifdef LLVM_ON_WIN32
6657 const StringRef PathSeparators = ";";
6658#else
6659 const StringRef PathSeparators = ":";
6660#endif
6661
6662 SmallVector<StringRef, 8> PathSegments;
6663 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
6664
6665 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
6666 const StringRef &PathSegment = PathSegments[i];
6667 if (PathSegment.empty())
6668 continue;
6669
6670 SmallString<128> FilePath(PathSegment);
6671 llvm::sys::path::append(FilePath, FallbackName);
6672 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
6673 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
6674 return FilePath.str();
6675 }
6676
6677 return FallbackName;
6678}
6679
Hans Wennborgc8ba0a02013-09-19 20:32:16 +00006680Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
6681 const InputInfo &Output,
6682 const InputInfoList &Inputs,
6683 const ArgList &Args,
6684 const char *LinkingOutput) const {
6685 ArgStringList CmdArgs;
6686 CmdArgs.push_back("/c"); // Compile only.
6687 CmdArgs.push_back("/W0"); // No warnings.
6688
6689 // The goal is to be able to invoke this tool correctly based on
6690 // any flag accepted by clang-cl.
6691
6692 // These are spelled the same way in clang and cl.exe,.
6693 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
6694 Args.AddAllArgs(CmdArgs, options::OPT_I);
6695 Args.AddLastArg(CmdArgs, options::OPT_O, options::OPT_O0);
6696
6697 // Flags for which clang-cl have an alias.
6698 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
6699
6700 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
6701 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
6702 : "/GR-");
6703 if (Args.hasArg(options::OPT_fsyntax_only))
6704 CmdArgs.push_back("/Zs");
6705
6706 // Flags that can simply be passed through.
6707 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
6708 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
6709
6710 // The order of these flags is relevant, so pick the last one.
6711 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
6712 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
6713 A->render(Args, CmdArgs);
6714
6715
6716 // Input filename.
6717 assert(Inputs.size() == 1);
6718 const InputInfo &II = Inputs[0];
6719 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
6720 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
6721 if (II.isFilename())
6722 CmdArgs.push_back(II.getFilename());
6723 else
6724 II.getInputArg().renderAsInput(Args, CmdArgs);
6725
6726 // Output filename.
6727 assert(Output.getType() == types::TY_Object);
6728 const char *Fo = Args.MakeArgString(std::string("/Fo") +
6729 Output.getFilename());
6730 CmdArgs.push_back(Fo);
6731
Hans Wennborgdc40bf92013-09-20 18:16:35 +00006732 const Driver &D = getToolChain().getDriver();
6733 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborgc8ba0a02013-09-19 20:32:16 +00006734
Hans Wennborgdc40bf92013-09-20 18:16:35 +00006735 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborgc8ba0a02013-09-19 20:32:16 +00006736}