blob: 4c5b3ea627f8001a4a59fee1e8ed3a4488db9802 [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Tools.cpp - Tools Implementations --------------------------------===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000012#include "ToolChains.h"
Josh Mageee0fc1a82014-02-11 01:35:14 +000013#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000015#include "clang/Basic/Version.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000016#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000018#include "clang/Driver/Driver.h"
19#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000020#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000022#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000023#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000024#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000026#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000029#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
David Blaikie24bbfed22014-03-31 23:29:38 +000032#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000033#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000034#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000035#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000036#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000037#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000038#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000039#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/Support/raw_ostream.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000041
Daniel Dunbar1a093d22009-03-18 06:00:36 +000042using namespace clang::driver;
43using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000044using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000045using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000046
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000047static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
48 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
49 options::OPT_fpic, options::OPT_fno_pic,
50 options::OPT_fPIE, options::OPT_fno_PIE,
51 options::OPT_fpie, options::OPT_fno_pie);
52 if (!LastPICArg)
53 return;
54 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
55 LastPICArg->getOption().matches(options::OPT_fpic) ||
56 LastPICArg->getOption().matches(options::OPT_fPIE) ||
57 LastPICArg->getOption().matches(options::OPT_fpie)) {
58 CmdArgs.push_back("-KPIC");
59 }
60}
61
Daniel Dunbar64198ef2009-09-10 01:21:05 +000062/// CheckPreprocessingOptions - Perform some validation of preprocessing
63/// arguments that is shared with gcc.
64static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000065 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
66 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
67 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000068 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000069 << A->getBaseArg().getAsString(Args)
70 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
71 }
72 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000073}
74
Daniel Dunbar4eadb602009-09-10 01:21:12 +000075/// CheckCodeGenerationOptions - Perform some validation of code generation
76/// arguments that is shared with gcc.
77static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
78 // In gcc, only ARM checks this, but it seems reasonable to check universally.
79 if (Args.hasArg(options::OPT_static))
80 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
81 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000082 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000083 << A->getAsString(Args) << "-static";
84}
85
Chris Lattnerbf2803f2010-03-29 17:55:58 +000086// Quote target names for inclusion in GNU Make dependency files.
87// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000088static void QuoteTarget(StringRef Target,
89 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000090 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
91 switch (Target[i]) {
92 case ' ':
93 case '\t':
94 // Escape the preceding backslashes
95 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
96 Res.push_back('\\');
97
98 // Escape the space/tab
99 Res.push_back('\\');
100 break;
101 case '$':
102 Res.push_back('$');
103 break;
104 case '#':
105 Res.push_back('\\');
106 break;
107 default:
108 break;
109 }
110
111 Res.push_back(Target[i]);
112 }
113}
114
Bill Wendlingc0938f32012-03-12 22:10:06 +0000115static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000116 ArgStringList &CmdArgs,
117 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000118 const char *EnvVar) {
119 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000120 bool CombinedArg = false;
121
Bill Wendling281ca292012-03-12 21:22:35 +0000122 if (!DirList)
123 return; // Nothing to do.
124
Chad Rosier616e8a52012-10-30 21:42:09 +0000125 StringRef Name(ArgName);
126 if (Name.equals("-I") || Name.equals("-L"))
127 CombinedArg = true;
128
Bill Wendling281ca292012-03-12 21:22:35 +0000129 StringRef Dirs(DirList);
130 if (Dirs.empty()) // Empty string should not add '.'.
131 return;
132
133 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000134 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000135 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000136 if (CombinedArg) {
137 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
138 } else {
139 CmdArgs.push_back(ArgName);
140 CmdArgs.push_back(".");
141 }
Bill Wendling281ca292012-03-12 21:22:35 +0000142 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000143 if (CombinedArg) {
144 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
145 } else {
146 CmdArgs.push_back(ArgName);
147 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
148 }
Bill Wendling281ca292012-03-12 21:22:35 +0000149 }
Nico Weber89355782012-03-19 15:00:03 +0000150 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000151 }
152
153 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000154 if (CombinedArg) {
155 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
156 } else {
157 CmdArgs.push_back(ArgName);
158 CmdArgs.push_back(".");
159 }
Bill Wendling281ca292012-03-12 21:22:35 +0000160 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000161 if (CombinedArg) {
162 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
163 } else {
164 CmdArgs.push_back(ArgName);
165 CmdArgs.push_back(Args.MakeArgString(Dirs));
166 }
Bill Wendling281ca292012-03-12 21:22:35 +0000167 }
168}
169
Daniel Dunbar54423b22010-09-17 00:24:54 +0000170static void AddLinkerInputs(const ToolChain &TC,
171 const InputInfoList &Inputs, const ArgList &Args,
172 ArgStringList &CmdArgs) {
173 const Driver &D = TC.getDriver();
174
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000175 // Add extra linker input arguments which are not treated as inputs
176 // (constructed via -Xarch_).
177 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
178
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000179 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000180 if (!TC.HasNativeLLVMSupport()) {
181 // Don't try to pass LLVM inputs unless we have native support.
182 if (II.getType() == types::TY_LLVM_IR ||
183 II.getType() == types::TY_LTO_IR ||
184 II.getType() == types::TY_LLVM_BC ||
185 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000186 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000187 << TC.getTripleString();
188 }
189
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000190 // Add filenames immediately.
191 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000192 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000193 continue;
194 }
195
196 // Otherwise, this is a linker input argument.
197 const Arg &A = II.getInputArg();
198
199 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000200 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000201 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000202 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000203 TC.AddCCKextLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000204 else
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000205 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000206 }
Bill Wendling281ca292012-03-12 21:22:35 +0000207
208 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000209 // and only supported on native toolchains.
210 if (!TC.isCrossCompiling())
211 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000212}
213
John McCall31168b02011-06-15 23:02:42 +0000214/// \brief Determine whether Objective-C automated reference counting is
215/// enabled.
216static bool isObjCAutoRefCount(const ArgList &Args) {
217 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
218}
219
Ted Kremeneke65b0862012-03-06 20:05:56 +0000220/// \brief Determine whether we are linking the ObjC runtime.
221static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000222 if (isObjCAutoRefCount(Args)) {
223 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000224 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000225 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000226 return Args.hasArg(options::OPT_fobjc_link_runtime);
227}
228
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000229static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000230 // Don't forward inputs from the original command line. They are added from
231 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000232 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000233 !O.hasFlag(options::DriverOption) &&
234 !O.hasFlag(options::LinkerInput);
235}
236
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000237void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000238 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000239 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000240 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000241 ArgStringList &CmdArgs,
242 const InputInfo &Output,
243 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000244 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000245
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000246 CheckPreprocessingOptions(D, Args);
247
248 Args.AddLastArg(CmdArgs, options::OPT_C);
249 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000250
251 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000252 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000253 (A = Args.getLastArg(options::OPT_MD)) ||
254 (A = Args.getLastArg(options::OPT_MMD))) {
255 // Determine the output location.
256 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000257 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000258 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000259 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000260 } else if (Output.getType() == types::TY_Dependencies) {
261 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000262 } else if (A->getOption().matches(options::OPT_M) ||
263 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000264 DepFile = "-";
265 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000266 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000267 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000268 }
269 CmdArgs.push_back("-dependency-file");
270 CmdArgs.push_back(DepFile);
271
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000272 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000273 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
274 const char *DepTarget;
275
276 // If user provided -o, that is the dependency target, except
277 // when we are only generating a dependency file.
278 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
279 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000280 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000281 } else {
282 // Otherwise derive from the base input.
283 //
284 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000285 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000286 llvm::sys::path::replace_extension(P, "o");
287 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000288 }
289
290 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000291 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000292 QuoteTarget(DepTarget, Quoted);
293 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000294 }
295
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000296 if (A->getOption().matches(options::OPT_M) ||
297 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000298 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000299
300 if (isa<PrecompileJobAction>(JA))
301 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 }
303
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000304 if (Args.hasArg(options::OPT_MG)) {
305 if (!A || A->getOption().matches(options::OPT_MD) ||
306 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000307 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000308 CmdArgs.push_back("-MG");
309 }
310
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000311 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000312
313 // Convert all -MQ <target> args to -MT <quoted target>
314 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
315 options::OPT_MQ),
316 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000317 const Arg *A = *it;
318 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000319
Daniel Dunbara442fd52010-06-11 22:00:13 +0000320 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000321 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000322 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000323 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000324 CmdArgs.push_back(Args.MakeArgString(Quoted));
325
326 // -MT flag - no change
327 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000328 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000329 }
330 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000331
Douglas Gregor111af7d2009-04-18 00:34:01 +0000332 // Add -i* options, and automatically translate to
333 // -include-pch/-include-pth for transparent PCH support. It's
334 // wonky, but we include looking for .gch so we can support seamless
335 // replacement into a build system already set up to be generating
336 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000337 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000338 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
339 ie = Args.filtered_end(); it != ie; ++it) {
340 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000341
342 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000343 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
344 RenderedImplicitInclude = true;
345
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000346 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000347 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000348
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000349 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000350 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000351 SmallString<128> P(A->getValue());
352 // We want the files to have a name like foo.h.pch. Add a dummy extension
353 // so that replace_extension does the right thing.
354 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000355 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000356 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000357 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000358 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000359 }
360
Douglas Gregor111af7d2009-04-18 00:34:01 +0000361 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000362 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000363 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000364 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000365 }
366
Douglas Gregor111af7d2009-04-18 00:34:01 +0000367 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000368 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000369 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000370 FoundPCH = UsePCH;
371 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000373 }
374
375 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000376 if (IsFirstImplicitInclude) {
377 A->claim();
378 if (UsePCH)
379 CmdArgs.push_back("-include-pch");
380 else
381 CmdArgs.push_back("-include-pth");
382 CmdArgs.push_back(Args.MakeArgString(P.str()));
383 continue;
384 } else {
385 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000386 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000387 << P.str() << A->getAsString(Args);
388 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000389 }
390 }
391
392 // Not translated, render as usual.
393 A->claim();
394 A->render(Args, CmdArgs);
395 }
396
397 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000398 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
399 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000400
401 // Add -Wp, and -Xassembler if using the preprocessor.
402
403 // FIXME: There is a very unfortunate problem here, some troubled
404 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
405 // really support that we would have to parse and then translate
406 // those options. :(
407 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
408 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000409
410 // -I- is a deprecated GCC feature, reject it.
411 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000412 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000413
414 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
415 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000416 StringRef sysroot = C.getSysRoot();
417 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000418 if (!Args.hasArg(options::OPT_isysroot)) {
419 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000420 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000421 }
422 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000423
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000424 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000425 // FIXME: We should probably sink the logic for handling these from the
426 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000427 // CPATH - included following the user specified includes (but prior to
428 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000429 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000430 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000431 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000432 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000433 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000434 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000435 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000436 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000437 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000438
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000439 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000440 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000441 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000442
443 // Add system include arguments.
444 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000445}
446
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000447// FIXME: Move to target hook.
448static bool isSignedCharDefault(const llvm::Triple &Triple) {
449 switch (Triple.getArch()) {
450 default:
451 return true;
452
Tim Northover9bb857a2013-01-31 12:13:10 +0000453 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000454 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +0000455 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +0000456 case llvm::Triple::arm64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000457 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000458 case llvm::Triple::armeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000459 if (Triple.isOSDarwin() || Triple.isOSWindows())
460 return true;
461 return false;
462
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000463 case llvm::Triple::ppc:
464 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000465 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000466 return true;
467 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000468
Bill Schmidt778d3872013-07-26 01:36:11 +0000469 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000470 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000471 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000472 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000473 }
474}
475
Robert Lytton0e076492013-08-13 09:43:10 +0000476static bool isNoCommonDefault(const llvm::Triple &Triple) {
477 switch (Triple.getArch()) {
478 default:
479 return false;
480
481 case llvm::Triple::xcore:
482 return true;
483 }
484}
485
Chad Rosiercfbfc582012-04-04 20:51:35 +0000486// Handle -mfpu=.
487//
488// FIXME: Centralize feature selection, defaulting shouldn't be also in the
489// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000490static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
491 const ArgList &Args,
492 std::vector<const char *> &Features) {
493 StringRef FPU = A->getValue();
494 if (FPU == "fp-armv8") {
495 Features.push_back("+fp-armv8");
496 } else if (FPU == "neon-fp-armv8") {
497 Features.push_back("+fp-armv8");
498 Features.push_back("+neon");
499 } else if (FPU == "crypto-neon-fp-armv8") {
500 Features.push_back("+fp-armv8");
501 Features.push_back("+neon");
502 Features.push_back("+crypto");
503 } else if (FPU == "neon") {
504 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000505 } else
506 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
507}
508
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000509// Handle -mhwdiv=.
510static void getARMHWDivFeatures(const Driver &D, const Arg *A,
511 const ArgList &Args,
512 std::vector<const char *> &Features) {
513 StringRef HWDiv = A->getValue();
514 if (HWDiv == "arm") {
515 Features.push_back("+hwdiv-arm");
516 Features.push_back("-hwdiv");
517 } else if (HWDiv == "thumb") {
518 Features.push_back("-hwdiv-arm");
519 Features.push_back("+hwdiv");
520 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
521 Features.push_back("+hwdiv-arm");
522 Features.push_back("+hwdiv");
523 } else if (HWDiv == "none") {
524 Features.push_back("-hwdiv-arm");
525 Features.push_back("-hwdiv");
526 } else
527 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
528}
529
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000530// Handle -mfpu=.
531//
532// FIXME: Centralize feature selection, defaulting shouldn't be also in the
533// frontend target.
534static void getARMFPUFeatures(const Driver &D, const Arg *A,
535 const ArgList &Args,
536 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000537 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000538
539 // Set the target features based on the FPU.
540 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
541 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000542 Features.push_back("-vfp2");
543 Features.push_back("-vfp3");
544 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000545 } else if (FPU == "vfp") {
546 Features.push_back("+vfp2");
547 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000548 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000549 Features.push_back("+vfp3");
550 Features.push_back("+d16");
551 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000552 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000553 Features.push_back("+vfp3");
554 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000555 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
556 Features.push_back("+vfp4");
557 Features.push_back("+d16");
558 Features.push_back("-neon");
559 } else if (FPU == "vfp4" || FPU == "vfpv4") {
560 Features.push_back("+vfp4");
561 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000562 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
563 Features.push_back("+vfp4");
564 Features.push_back("+d16");
565 Features.push_back("+fp-only-sp");
566 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000567 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000568 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000569 Features.push_back("-neon");
570 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000571 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000572 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000573 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000574 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000575 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000576 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000577 Features.push_back("+neon");
578 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000579 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000580 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000581 } else if (FPU == "none") {
582 Features.push_back("-vfp2");
583 Features.push_back("-vfp3");
584 Features.push_back("-vfp4");
585 Features.push_back("-fp-armv8");
586 Features.push_back("-crypto");
587 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000588 } else
589 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
590}
591
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000592// Select the float ABI as determined by -msoft-float, -mhard-float, and
593// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000594StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
595 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000596 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000597 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
598 options::OPT_mhard_float,
599 options::OPT_mfloat_abi_EQ)) {
600 if (A->getOption().matches(options::OPT_msoft_float))
601 FloatABI = "soft";
602 else if (A->getOption().matches(options::OPT_mhard_float))
603 FloatABI = "hard";
604 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000605 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000606 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000607 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000608 << A->getAsString(Args);
609 FloatABI = "soft";
610 }
611 }
612 }
613
614 // If unspecified, choose the default based on the platform.
615 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000616 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000617 case llvm::Triple::Darwin:
618 case llvm::Triple::MacOSX:
619 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000620 // Darwin defaults to "softfp" for v6 and v7.
621 //
622 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000623 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000624 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000625 if (StringRef(ArchName).startswith("v6") ||
626 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000627 FloatABI = "softfp";
628 else
629 FloatABI = "soft";
630 break;
631 }
632
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000633 // FIXME: this is invalid for WindowsCE
634 case llvm::Triple::Win32:
635 FloatABI = "hard";
636 break;
637
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000638 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000639 switch(Triple.getEnvironment()) {
640 case llvm::Triple::GNUEABIHF:
641 FloatABI = "hard";
642 break;
643 default:
644 // FreeBSD defaults to soft float
645 FloatABI = "soft";
646 break;
647 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000648 break;
649
Daniel Dunbar78485922009-09-10 23:00:09 +0000650 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000651 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000652 case llvm::Triple::GNUEABIHF:
653 FloatABI = "hard";
654 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000655 case llvm::Triple::GNUEABI:
656 FloatABI = "softfp";
657 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000658 case llvm::Triple::EABIHF:
659 FloatABI = "hard";
660 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000661 case llvm::Triple::EABI:
662 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
663 FloatABI = "softfp";
664 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000665 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000666 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000667 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000668 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000669 FloatABI = "softfp";
670 else
671 FloatABI = "soft";
672 break;
673 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000674 default:
675 // Assume "soft", but warn the user we are guessing.
676 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000677 if (Triple.getOS() != llvm::Triple::UnknownOS ||
678 !Triple.isOSBinFormatMachO())
679 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000680 break;
681 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000682 }
683 }
684
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000685 return FloatABI;
686}
687
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000688static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
689 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000690 std::vector<const char *> &Features,
691 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000692 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000693 if (!ForAS) {
694 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
695 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
696 // stripped out by the ARM target. We should probably pass this a new
697 // -target-option, which is handled by the -cc1/-cc1as invocation.
698 //
699 // FIXME2: For consistency, it would be ideal if we set up the target
700 // machine state the same when using the frontend or the assembler. We don't
701 // currently do that for the assembler, we pass the options directly to the
702 // backend and never even instantiate the frontend TargetInfo. If we did,
703 // and used its handleTargetFeatures hook, then we could ensure the
704 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000705
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000706 // Use software floating point operations?
707 if (FloatABI == "soft")
708 Features.push_back("+soft-float");
709
710 // Use software floating point argument passing?
711 if (FloatABI != "hard")
712 Features.push_back("+soft-float-abi");
713 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000714
715 // Honor -mfpu=.
716 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000717 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000718 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
719 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000720
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000721 // Setting -msoft-float effectively disables NEON because of the GCC
722 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000723 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000724 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000725 // Also need to explicitly disable features which imply NEON.
726 Features.push_back("-crypto");
727 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000728
729 // En/disable crc
730 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
731 options::OPT_mnocrc)) {
732 if (A->getOption().matches(options::OPT_mcrc))
733 Features.push_back("+crc");
734 else
735 Features.push_back("-crc");
736 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000737}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000738
739void Clang::AddARMTargetArgs(const ArgList &Args,
740 ArgStringList &CmdArgs,
741 bool KernelOrKext) const {
742 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000743 // Get the effective triple, which takes into account the deployment target.
744 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
745 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000746 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000747
748 // Select the ABI to use.
749 //
750 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000751 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000752 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000753 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000754 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000755 // The backend is hardwired to assume AAPCS for M-class processors, ensure
756 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000757 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000758 (Triple.getOS() == llvm::Triple::UnknownOS &&
759 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000760 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000761 ABIName = "aapcs";
762 } else {
763 ABIName = "apcs-gnu";
764 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000765 } else if (Triple.isOSWindows()) {
766 // FIXME: this is invalid for WindowsCE
767 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000768 } else {
769 // Select the default based on the platform.
770 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000771 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000772 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000773 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000774 ABIName = "aapcs-linux";
775 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000776 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000777 case llvm::Triple::EABI:
778 ABIName = "aapcs";
779 break;
780 default:
781 ABIName = "apcs-gnu";
782 }
783 }
784 CmdArgs.push_back("-target-abi");
785 CmdArgs.push_back(ABIName);
786
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000787 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000788 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000789 if (FloatABI == "soft") {
790 // Floating point operations and argument passing are soft.
791 //
792 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000793 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000794 CmdArgs.push_back("-mfloat-abi");
795 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000796 } else if (FloatABI == "softfp") {
797 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000798 CmdArgs.push_back("-mfloat-abi");
799 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000800 } else {
801 // Floating point operations and argument passing are hard.
802 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000803 CmdArgs.push_back("-mfloat-abi");
804 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000805 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000806
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000807 // Kernel code has more strict alignment requirements.
808 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000809 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000810 CmdArgs.push_back("-backend-option");
811 CmdArgs.push_back("-arm-long-calls");
812 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000813
Daniel Dunbar12100e22011-03-22 16:48:17 +0000814 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000815 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000816
817 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000818 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000819 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000820 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000821
822 // Setting -mno-global-merge disables the codegen global merge pass. Setting
823 // -mglobal-merge has no effect as the pass is enabled by default.
824 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
825 options::OPT_mno_global_merge)) {
826 if (A->getOption().matches(options::OPT_mno_global_merge))
827 CmdArgs.push_back("-mno-global-merge");
828 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000829
Bob Wilson9c8af452013-04-11 18:53:25 +0000830 if (!Args.hasFlag(options::OPT_mimplicit_float,
831 options::OPT_mno_implicit_float,
832 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000833 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000834
Logan Chien749763e2014-04-03 13:12:44 +0000835 // llvm does not support reserving registers in general. There is support
836 // for reserving r9 on ARM though (defined as a platform-specific register
837 // in ARM EABI).
838 if (Args.hasArg(options::OPT_ffixed_r9)) {
839 CmdArgs.push_back("-backend-option");
840 CmdArgs.push_back("-arm-reserve-r9");
841 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000842}
843
Tim Northover573cbee2014-05-24 12:52:07 +0000844/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
845/// targeting.
846static std::string getAArch64TargetCPU(const ArgList &Args) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000847 // If we have -mcpu=, use that.
848 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
849 StringRef MCPU = A->getValue();
850 // Handle -mcpu=native.
851 if (MCPU == "native")
852 return llvm::sys::getHostCPUName();
853 else
854 return MCPU;
855 }
856
857 // At some point, we may need to check -march here, but for now we only
858 // one arm64 architecture.
859
James Molloy9b1586b2014-04-17 12:51:17 +0000860 // Make sure we pick "cyclone" if -arch is used.
861 // FIXME: Should this be picked by checking the target triple instead?
862 if (Args.getLastArg(options::OPT_arch))
863 return "cyclone";
864
865 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000866}
867
Tim Northover573cbee2014-05-24 12:52:07 +0000868void Clang::AddAArch64TargetArgs(const ArgList &Args,
869 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000870 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
871 llvm::Triple Triple(TripleStr);
872
873 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
874 Args.hasArg(options::OPT_mkernel) ||
875 Args.hasArg(options::OPT_fapple_kext))
876 CmdArgs.push_back("-disable-red-zone");
877
878 if (!Args.hasFlag(options::OPT_mimplicit_float,
879 options::OPT_mno_implicit_float, true))
880 CmdArgs.push_back("-no-implicit-float");
881
Craig Topper92fc2df2014-05-17 16:56:41 +0000882 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000883 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
884 ABIName = A->getValue();
885 else if (Triple.isOSDarwin())
886 ABIName = "darwinpcs";
887 else
888 ABIName = "aapcs";
889
890 CmdArgs.push_back("-target-abi");
891 CmdArgs.push_back(ABIName);
892
893 CmdArgs.push_back("-target-cpu");
Tim Northover573cbee2014-05-24 12:52:07 +0000894 CmdArgs.push_back(Args.MakeArgString(getAArch64TargetCPU(Args)));
Tim Northovera2ee4332014-03-29 15:09:45 +0000895
896 if (Args.hasArg(options::OPT_mstrict_align)) {
897 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +0000898 CmdArgs.push_back("-aarch64-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000899 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000900
901 // Setting -mno-global-merge disables the codegen global merge pass. Setting
902 // -mglobal-merge has no effect as the pass is enabled by default.
903 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
904 options::OPT_mno_global_merge)) {
905 if (A->getOption().matches(options::OPT_mno_global_merge))
906 CmdArgs.push_back("-mno-global-merge");
907 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000908}
909
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000910// Get CPU and ABI names. They are not independent
911// so we have to calculate them together.
912static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000913 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000914 StringRef &CPUName,
915 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000916 const char *DefMips32CPU = "mips32r2";
917 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000918
Daniel Sanders2bf13662014-07-10 14:40:57 +0000919 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
920 // default for mips64(el)?-img-linux-gnu.
921 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
922 Triple.getEnvironment() == llvm::Triple::GNU) {
923 DefMips32CPU = "mips32r6";
924 DefMips64CPU = "mips64r6";
925 }
926
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000927 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000928 options::OPT_mcpu_EQ))
929 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000930
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000931 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000932 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000933 // Convert a GNU style Mips ABI name to the name
934 // accepted by LLVM Mips backend.
935 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
936 .Case("32", "o32")
937 .Case("64", "n64")
938 .Default(ABIName);
939 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000940
941 // Setup default CPU and ABI names.
942 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000943 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000944 default:
945 llvm_unreachable("Unexpected triple arch name");
946 case llvm::Triple::mips:
947 case llvm::Triple::mipsel:
948 CPUName = DefMips32CPU;
949 break;
950 case llvm::Triple::mips64:
951 case llvm::Triple::mips64el:
952 CPUName = DefMips64CPU;
953 break;
954 }
955 }
956
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000957 if (ABIName.empty()) {
958 // Deduce ABI name from the target triple.
959 if (Triple.getArch() == llvm::Triple::mips ||
960 Triple.getArch() == llvm::Triple::mipsel)
961 ABIName = "o32";
962 else
963 ABIName = "n64";
964 }
965
966 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000967 // Deduce CPU name from ABI name.
968 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000969 .Cases("o32", "eabi", DefMips32CPU)
970 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000971 .Default("");
972 }
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000973}
974
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000975// Convert ABI name to the GNU tools acceptable variant.
976static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
977 return llvm::StringSwitch<llvm::StringRef>(ABI)
978 .Case("o32", "32")
979 .Case("n64", "64")
980 .Default(ABI);
981}
982
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000983// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
984// and -mfloat-abi=.
985static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000986 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000987 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000988 options::OPT_mhard_float,
989 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000990 if (A->getOption().matches(options::OPT_msoft_float))
991 FloatABI = "soft";
992 else if (A->getOption().matches(options::OPT_mhard_float))
993 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000994 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000995 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000996 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000997 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000998 FloatABI = "hard";
999 }
1000 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001001 }
1002
1003 // If unspecified, choose the default based on the platform.
1004 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001005 // Assume "hard", because it's a default value used by gcc.
1006 // When we start to recognize specific target MIPS processors,
1007 // we will be able to select the default more correctly.
1008 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001009 }
1010
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001011 return FloatABI;
1012}
1013
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001014static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001015 std::vector<const char *> &Features,
1016 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001017 StringRef FeatureName) {
1018 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001019 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001020 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001021 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001022 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001023 }
1024}
1025
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001026static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1027 std::vector<const char *> &Features) {
1028 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001029 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001030 // FIXME: Note, this is a hack. We need to pass the selected float
1031 // mode to the MipsTargetInfoBase to define appropriate macros there.
1032 // Now it is the only method.
1033 Features.push_back("+soft-float");
1034 }
1035
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001036 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001037 StringRef Val = StringRef(A->getValue());
1038 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001039 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001040 else if (Val == "legacy")
1041 Features.push_back("-nan2008");
1042 else
1043 D.Diag(diag::err_drv_unsupported_option_argument)
1044 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001045 }
1046
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001047 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1048 options::OPT_mdouble_float, "single-float");
1049 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1050 "mips16");
1051 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1052 options::OPT_mno_micromips, "micromips");
1053 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1054 "dsp");
1055 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1056 "dspr2");
1057 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1058 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +00001059 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1060 "fp64");
Daniel Sanders28e5d392014-07-10 10:39:51 +00001061 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1062 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001063}
1064
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001065void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001066 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001067 const Driver &D = getToolChain().getDriver();
1068 StringRef CPUName;
1069 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001070 const llvm::Triple &Triple = getToolChain().getTriple();
1071 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001072
1073 CmdArgs.push_back("-target-abi");
1074 CmdArgs.push_back(ABIName.data());
1075
1076 StringRef FloatABI = getMipsFloatABI(D, Args);
1077
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001078 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001079 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001080 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001081 CmdArgs.push_back("-mfloat-abi");
1082 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001083 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001084 else {
1085 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001086 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001087 CmdArgs.push_back("-mfloat-abi");
1088 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001089 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001090
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001091 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1092 if (A->getOption().matches(options::OPT_mxgot)) {
1093 CmdArgs.push_back("-mllvm");
1094 CmdArgs.push_back("-mxgot");
1095 }
1096 }
1097
Simon Atanasyanc580b322013-05-11 06:33:44 +00001098 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1099 options::OPT_mno_ldc1_sdc1)) {
1100 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1101 CmdArgs.push_back("-mllvm");
1102 CmdArgs.push_back("-mno-ldc1-sdc1");
1103 }
1104 }
1105
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001106 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1107 options::OPT_mno_check_zero_division)) {
1108 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1109 CmdArgs.push_back("-mllvm");
1110 CmdArgs.push_back("-mno-check-zero-division");
1111 }
1112 }
1113
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001114 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001115 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001116 CmdArgs.push_back("-mllvm");
1117 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1118 A->claim();
1119 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001120}
1121
Hal Finkel8eb59282012-06-11 22:35:19 +00001122/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1123static std::string getPPCTargetCPU(const ArgList &Args) {
1124 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001125 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001126
1127 if (CPUName == "native") {
1128 std::string CPU = llvm::sys::getHostCPUName();
1129 if (!CPU.empty() && CPU != "generic")
1130 return CPU;
1131 else
1132 return "";
1133 }
1134
1135 return llvm::StringSwitch<const char *>(CPUName)
1136 .Case("common", "generic")
1137 .Case("440", "440")
1138 .Case("440fp", "440")
1139 .Case("450", "450")
1140 .Case("601", "601")
1141 .Case("602", "602")
1142 .Case("603", "603")
1143 .Case("603e", "603e")
1144 .Case("603ev", "603ev")
1145 .Case("604", "604")
1146 .Case("604e", "604e")
1147 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001148 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001149 .Case("G3", "g3")
1150 .Case("7400", "7400")
1151 .Case("G4", "g4")
1152 .Case("7450", "7450")
1153 .Case("G4+", "g4+")
1154 .Case("750", "750")
1155 .Case("970", "970")
1156 .Case("G5", "g5")
1157 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001158 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001159 .Case("e500mc", "e500mc")
1160 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001161 .Case("power3", "pwr3")
1162 .Case("power4", "pwr4")
1163 .Case("power5", "pwr5")
1164 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001165 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001166 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001167 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001168 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001169 .Case("pwr3", "pwr3")
1170 .Case("pwr4", "pwr4")
1171 .Case("pwr5", "pwr5")
1172 .Case("pwr5x", "pwr5x")
1173 .Case("pwr6", "pwr6")
1174 .Case("pwr6x", "pwr6x")
1175 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001176 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001177 .Case("powerpc", "ppc")
1178 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001179 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001180 .Default("");
1181 }
1182
1183 return "";
1184}
1185
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001186static void getPPCTargetFeatures(const ArgList &Args,
1187 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001188 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1189 ie = Args.filtered_end();
1190 it != ie; ++it) {
1191 StringRef Name = (*it)->getOption().getName();
1192 (*it)->claim();
1193
1194 // Skip over "-m".
1195 assert(Name.startswith("m") && "Invalid feature name.");
1196 Name = Name.substr(1);
1197
1198 bool IsNegative = Name.startswith("no-");
1199 if (IsNegative)
1200 Name = Name.substr(3);
1201
1202 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1203 // pass the correct option to the backend while calling the frontend
1204 // option the same.
1205 // TODO: Change the LLVM backend option maybe?
1206 if (Name == "mfcrf")
1207 Name = "mfocrf";
1208
1209 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1210 }
1211
1212 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001213 AddTargetFeature(Args, Features, options::OPT_faltivec,
1214 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001215}
1216
Tom Stellard6674c702013-04-01 20:56:53 +00001217/// Get the (LLVM) name of the R600 gpu we are targeting.
1218static std::string getR600TargetGPU(const ArgList &Args) {
1219 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001220 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001221 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001222 .Cases("rv630", "rv635", "r600")
1223 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001224 .Case("rv740", "rv770")
1225 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001226 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001227 .Case("hemlock", "cypress")
1228 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001229 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001230 }
1231 return "";
1232}
1233
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001234static void getSparcTargetFeatures(const ArgList &Args,
1235 std::vector<const char *> Features) {
1236 bool SoftFloatABI = true;
1237 if (Arg *A =
1238 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1239 if (A->getOption().matches(options::OPT_mhard_float))
1240 SoftFloatABI = false;
1241 }
1242 if (SoftFloatABI)
1243 Features.push_back("+soft-float");
1244}
1245
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001246void Clang::AddSparcTargetArgs(const ArgList &Args,
1247 ArgStringList &CmdArgs) const {
1248 const Driver &D = getToolChain().getDriver();
1249
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001250 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001251 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001252 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1253 options::OPT_mhard_float)) {
1254 if (A->getOption().matches(options::OPT_msoft_float))
1255 FloatABI = "soft";
1256 else if (A->getOption().matches(options::OPT_mhard_float))
1257 FloatABI = "hard";
1258 }
1259
1260 // If unspecified, choose the default based on the platform.
1261 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001262 // Assume "soft", but warn the user we are guessing.
1263 FloatABI = "soft";
1264 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001265 }
1266
1267 if (FloatABI == "soft") {
1268 // Floating point operations and argument passing are soft.
1269 //
1270 // FIXME: This changes CPP defines, we need -target-soft-float.
1271 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001272 } else {
1273 assert(FloatABI == "hard" && "Invalid float abi!");
1274 CmdArgs.push_back("-mhard-float");
1275 }
1276}
1277
Richard Sandiford4652d892013-07-19 16:51:51 +00001278static const char *getSystemZTargetCPU(const ArgList &Args) {
1279 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1280 return A->getValue();
1281 return "z10";
1282}
1283
Chandler Carruth953fb082013-01-13 11:46:33 +00001284static const char *getX86TargetCPU(const ArgList &Args,
1285 const llvm::Triple &Triple) {
1286 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001287 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001288 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001289 return "core-avx2";
1290
Chandler Carruth953fb082013-01-13 11:46:33 +00001291 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001292 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001293
1294 // FIXME: Reject attempts to use -march=native unless the target matches
1295 // the host.
1296 //
1297 // FIXME: We should also incorporate the detected target features for use
1298 // with -native.
1299 std::string CPU = llvm::sys::getHostCPUName();
1300 if (!CPU.empty() && CPU != "generic")
1301 return Args.MakeArgString(CPU);
1302 }
1303
1304 // Select the default CPU if none was given (or detection failed).
1305
1306 if (Triple.getArch() != llvm::Triple::x86_64 &&
1307 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001308 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001309
1310 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1311
1312 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001313 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001314 if (Triple.getArchName() == "x86_64h")
1315 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001316 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001317 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001318
Alexey Bataev286d1b92014-01-31 04:07:13 +00001319 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001320 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001321 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001322
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001323 // Everything else goes to x86-64 in 64-bit mode.
1324 if (Is64Bit)
1325 return "x86-64";
1326
1327 switch (Triple.getOS()) {
1328 case llvm::Triple::FreeBSD:
1329 case llvm::Triple::NetBSD:
1330 case llvm::Triple::OpenBSD:
1331 return "i486";
1332 case llvm::Triple::Haiku:
1333 return "i586";
1334 case llvm::Triple::Bitrig:
1335 return "i686";
1336 default:
1337 // Fallback to p4.
1338 return "pentium4";
1339 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001340}
1341
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001342static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1343 switch(T.getArch()) {
1344 default:
1345 return "";
1346
Amara Emerson703da2e2013-10-31 09:32:33 +00001347 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001348 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001349 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001350 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001351 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001352
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001353 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001354 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001355 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001356 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001357 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001358
1359 case llvm::Triple::mips:
1360 case llvm::Triple::mipsel:
1361 case llvm::Triple::mips64:
1362 case llvm::Triple::mips64el: {
1363 StringRef CPUName;
1364 StringRef ABIName;
1365 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1366 return CPUName;
1367 }
1368
1369 case llvm::Triple::ppc:
1370 case llvm::Triple::ppc64:
1371 case llvm::Triple::ppc64le: {
1372 std::string TargetCPUName = getPPCTargetCPU(Args);
1373 // LLVM may default to generating code for the native CPU,
1374 // but, like gcc, we default to a more generic option for
1375 // each architecture. (except on Darwin)
1376 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1377 if (T.getArch() == llvm::Triple::ppc64)
1378 TargetCPUName = "ppc64";
1379 else if (T.getArch() == llvm::Triple::ppc64le)
1380 TargetCPUName = "ppc64le";
1381 else
1382 TargetCPUName = "ppc";
1383 }
1384 return TargetCPUName;
1385 }
1386
1387 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001388 case llvm::Triple::sparcv9:
1389 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001390 return A->getValue();
1391 return "";
1392
1393 case llvm::Triple::x86:
1394 case llvm::Triple::x86_64:
1395 return getX86TargetCPU(Args, T);
1396
1397 case llvm::Triple::hexagon:
1398 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1399
1400 case llvm::Triple::systemz:
1401 return getSystemZTargetCPU(Args);
1402
1403 case llvm::Triple::r600:
1404 return getR600TargetGPU(Args);
1405 }
1406}
1407
Alp Tokerce365ca2013-12-02 12:43:03 +00001408static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1409 ArgStringList &CmdArgs) {
1410 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1411 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1412 // forward.
1413 CmdArgs.push_back("-plugin");
1414 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1415 CmdArgs.push_back(Args.MakeArgString(Plugin));
1416
1417 // Try to pass driver level flags relevant to LTO code generation down to
1418 // the plugin.
1419
1420 // Handle flags for selecting CPU variants.
1421 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1422 if (!CPU.empty())
1423 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1424}
1425
Jim Grosbach82eee262013-11-16 00:53:35 +00001426static void getX86TargetFeatures(const llvm::Triple &Triple,
1427 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001428 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001429 if (Triple.getArchName() == "x86_64h") {
1430 // x86_64h implies quite a few of the more modern subtarget features
1431 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1432 Features.push_back("-rdrnd");
1433 Features.push_back("-aes");
1434 Features.push_back("-pclmul");
1435 Features.push_back("-rtm");
1436 Features.push_back("-hle");
1437 Features.push_back("-fsgsbase");
1438 }
1439
Alexey Volkov54ff0802014-06-25 12:15:36 +00001440 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001441 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001442 if (Triple.getArch() == llvm::Triple::x86_64) {
1443 Features.push_back("+sse4.2");
1444 Features.push_back("+popcnt");
1445 } else
1446 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001447 }
1448
Jim Grosbach82eee262013-11-16 00:53:35 +00001449 // Now add any that the user explicitly requested on the command line,
1450 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001451 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1452 ie = Args.filtered_end();
1453 it != ie; ++it) {
1454 StringRef Name = (*it)->getOption().getName();
1455 (*it)->claim();
1456
1457 // Skip over "-m".
1458 assert(Name.startswith("m") && "Invalid feature name.");
1459 Name = Name.substr(1);
1460
1461 bool IsNegative = Name.startswith("no-");
1462 if (IsNegative)
1463 Name = Name.substr(3);
1464
1465 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1466 }
1467}
1468
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001469void Clang::AddX86TargetArgs(const ArgList &Args,
1470 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001471 if (!Args.hasFlag(options::OPT_mred_zone,
1472 options::OPT_mno_red_zone,
1473 true) ||
1474 Args.hasArg(options::OPT_mkernel) ||
1475 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001476 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001477
Bob Wilson2616e2e2013-02-10 16:01:41 +00001478 // Default to avoid implicit floating-point for kernel/kext code, but allow
1479 // that to be overridden with -mno-soft-float.
1480 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1481 Args.hasArg(options::OPT_fapple_kext));
1482 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1483 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001484 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001485 options::OPT_mno_implicit_float)) {
1486 const Option &O = A->getOption();
1487 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1488 O.matches(options::OPT_msoft_float));
1489 }
1490 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001491 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001492
1493 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1494 StringRef Value = A->getValue();
1495 if (Value == "intel" || Value == "att") {
1496 CmdArgs.push_back("-mllvm");
1497 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1498 } else {
1499 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1500 << A->getOption().getName() << Value;
1501 }
1502 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001503}
1504
Matthew Curtise8f80a12012-12-06 17:49:03 +00001505static inline bool HasPICArg(const ArgList &Args) {
1506 return Args.hasArg(options::OPT_fPIC)
1507 || Args.hasArg(options::OPT_fpic);
1508}
1509
1510static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1511 return Args.getLastArg(options::OPT_G,
1512 options::OPT_G_EQ,
1513 options::OPT_msmall_data_threshold_EQ);
1514}
1515
1516static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1517 std::string value;
1518 if (HasPICArg(Args))
1519 value = "0";
1520 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1521 value = A->getValue();
1522 A->claim();
1523 }
1524 return value;
1525}
1526
Tony Linthicum76329bf2011-12-12 21:14:55 +00001527void Clang::AddHexagonTargetArgs(const ArgList &Args,
1528 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001529 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001530 CmdArgs.push_back("-mqdsp6-compat");
1531 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001532
Matthew Curtise8f80a12012-12-06 17:49:03 +00001533 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1534 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001535 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001536 CmdArgs.push_back(Args.MakeArgString(
1537 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001538 }
1539
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001540 if (!Args.hasArg(options::OPT_fno_short_enums))
1541 CmdArgs.push_back("-fshort-enums");
1542 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1543 CmdArgs.push_back ("-mllvm");
1544 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1545 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001546 CmdArgs.push_back ("-mllvm");
1547 CmdArgs.push_back ("-machine-sink-split=0");
1548}
1549
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001550static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1551 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001552 // Honor -mfpu=.
1553 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001554 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001555 else
1556 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001557
1558 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1559 Features.push_back("-fp-armv8");
1560 Features.push_back("-crypto");
1561 Features.push_back("-neon");
1562 }
Bradley Smith418c5932014-05-02 15:17:51 +00001563
1564 // En/disable crc
1565 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1566 options::OPT_mnocrc)) {
1567 if (A->getOption().matches(options::OPT_mcrc))
1568 Features.push_back("+crc");
1569 else
1570 Features.push_back("-crc");
1571 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001572}
1573
1574static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001575 const ArgList &Args, ArgStringList &CmdArgs,
1576 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001577 std::vector<const char *> Features;
1578 switch (Triple.getArch()) {
1579 default:
1580 break;
1581 case llvm::Triple::mips:
1582 case llvm::Triple::mipsel:
1583 case llvm::Triple::mips64:
1584 case llvm::Triple::mips64el:
1585 getMIPSTargetFeatures(D, Args, Features);
1586 break;
1587
1588 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001589 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001590 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001591 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001592 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001593 break;
1594
1595 case llvm::Triple::ppc:
1596 case llvm::Triple::ppc64:
1597 case llvm::Triple::ppc64le:
1598 getPPCTargetFeatures(Args, Features);
1599 break;
1600 case llvm::Triple::sparc:
1601 getSparcTargetFeatures(Args, Features);
1602 break;
1603 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001604 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001605 case llvm::Triple::arm64:
1606 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001607 getAArch64TargetFeatures(D, Args, Features);
1608 break;
1609 case llvm::Triple::x86:
1610 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001611 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001612 break;
1613 }
Rafael Espindola43964802013-08-21 17:34:32 +00001614
1615 // Find the last of each feature.
1616 llvm::StringMap<unsigned> LastOpt;
1617 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1618 const char *Name = Features[I];
1619 assert(Name[0] == '-' || Name[0] == '+');
1620 LastOpt[Name + 1] = I;
1621 }
1622
1623 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1624 // If this feature was overridden, ignore it.
1625 const char *Name = Features[I];
1626 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1627 assert(LastI != LastOpt.end());
1628 unsigned Last = LastI->second;
1629 if (Last != I)
1630 continue;
1631
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001632 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001633 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001634 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001635}
1636
Eric Christopher84fbdb42011-08-19 00:30:14 +00001637static bool
John McCall5fb5df92012-06-20 06:18:46 +00001638shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001639 const llvm::Triple &Triple) {
1640 // We use the zero-cost exception tables for Objective-C if the non-fragile
1641 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1642 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001643 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001644 return true;
1645
Bob Wilson83e723a2013-12-05 19:38:42 +00001646 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001647 return false;
1648
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001649 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001650 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001651 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001652}
1653
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001654namespace {
1655 struct ExceptionSettings {
1656 bool ExceptionsEnabled;
1657 bool ShouldUseExceptionTables;
1658 ExceptionSettings() : ExceptionsEnabled(false),
1659 ShouldUseExceptionTables(false) {}
1660 };
1661} // end anonymous namespace.
1662
Nico Webere8e53112014-05-11 01:04:02 +00001663// exceptionSettings() exists to share the logic between -cc1 and linker
1664// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001665static ExceptionSettings exceptionSettings(const ArgList &Args,
1666 const llvm::Triple &Triple) {
1667 ExceptionSettings ES;
1668
1669 // Are exceptions enabled by default?
1670 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1671
1672 // This keeps track of whether exceptions were explicitly turned on or off.
1673 bool DidHaveExplicitExceptionFlag = false;
1674
1675 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1676 options::OPT_fno_exceptions)) {
1677 if (A->getOption().matches(options::OPT_fexceptions))
1678 ES.ExceptionsEnabled = true;
1679 else
1680 ES.ExceptionsEnabled = false;
1681
1682 DidHaveExplicitExceptionFlag = true;
1683 }
1684
1685 // Exception tables and cleanups can be enabled with -fexceptions even if the
1686 // language itself doesn't support exceptions.
1687 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1688 ES.ShouldUseExceptionTables = true;
1689
1690 return ES;
1691}
1692
Anders Carlssone96ab552011-02-28 02:27:16 +00001693/// addExceptionArgs - Adds exception related arguments to the driver command
1694/// arguments. There's a master flag, -fexceptions and also language specific
1695/// flags to enable/disable C++ and Objective-C exceptions.
1696/// This makes it possible to for example disable C++ exceptions but enable
1697/// Objective-C exceptions.
1698static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1699 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001700 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001701 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001702 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001703 if (KernelOrKext) {
1704 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1705 // arguments now to avoid warnings about unused arguments.
1706 Args.ClaimAllArgs(options::OPT_fexceptions);
1707 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1708 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1709 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1710 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1711 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001712 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001713 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001714
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001715 // Gather the exception settings from the command line arguments.
1716 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001717
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001718 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1719 // is not necessarily sensible, but follows GCC.
1720 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001721 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001722 options::OPT_fno_objc_exceptions,
1723 true)) {
1724 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001725
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001726 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001727 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001728 }
1729
1730 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001731 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001732
Eric Christopher84fbdb42011-08-19 00:30:14 +00001733 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1734 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001735 options::OPT_fexceptions,
1736 options::OPT_fno_exceptions)) {
1737 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1738 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001739 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001740 CXXExceptionsEnabled = false;
1741 }
1742
1743 if (CXXExceptionsEnabled) {
1744 CmdArgs.push_back("-fcxx-exceptions");
1745
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001746 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001747 }
1748 }
1749
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001750 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001751 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001752}
1753
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001754static bool ShouldDisableAutolink(const ArgList &Args,
1755 const ToolChain &TC) {
1756 bool Default = true;
1757 if (TC.getTriple().isOSDarwin()) {
1758 // The native darwin assembler doesn't support the linker_option directives,
1759 // so we disable them if we think the .s file will be passed to it.
1760 Default = TC.useIntegratedAs();
1761 }
1762 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1763 Default);
1764}
1765
Ted Kremenek62093662013-03-12 17:02:12 +00001766static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1767 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001768 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1769 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001770 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001771 return !UseDwarfDirectory;
1772}
1773
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001774/// \brief Check whether the given input tree contains any compilation actions.
1775static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001776 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001777 return true;
1778
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001779 for (const auto &Act : *A)
1780 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001781 return true;
1782
1783 return false;
1784}
1785
1786/// \brief Check if -relax-all should be passed to the internal assembler.
1787/// This is done by default when compiling non-assembler source with -O0.
1788static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1789 bool RelaxDefault = true;
1790
1791 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1792 RelaxDefault = A->getOption().matches(options::OPT_O0);
1793
1794 if (RelaxDefault) {
1795 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001796 for (const auto &Act : C.getActions()) {
1797 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001798 RelaxDefault = true;
1799 break;
1800 }
1801 }
1802 }
1803
1804 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1805 RelaxDefault);
1806}
1807
David Blaikie9260ed62013-07-25 21:19:01 +00001808static void CollectArgsForIntegratedAssembler(Compilation &C,
1809 const ArgList &Args,
1810 ArgStringList &CmdArgs,
1811 const Driver &D) {
1812 if (UseRelaxAll(C, Args))
1813 CmdArgs.push_back("-mrelax-all");
1814
David Peixottodfb66142013-11-14 22:52:58 +00001815 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001816 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001817 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1818 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1819 // arg after parsing the '-I' arg.
1820 bool TakeNextArg = false;
1821
David Blaikie9260ed62013-07-25 21:19:01 +00001822 // When using an integrated assembler, translate -Wa, and -Xassembler
1823 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001824 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001825 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1826 options::OPT_Xassembler),
1827 ie = Args.filtered_end(); it != ie; ++it) {
1828 const Arg *A = *it;
1829 A->claim();
1830
1831 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1832 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001833 if (TakeNextArg) {
1834 CmdArgs.push_back(Value.data());
1835 TakeNextArg = false;
1836 continue;
1837 }
David Blaikie9260ed62013-07-25 21:19:01 +00001838
1839 if (Value == "-force_cpusubtype_ALL") {
1840 // Do nothing, this is the default and we don't support anything else.
1841 } else if (Value == "-L") {
1842 CmdArgs.push_back("-msave-temp-labels");
1843 } else if (Value == "--fatal-warnings") {
1844 CmdArgs.push_back("-mllvm");
1845 CmdArgs.push_back("-fatal-assembler-warnings");
1846 } else if (Value == "--noexecstack") {
1847 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001848 } else if (Value == "-compress-debug-sections" ||
1849 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001850 CompressDebugSections = true;
1851 } else if (Value == "-nocompress-debug-sections" ||
1852 Value == "--nocompress-debug-sections") {
1853 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001854 } else if (Value.startswith("-I")) {
1855 CmdArgs.push_back(Value.data());
1856 // We need to consume the next argument if the current arg is a plain
1857 // -I. The next arg will be the include directory.
1858 if (Value == "-I")
1859 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00001860 } else if (Value.startswith("-gdwarf-")) {
1861 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00001862 } else {
1863 D.Diag(diag::err_drv_unsupported_option_argument)
1864 << A->getOption().getName() << Value;
1865 }
1866 }
1867 }
David Blaikie24bbfed22014-03-31 23:29:38 +00001868 if (CompressDebugSections) {
1869 if (llvm::zlib::isAvailable())
1870 CmdArgs.push_back("-compress-debug-sections");
1871 else
1872 D.Diag(diag::warn_debug_compression_unavailable);
1873 }
David Blaikie9260ed62013-07-25 21:19:01 +00001874}
1875
Renato Goline807c122014-01-31 11:47:28 +00001876// Until ARM libraries are build separately, we have them all in one library
1877static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001878 if (TC.getArch() == llvm::Triple::arm ||
1879 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00001880 return "arm";
1881 else
1882 return TC.getArchName();
1883}
1884
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001885static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1886 // The runtimes are located in the OS-specific resource directory.
1887 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001888 const llvm::Triple &Triple = TC.getTriple();
1889 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1890 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1891 "freebsd" : TC.getOS();
1892 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001893 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001894}
1895
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001896// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00001897// FIXME: Make sure we can also emit shared objects if they're requested
1898// and available, check for possible errors, etc.
1899static void addClangRTLinux(
1900 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001901 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001902 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
1903 getArchNameForCompilerRTLib(TC) +
1904 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00001905
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001906 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001907 CmdArgs.push_back("-lgcc_s");
1908 if (TC.getDriver().CCCIsCXX())
1909 CmdArgs.push_back("-lgcc_eh");
1910}
1911
Alexey Samsonov7811d192014-02-20 13:57:37 +00001912static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001913 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1914 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1915 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001916 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001917 Args.hasArg(options::OPT_fcreate_profile) ||
1918 Args.hasArg(options::OPT_coverage)))
1919 return;
1920
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001921 // -fprofile-instr-generate requires position-independent code to build with
1922 // shared objects. Link against the right archive.
1923 const char *Lib = "libclang_rt.profile-";
1924 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1925 Args.hasArg(options::OPT_shared))
1926 Lib = "libclang_rt.profile-pic-";
1927
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001928 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1929 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001930 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001931
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00001932 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00001933}
1934
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001935static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
1936 const StringRef Sanitizer,
1937 bool Shared) {
1938 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
1939 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
1940 const char *EnvSuffix =
1941 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001942 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1943 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001944 Twine("libclang_rt.") + Sanitizer + "-" +
1945 getArchNameForCompilerRTLib(TC) + EnvSuffix +
1946 (Shared ? ".so" : ".a"));
1947 return LibSanitizer;
1948}
1949
1950static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
1951 ArgStringList &CmdArgs,
1952 const StringRef Sanitizer,
1953 bool BeforeLibStdCXX,
1954 bool ExportSymbols = true,
1955 bool LinkDeps = true) {
1956 SmallString<128> LibSanitizer =
1957 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00001958
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001959 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1960 // etc.) so that the linker picks custom versions of the global 'operator
1961 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001962 // strategy of inserting it at the front of the link command. It also
1963 // needs to be forced to end up in the executable, so wrap it in
1964 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001965 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001966 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001967 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001968 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001969
1970 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1971 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1972
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001973 if (LinkDeps) {
1974 // Link sanitizer dependencies explicitly
1975 CmdArgs.push_back("-lpthread");
1976 CmdArgs.push_back("-lrt");
1977 CmdArgs.push_back("-lm");
1978 // There's no libdl on FreeBSD.
1979 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1980 CmdArgs.push_back("-ldl");
1981 }
Richard Smithf3e624c2013-03-23 00:30:08 +00001982
1983 // If possible, use a dynamic symbols file to export the symbols from the
1984 // runtime library. If we can't do so, use -export-dynamic instead to export
1985 // all symbols from the binary.
1986 if (ExportSymbols) {
1987 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1988 CmdArgs.push_back(
1989 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1990 else
1991 CmdArgs.push_back("-export-dynamic");
1992 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001993}
1994
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001995/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1996/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001997static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001998 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001999 if (Shared) {
2000 // Link dynamic runtime if necessary.
2001 SmallString<128> LibSanitizer =
2002 getSanitizerRTLibName(TC, "asan", Shared);
2003 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002004 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002005
2006 // Do not link static runtime to DSOs or if compiling for Android.
2007 if (Args.hasArg(options::OPT_shared) ||
2008 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
2009 return;
2010
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002011 if (Shared) {
2012 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
2013 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
2014 /*LinkDeps*/ false);
2015 } else {
2016 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2017 if (IsCXX)
2018 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2019 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002020}
2021
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002022/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2023/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002024static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2025 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002026 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002027 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002028}
2029
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002030/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2031/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002032static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2033 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002034 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002035 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002036}
2037
2038/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2039/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002040static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2041 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002042 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002043 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002044}
2045
Richard Smithe30752c2012-10-09 19:52:38 +00002046/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2047/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002048static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2049 ArgStringList &CmdArgs, bool IsCXX,
2050 bool HasOtherSanitizerRt) {
Alexey Samsonovc6496812014-06-30 20:27:16 +00002051 // Do not link runtime into shared libraries.
2052 if (Args.hasArg(options::OPT_shared))
2053 return;
Richard Smith4244ea92014-06-04 23:28:46 +00002054
Nick Lewycky24921692013-10-19 00:27:23 +00002055 // Need a copy of sanitizer_common. This could come from another sanitizer
2056 // runtime; if we're not including one, include our own copy.
2057 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002058 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002059
Alexey Samsonovc6496812014-06-30 20:27:16 +00002060 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, true);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002061
2062 // Only include the bits of the runtime which need a C++ ABI library if
2063 // we're linking in C++ mode.
2064 if (IsCXX)
Alexey Samsonovc6496812014-06-30 20:27:16 +00002065 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false, true);
Richard Smithe30752c2012-10-09 19:52:38 +00002066}
2067
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002068static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2069 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002070 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002071 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2072}
2073
2074// Should be called before we add C++ ABI library.
2075static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2076 ArgStringList &CmdArgs) {
2077 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2078 const Driver &D = TC.getDriver();
2079 if (Sanitize.needsUbsanRt())
2080 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2081 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2082 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2083 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002084 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002085 if (Sanitize.needsTsanRt())
2086 addTsanRT(TC, Args, CmdArgs);
2087 if (Sanitize.needsMsanRt())
2088 addMsanRT(TC, Args, CmdArgs);
2089 if (Sanitize.needsLsanRt())
2090 addLsanRT(TC, Args, CmdArgs);
2091 if (Sanitize.needsDfsanRt())
2092 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002093}
2094
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002095static bool shouldUseFramePointerForTarget(const ArgList &Args,
2096 const llvm::Triple &Triple) {
2097 switch (Triple.getArch()) {
2098 // Don't use a frame pointer on linux if optimizing for certain targets.
2099 case llvm::Triple::mips64:
2100 case llvm::Triple::mips64el:
2101 case llvm::Triple::mips:
2102 case llvm::Triple::mipsel:
2103 case llvm::Triple::systemz:
2104 case llvm::Triple::x86:
2105 case llvm::Triple::x86_64:
2106 if (Triple.isOSLinux())
2107 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2108 if (!A->getOption().matches(options::OPT_O0))
2109 return false;
2110 return true;
2111 case llvm::Triple::xcore:
2112 return false;
2113 default:
2114 return true;
2115 }
2116}
2117
Rafael Espindola224dd632011-12-14 21:02:23 +00002118static bool shouldUseFramePointer(const ArgList &Args,
2119 const llvm::Triple &Triple) {
2120 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2121 options::OPT_fomit_frame_pointer))
2122 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2123
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002124 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002125}
2126
Eric Christopherb7d97e92013-04-03 01:58:53 +00002127static bool shouldUseLeafFramePointer(const ArgList &Args,
2128 const llvm::Triple &Triple) {
2129 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2130 options::OPT_momit_leaf_frame_pointer))
2131 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2132
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002133 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002134}
2135
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002136/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002137static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002138 SmallString<128> cwd;
2139 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002140 CmdArgs.push_back("-fdebug-compilation-dir");
2141 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002142 }
2143}
2144
Eric Christopherd3804002013-02-22 20:12:52 +00002145static const char *SplitDebugName(const ArgList &Args,
2146 const InputInfoList &Inputs) {
2147 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2148 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2149 SmallString<128> T(FinalOutput->getValue());
2150 llvm::sys::path::replace_extension(T, "dwo");
2151 return Args.MakeArgString(T);
2152 } else {
2153 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002154 SmallString<128> T(
2155 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002156 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2157 llvm::sys::path::replace_extension(F, "dwo");
2158 T += F;
2159 return Args.MakeArgString(F);
2160 }
2161}
2162
2163static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2164 const Tool &T, const JobAction &JA,
2165 const ArgList &Args, const InputInfo &Output,
2166 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002167 ArgStringList ExtractArgs;
2168 ExtractArgs.push_back("--extract-dwo");
2169
2170 ArgStringList StripArgs;
2171 StripArgs.push_back("--strip-dwo");
2172
2173 // Grabbing the output of the earlier compile step.
2174 StripArgs.push_back(Output.getFilename());
2175 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002176 ExtractArgs.push_back(OutFile);
2177
2178 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002179 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002180
2181 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002182 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002183
2184 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002185 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002186}
2187
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002188/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002189/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2190static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002191 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002192 if (A->getOption().matches(options::OPT_O4) ||
2193 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002194 return true;
2195
2196 if (A->getOption().matches(options::OPT_O0))
2197 return false;
2198
2199 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2200
Rafael Espindola91780de2013-08-26 14:05:41 +00002201 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002202 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002203 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002204 return true;
2205
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002206 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002207 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002208 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002209
2210 unsigned OptLevel = 0;
2211 if (S.getAsInteger(10, OptLevel))
2212 return false;
2213
2214 return OptLevel > 1;
2215 }
2216
2217 return false;
2218}
2219
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002220/// Add -x lang to \p CmdArgs for \p Input.
2221static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2222 ArgStringList &CmdArgs) {
2223 // When using -verify-pch, we don't want to provide the type
2224 // 'precompiled-header' if it was inferred from the file extension
2225 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2226 return;
2227
2228 CmdArgs.push_back("-x");
2229 if (Args.hasArg(options::OPT_rewrite_objc))
2230 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2231 else
2232 CmdArgs.push_back(types::getTypeName(Input.getType()));
2233}
2234
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002235void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002236 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002237 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002238 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002239 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002240 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2241 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002242 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002243 ArgStringList CmdArgs;
2244
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002245 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002246 bool IsWindowsCygnus =
2247 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002248 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2249
Daniel Dunbare521a892009-03-31 20:53:55 +00002250 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2251
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002252 // Invoke ourselves in -cc1 mode.
2253 //
2254 // FIXME: Implement custom jobs for internal actions.
2255 CmdArgs.push_back("-cc1");
2256
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002257 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002258 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002259 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002260 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002261
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002262 const llvm::Triple TT(TripleStr);
2263 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2264 TT.getArch() == llvm::Triple::thumb)) {
2265 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2266 unsigned Version;
2267 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2268 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002269 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2270 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002271 }
2272
Tim Northover336f1892014-03-29 13:16:12 +00002273 // Push all default warning arguments that are specific to
2274 // the given target. These come before user provided warning options
2275 // are provided.
2276 getToolChain().addClangWarningOptions(CmdArgs);
2277
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002278 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002279 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002280
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002281 if (isa<AnalyzeJobAction>(JA)) {
2282 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2283 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002284 } else if (isa<MigrateJobAction>(JA)) {
2285 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002286 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002287 if (Output.getType() == types::TY_Dependencies)
2288 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002289 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002290 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002291 if (Args.hasArg(options::OPT_rewrite_objc) &&
2292 !Args.hasArg(options::OPT_g_Group))
2293 CmdArgs.push_back("-P");
2294 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002295 } else if (isa<AssembleJobAction>(JA)) {
2296 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002297
David Blaikie9260ed62013-07-25 21:19:01 +00002298 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002299
2300 // Also ignore explicit -force_cpusubtype_ALL option.
2301 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002302 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002303 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002304 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002305
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002306 if (JA.getType() == types::TY_Nothing)
2307 CmdArgs.push_back("-fsyntax-only");
2308 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002309 CmdArgs.push_back("-emit-pch");
2310 else
2311 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002312 } else if (isa<VerifyPCHJobAction>(JA)) {
2313 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002314 } else {
2315 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002316
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002317 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002318 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002319 } else if (JA.getType() == types::TY_LLVM_IR ||
2320 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002321 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002322 } else if (JA.getType() == types::TY_LLVM_BC ||
2323 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002324 CmdArgs.push_back("-emit-llvm-bc");
2325 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002326 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002327 } else if (JA.getType() == types::TY_AST) {
2328 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002329 } else if (JA.getType() == types::TY_ModuleFile) {
2330 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002331 } else if (JA.getType() == types::TY_RewrittenObjC) {
2332 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002333 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002334 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2335 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002336 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002337 } else {
2338 assert(JA.getType() == types::TY_PP_Asm &&
2339 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002340 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002341 }
2342
Justin Bognera88f0122014-06-20 22:59:50 +00002343 // We normally speed up the clang process a bit by skipping destructors at
2344 // exit, but when we're generating diagnostics we can rely on some of the
2345 // cleanup.
2346 if (!C.isForDiagnostics())
2347 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002348
John McCallbb79b5f2010-02-13 03:50:24 +00002349 // Disable the verification pass in -asserts builds.
2350#ifdef NDEBUG
2351 CmdArgs.push_back("-disable-llvm-verifier");
2352#endif
2353
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002354 // Set the main file name, so that debug info works even with
2355 // -save-temps.
2356 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002357 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002358
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002359 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002360 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002361 if (Args.hasArg(options::OPT_static))
2362 CmdArgs.push_back("-static-define");
2363
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002364 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002365 // Enable region store model by default.
2366 CmdArgs.push_back("-analyzer-store=region");
2367
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002368 // Treat blocks as analysis entry points.
2369 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2370
Ted Kremenek49c79792011-03-24 00:28:47 +00002371 CmdArgs.push_back("-analyzer-eagerly-assume");
2372
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002373 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002374 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002375 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002376
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002377 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002378 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002379
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002380 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002381 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002382
2383 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002384
Jordan Rose10ad0812013-04-05 17:55:07 +00002385 if (types::isCXX(Inputs[0].getType()))
2386 CmdArgs.push_back("-analyzer-checker=cplusplus");
2387
Nico Webere8e53112014-05-11 01:04:02 +00002388 // Enable the following experimental checkers for testing.
2389 CmdArgs.push_back(
2390 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002391 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2392 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2393 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2394 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2395 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002396 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002397
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002398 // Set the output format. The default is plist, for (lame) historical
2399 // reasons.
2400 CmdArgs.push_back("-analyzer-output");
2401 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002402 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002403 else
2404 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002405
Ted Kremenekfe449a22010-03-22 22:32:05 +00002406 // Disable the presentation of standard compiler warnings when
2407 // using --analyze. We only want to show static analyzer diagnostics
2408 // or frontend errors.
2409 CmdArgs.push_back("-w");
2410
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002411 // Add -Xanalyzer arguments when running as analyzer.
2412 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002413 }
2414
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002415 CheckCodeGenerationOptions(D, Args);
2416
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002417 bool PIE = getToolChain().isPIEDefault();
2418 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002419 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002420
Alexey Bataev40e75222014-01-28 06:30:35 +00002421 // Android-specific defaults for PIC/PIE
2422 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2423 switch (getToolChain().getTriple().getArch()) {
2424 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002425 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002426 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002427 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002428 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002429 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002430 case llvm::Triple::mips:
2431 case llvm::Triple::mipsel:
2432 case llvm::Triple::mips64:
2433 case llvm::Triple::mips64el:
2434 PIC = true; // "-fpic"
2435 break;
2436
2437 case llvm::Triple::x86:
2438 case llvm::Triple::x86_64:
2439 PIC = true; // "-fPIC"
2440 IsPICLevelTwo = true;
2441 break;
2442
2443 default:
2444 break;
2445 }
2446 }
2447
Brad Smith5b05db82014-06-24 19:51:29 +00002448 // OpenBSD-specific defaults for PIE
2449 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2450 switch (getToolChain().getTriple().getArch()) {
2451 case llvm::Triple::mips64:
2452 case llvm::Triple::mips64el:
2453 case llvm::Triple::sparc:
2454 case llvm::Triple::x86:
2455 case llvm::Triple::x86_64:
2456 IsPICLevelTwo = false; // "-fpie"
2457 break;
2458
2459 case llvm::Triple::ppc:
2460 case llvm::Triple::sparcv9:
2461 IsPICLevelTwo = true; // "-fPIE"
2462 break;
2463
2464 default:
2465 break;
2466 }
2467 }
2468
Alexey Samsonov090301e2013-04-09 12:28:19 +00002469 // For the PIC and PIE flag options, this logic is different from the
2470 // legacy logic in very old versions of GCC, as that logic was just
2471 // a bug no one had ever fixed. This logic is both more rational and
2472 // consistent with GCC's new logic now that the bugs are fixed. The last
2473 // argument relating to either PIC or PIE wins, and no other argument is
2474 // used. If the last argument is any flavor of the '-fno-...' arguments,
2475 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2476 // at the same level.
2477 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2478 options::OPT_fpic, options::OPT_fno_pic,
2479 options::OPT_fPIE, options::OPT_fno_PIE,
2480 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002481 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2482 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002483 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002484 if (LastPICArg) {
2485 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002486 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2487 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2488 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2489 PIC = PIE || O.matches(options::OPT_fPIC) ||
2490 O.matches(options::OPT_fpic);
2491 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2492 O.matches(options::OPT_fPIC);
2493 } else {
2494 PIE = PIC = false;
2495 }
2496 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002497 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002498
Nick Lewycky609dd662013-10-11 03:33:53 +00002499 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002500 // specified while enabling PIC enabled level 1 PIC, just force it back to
2501 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2502 // informal testing).
2503 if (PIC && getToolChain().getTriple().isOSDarwin())
2504 IsPICLevelTwo |= getToolChain().isPICDefault();
2505
Chandler Carruthc0c04552012-04-08 16:40:35 +00002506 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2507 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002508 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002509 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002510 Triple.getArch() == llvm::Triple::arm64 ||
2511 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002512 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002513 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002514 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002515
Chandler Carruth76a943b2012-11-19 03:52:03 +00002516 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2517 // This is a very special mode. It trumps the other modes, almost no one
2518 // uses it, and it isn't even valid on any OS but Darwin.
2519 if (!getToolChain().getTriple().isOSDarwin())
2520 D.Diag(diag::err_drv_unsupported_opt_for_target)
2521 << A->getSpelling() << getToolChain().getTriple().str();
2522
2523 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2524
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002525 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002526 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002527
Chandler Carruth76a943b2012-11-19 03:52:03 +00002528 // Only a forced PIC mode can cause the actual compile to have PIC defines
2529 // etc., no flags are sufficient. This behavior was selected to closely
2530 // match that of llvm-gcc and Apple GCC before that.
2531 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2532 CmdArgs.push_back("-pic-level");
2533 CmdArgs.push_back("2");
2534 }
2535 } else {
2536 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2537 // handled in Clang's IRGen by the -pie-level flag.
2538 CmdArgs.push_back("-mrelocation-model");
2539 CmdArgs.push_back(PIC ? "pic" : "static");
2540
2541 if (PIC) {
2542 CmdArgs.push_back("-pic-level");
2543 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2544 if (PIE) {
2545 CmdArgs.push_back("-pie-level");
2546 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2547 }
2548 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002549 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002550
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002551 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2552 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002553 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002554
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002555 // LLVM Code Generator Options.
2556
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002557 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2558 StringRef v = A->getValue();
2559 CmdArgs.push_back("-mllvm");
2560 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2561 A->claim();
2562 }
2563
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002564 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2565 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002566 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002567 }
2568
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002569 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2570 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002571 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002572 D.Diag(diag::err_drv_unsupported_opt_for_target)
2573 << A->getSpelling() << getToolChain().getTriple().str();
2574 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2575 CmdArgs.push_back("-fpcc-struct-return");
2576 } else {
2577 assert(A->getOption().matches(options::OPT_freg_struct_return));
2578 CmdArgs.push_back("-freg-struct-return");
2579 }
2580 }
2581
Roman Divacky65b88cd2011-03-01 17:40:53 +00002582 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2583 CmdArgs.push_back("-mrtd");
2584
Rafael Espindola224dd632011-12-14 21:02:23 +00002585 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002586 CmdArgs.push_back("-mdisable-fp-elim");
2587 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2588 options::OPT_fno_zero_initialized_in_bss))
2589 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002590
2591 bool OFastEnabled = isOptimizationLevelFast(Args);
2592 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2593 // enabled. This alias option is being used to simplify the hasFlag logic.
2594 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2595 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002596 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2597 // doesn't do any TBAA.
2598 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002599 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002600 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002601 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002602 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2603 options::OPT_fno_struct_path_tbaa))
2604 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002605 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2606 false))
2607 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002608 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2609 options::OPT_fno_optimize_sibling_calls))
2610 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002611
Eric Christopher006208c2013-04-04 06:29:47 +00002612 // Handle segmented stacks.
2613 if (Args.hasArg(options::OPT_fsplit_stack))
2614 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002615
2616 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2617 // This alias option is being used to simplify the getLastArg logic.
2618 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2619 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002620
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002621 // Handle various floating point optimization flags, mapping them to the
2622 // appropriate LLVM code generation flags. The pattern for all of these is to
2623 // default off the codegen optimizations, and if any flag enables them and no
2624 // flag disables them after the flag enabling them, enable the codegen
2625 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002626 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002627 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002628 options::OPT_ffinite_math_only,
2629 options::OPT_fno_finite_math_only,
2630 options::OPT_fhonor_infinities,
2631 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002632 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2633 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002634 A->getOption().getID() != options::OPT_fhonor_infinities)
2635 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002636 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002637 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002638 options::OPT_ffinite_math_only,
2639 options::OPT_fno_finite_math_only,
2640 options::OPT_fhonor_nans,
2641 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002642 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2643 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002644 A->getOption().getID() != options::OPT_fhonor_nans)
2645 CmdArgs.push_back("-menable-no-nans");
2646
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002647 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2648 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002649 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002650 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002651 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002652 options::OPT_fno_math_errno)) {
2653 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2654 // However, turning *off* -ffast_math merely restores the toolchain default
2655 // (which may be false).
2656 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2657 A->getOption().getID() == options::OPT_ffast_math ||
2658 A->getOption().getID() == options::OPT_Ofast)
2659 MathErrno = false;
2660 else if (A->getOption().getID() == options::OPT_fmath_errno)
2661 MathErrno = true;
2662 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002663 if (MathErrno)
2664 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002665
2666 // There are several flags which require disabling very specific
2667 // optimizations. Any of these being disabled forces us to turn off the
2668 // entire set of LLVM optimizations, so collect them through all the flag
2669 // madness.
2670 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002671 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002672 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002673 options::OPT_funsafe_math_optimizations,
2674 options::OPT_fno_unsafe_math_optimizations,
2675 options::OPT_fassociative_math,
2676 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002677 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2678 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002679 A->getOption().getID() != options::OPT_fno_associative_math)
2680 AssociativeMath = true;
2681 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002682 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002683 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002684 options::OPT_funsafe_math_optimizations,
2685 options::OPT_fno_unsafe_math_optimizations,
2686 options::OPT_freciprocal_math,
2687 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002688 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2689 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002690 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2691 ReciprocalMath = true;
2692 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002693 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002694 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002695 options::OPT_funsafe_math_optimizations,
2696 options::OPT_fno_unsafe_math_optimizations,
2697 options::OPT_fsigned_zeros,
2698 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002699 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2700 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002701 A->getOption().getID() != options::OPT_fsigned_zeros)
2702 SignedZeros = false;
2703 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002704 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002705 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002706 options::OPT_funsafe_math_optimizations,
2707 options::OPT_fno_unsafe_math_optimizations,
2708 options::OPT_ftrapping_math,
2709 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002710 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2711 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002712 A->getOption().getID() != options::OPT_ftrapping_math)
2713 TrappingMath = false;
2714 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2715 !TrappingMath)
2716 CmdArgs.push_back("-menable-unsafe-fp-math");
2717
Lang Hamesaa53b932012-07-06 00:59:19 +00002718
2719 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002720 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002721 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002722 options::OPT_ffp_contract)) {
2723 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002724 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002725 if (Val == "fast" || Val == "on" || Val == "off") {
2726 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2727 } else {
2728 D.Diag(diag::err_drv_unsupported_option_argument)
2729 << A->getOption().getName() << Val;
2730 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002731 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2732 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002733 // If fast-math is set then set the fp-contract mode to fast.
2734 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2735 }
2736 }
2737
Bob Wilson6a039162012-07-19 03:52:53 +00002738 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2739 // and if we find them, tell the frontend to provide the appropriate
2740 // preprocessor macros. This is distinct from enabling any optimizations as
2741 // these options induce language changes which must survive serialization
2742 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002743 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2744 options::OPT_fno_fast_math))
2745 if (!A->getOption().matches(options::OPT_fno_fast_math))
2746 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002747 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2748 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002749 if (A->getOption().matches(options::OPT_ffinite_math_only))
2750 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002751
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002752 // Decide whether to use verbose asm. Verbose assembly is the default on
2753 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002754 bool IsIntegratedAssemblerDefault =
2755 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002756 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002757 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002758 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002759 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002760
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002761 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002762 IsIntegratedAssemblerDefault))
2763 CmdArgs.push_back("-no-integrated-as");
2764
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002765 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2766 CmdArgs.push_back("-mdebug-pass");
2767 CmdArgs.push_back("Structure");
2768 }
2769 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2770 CmdArgs.push_back("-mdebug-pass");
2771 CmdArgs.push_back("Arguments");
2772 }
2773
John McCall8517abc2010-02-19 02:45:38 +00002774 // Enable -mconstructor-aliases except on darwin, where we have to
2775 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002776 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002777 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002778
John McCall7ef5cb32011-03-18 02:56:14 +00002779 // Darwin's kernel doesn't support guard variables; just die if we
2780 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002781 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002782 CmdArgs.push_back("-fforbid-guard-variables");
2783
Douglas Gregordbe39272011-02-01 15:15:22 +00002784 if (Args.hasArg(options::OPT_mms_bitfields)) {
2785 CmdArgs.push_back("-mms-bitfields");
2786 }
John McCall8517abc2010-02-19 02:45:38 +00002787
Daniel Dunbar306945d2009-09-16 06:17:29 +00002788 // This is a coarse approximation of what llvm-gcc actually does, both
2789 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2790 // complicated ways.
2791 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002792 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2793 options::OPT_fno_asynchronous_unwind_tables,
2794 (getToolChain().IsUnwindTablesDefault() ||
2795 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2796 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002797 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2798 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002799 CmdArgs.push_back("-munwind-tables");
2800
Chandler Carruth05fb5852012-11-21 23:40:23 +00002801 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002802
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002803 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2804 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002805 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002806 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002807
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002808 // FIXME: Handle -mtune=.
2809 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002810
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002811 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002812 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002813 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002814 }
2815
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002816 // Add the target cpu
2817 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2818 llvm::Triple ETriple(ETripleStr);
2819 std::string CPU = getCPUName(Args, ETriple);
2820 if (!CPU.empty()) {
2821 CmdArgs.push_back("-target-cpu");
2822 CmdArgs.push_back(Args.MakeArgString(CPU));
2823 }
2824
Rafael Espindolaeb265472013-08-21 21:59:03 +00002825 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2826 CmdArgs.push_back("-mfpmath");
2827 CmdArgs.push_back(A->getValue());
2828 }
2829
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002830 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002831 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002832
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002833 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002834 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002835 default:
2836 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002837
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002838 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002839 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002840 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002841 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002842 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002843 break;
2844
Tim Northover573cbee2014-05-24 12:52:07 +00002845 case llvm::Triple::aarch64:
2846 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002847 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002848 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002849 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002850 break;
2851
Eric Christopher0b26a612010-03-02 02:41:08 +00002852 case llvm::Triple::mips:
2853 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002854 case llvm::Triple::mips64:
2855 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002856 AddMIPSTargetArgs(Args, CmdArgs);
2857 break;
2858
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002859 case llvm::Triple::sparc:
2860 AddSparcTargetArgs(Args, CmdArgs);
2861 break;
2862
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002863 case llvm::Triple::x86:
2864 case llvm::Triple::x86_64:
2865 AddX86TargetArgs(Args, CmdArgs);
2866 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002867
2868 case llvm::Triple::hexagon:
2869 AddHexagonTargetArgs(Args, CmdArgs);
2870 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002871 }
2872
Hans Wennborg75958c42013-08-08 00:17:41 +00002873 // Add clang-cl arguments.
2874 if (getToolChain().getDriver().IsCLMode())
2875 AddClangCLArgs(Args, CmdArgs);
2876
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002877 // Pass the linker version in use.
2878 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2879 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002880 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002881 }
2882
Eric Christopherb7d97e92013-04-03 01:58:53 +00002883 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002884 CmdArgs.push_back("-momit-leaf-frame-pointer");
2885
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002886 // Explicitly error on some things we know we don't support and can't just
2887 // ignore.
2888 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002889 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2890 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002891 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002892 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002893 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002894 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2895 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002896 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002897 << Unsupported->getOption().getName();
2898 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002899 }
2900
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002901 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002902 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002903 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002904 CmdArgs.push_back("-header-include-file");
2905 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2906 D.CCPrintHeadersFilename : "-");
2907 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002908 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002909 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002910
Chad Rosierbe10f982011-08-02 17:58:04 +00002911 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002912 CmdArgs.push_back("-diagnostic-log-file");
2913 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2914 D.CCLogDiagnosticsFilename : "-");
2915 }
2916
Manman Ren17bdb0f2013-11-20 20:22:14 +00002917 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2918 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002919 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002920 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002921 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002922 // FIXME: we should support specifying dwarf version with
2923 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002924 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00002925 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2926 const llvm::Triple &Triple = getToolChain().getTriple();
2927 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2928 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002929 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002930 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002931 CmdArgs.push_back("-gdwarf-2");
2932 else if (A->getOption().matches(options::OPT_gdwarf_3))
2933 CmdArgs.push_back("-gdwarf-3");
2934 else if (A->getOption().matches(options::OPT_gdwarf_4))
2935 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002936 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002937 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00002938 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2939 const llvm::Triple &Triple = getToolChain().getTriple();
2940 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2941 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002942 CmdArgs.push_back("-gdwarf-2");
2943 else
2944 CmdArgs.push_back("-g");
2945 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002946 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002947
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002948 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2949 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002950 if (Args.hasArg(options::OPT_gcolumn_info))
2951 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002952
Eric Christopher138c32b2013-09-13 22:37:55 +00002953 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002954 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2955 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002956 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002957 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002958 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002959 CmdArgs.push_back("-g");
2960 CmdArgs.push_back("-backend-option");
2961 CmdArgs.push_back("-split-dwarf=Enable");
2962 }
2963
Eric Christopher138c32b2013-09-13 22:37:55 +00002964 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2965 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2966 CmdArgs.push_back("-backend-option");
2967 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2968 }
Eric Christophereec89c22013-06-18 00:03:50 +00002969
Eric Christopher0d403d22014-02-14 01:27:03 +00002970 // -gdwarf-aranges turns on the emission of the aranges section in the
2971 // backend.
2972 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2973 CmdArgs.push_back("-backend-option");
2974 CmdArgs.push_back("-generate-arange-section");
2975 }
2976
David Blaikief36d9ba2014-01-27 18:52:43 +00002977 if (Args.hasFlag(options::OPT_fdebug_types_section,
2978 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002979 CmdArgs.push_back("-backend-option");
2980 CmdArgs.push_back("-generate-type-units");
2981 }
Eric Christophereec89c22013-06-18 00:03:50 +00002982
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002983 if (Args.hasFlag(options::OPT_ffunction_sections,
2984 options::OPT_fno_function_sections, false)) {
2985 CmdArgs.push_back("-ffunction-sections");
2986 }
2987
2988 if (Args.hasFlag(options::OPT_fdata_sections,
2989 options::OPT_fno_data_sections, false)) {
2990 CmdArgs.push_back("-fdata-sections");
2991 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002992
Chris Lattner3c77a352010-06-22 00:03:40 +00002993 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2994
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002995 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2996 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2997 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2998 D.Diag(diag::err_drv_argument_not_allowed_with)
2999 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3000
3001 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3002
3003 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3004 A->render(Args, CmdArgs);
3005 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3006 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3007
Nick Lewycky207bce32011-04-21 23:44:07 +00003008 if (Args.hasArg(options::OPT_ftest_coverage) ||
3009 Args.hasArg(options::OPT_coverage))
3010 CmdArgs.push_back("-femit-coverage-notes");
3011 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3012 Args.hasArg(options::OPT_coverage))
3013 CmdArgs.push_back("-femit-coverage-data");
3014
Nick Lewycky480cb992011-05-04 20:46:58 +00003015 if (C.getArgs().hasArg(options::OPT_c) ||
3016 C.getArgs().hasArg(options::OPT_S)) {
3017 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003018 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00003019 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00003020 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003021 SmallString<128> Pwd;
3022 if (!llvm::sys::fs::current_path(Pwd)) {
3023 llvm::sys::path::append(Pwd, CoverageFilename.str());
3024 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003025 }
3026 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003027 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003028 }
3029 }
3030
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003031 // Pass options for controlling the default header search paths.
3032 if (Args.hasArg(options::OPT_nostdinc)) {
3033 CmdArgs.push_back("-nostdsysteminc");
3034 CmdArgs.push_back("-nobuiltininc");
3035 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003036 if (Args.hasArg(options::OPT_nostdlibinc))
3037 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003038 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3039 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3040 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003041
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003042 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003043 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003044 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003045
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003046 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3047
Ted Kremenekf7639e12012-03-06 20:06:33 +00003048 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003049 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003050 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003051 options::OPT_ccc_arcmt_modify,
3052 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003053 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003054 switch (A->getOption().getID()) {
3055 default:
3056 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003057 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003058 CmdArgs.push_back("-arcmt-check");
3059 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003060 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003061 CmdArgs.push_back("-arcmt-modify");
3062 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003063 case options::OPT_ccc_arcmt_migrate:
3064 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003065 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003066 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003067
3068 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3069 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003070 break;
John McCalld70fb982011-06-15 23:25:17 +00003071 }
3072 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003073 } else {
3074 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3075 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3076 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003077 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003078
Ted Kremenekf7639e12012-03-06 20:06:33 +00003079 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3080 if (ARCMTEnabled) {
3081 D.Diag(diag::err_drv_argument_not_allowed_with)
3082 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3083 }
3084 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003085 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003086
3087 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003088 options::OPT_objcmt_migrate_subscripting,
3089 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003090 // None specified, means enable them all.
3091 CmdArgs.push_back("-objcmt-migrate-literals");
3092 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003093 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003094 } else {
3095 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3096 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003097 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003098 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003099 } else {
3100 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3101 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3102 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3103 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3104 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3105 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3106 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3107 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3108 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3109 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3110 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3111 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3112 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003113 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003114 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003115 }
3116
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003117 // Add preprocessing options like -I, -D, etc. if we are using the
3118 // preprocessor.
3119 //
3120 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003121 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003122 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003123
Rafael Espindolaa7431922011-07-21 23:40:37 +00003124 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3125 // that "The compiler can only warn and ignore the option if not recognized".
3126 // When building with ccache, it will pass -D options to clang even on
3127 // preprocessed inputs and configure concludes that -fPIC is not supported.
3128 Args.ClaimAllArgs(options::OPT_D);
3129
Alp Toker7874bdc2013-11-15 20:40:58 +00003130 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003131 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3132 if (A->getOption().matches(options::OPT_O4)) {
3133 CmdArgs.push_back("-O3");
3134 D.Diag(diag::warn_O4_is_O3);
3135 } else {
3136 A->render(Args, CmdArgs);
3137 }
3138 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003139
Chad Rosier86b82082012-12-12 20:06:31 +00003140 // Don't warn about unused -flto. This can happen when we're preprocessing or
3141 // precompiling.
3142 Args.ClaimAllArgs(options::OPT_flto);
3143
Daniel Dunbar945577c2009-10-29 02:24:45 +00003144 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003145 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3146 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003147 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003148 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003149
3150 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003151 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003152 //
3153 // If a std is supplied, only add -trigraphs if it follows the
3154 // option.
3155 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3156 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003157 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003158 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003159 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003160 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003161 else
3162 Std->render(Args, CmdArgs);
3163
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003164 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3165 options::OPT_trigraphs))
3166 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003167 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003168 } else {
3169 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003170 //
3171 // FIXME: Clang doesn't correctly handle -std= when the input language
3172 // doesn't match. For the time being just ignore this for C++ inputs;
3173 // eventually we want to do all the standard defaulting here instead of
3174 // splitting it between the driver and clang -cc1.
3175 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003176 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3177 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003178 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003179 CmdArgs.push_back("-std=c++11");
3180
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003181 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003182 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003183
Richard Smith282b4492013-09-04 22:50:31 +00003184 // GCC's behavior for -Wwrite-strings is a bit strange:
3185 // * In C, this "warning flag" changes the types of string literals from
3186 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3187 // for the discarded qualifier.
3188 // * In C++, this is just a normal warning flag.
3189 //
3190 // Implementing this warning correctly in C is hard, so we follow GCC's
3191 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3192 // a non-const char* in C, rather than using this crude hack.
3193 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003194 // FIXME: This should behave just like a warning flag, and thus should also
3195 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3196 Arg *WriteStrings =
3197 Args.getLastArg(options::OPT_Wwrite_strings,
3198 options::OPT_Wno_write_strings, options::OPT_w);
3199 if (WriteStrings &&
3200 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003201 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003202 }
3203
Chandler Carruth61fbf622011-04-23 09:27:53 +00003204 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003205 // during C++ compilation, which it is by default. GCC keeps this define even
3206 // in the presence of '-w', match this behavior bug-for-bug.
3207 if (types::isCXX(InputType) &&
3208 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3209 true)) {
3210 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003211 }
3212
Chandler Carruthe0391482010-05-22 02:21:53 +00003213 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3214 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3215 if (Asm->getOption().matches(options::OPT_fasm))
3216 CmdArgs.push_back("-fgnu-keywords");
3217 else
3218 CmdArgs.push_back("-fno-gnu-keywords");
3219 }
3220
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003221 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3222 CmdArgs.push_back("-fno-dwarf-directory-asm");
3223
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003224 if (ShouldDisableAutolink(Args, getToolChain()))
3225 CmdArgs.push_back("-fno-autolink");
3226
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003227 // Add in -fdebug-compilation-dir if necessary.
3228 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003229
Richard Smith9a568822011-11-21 19:36:32 +00003230 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3231 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003232 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003233 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003234 }
3235
Richard Smith79c927b2013-11-06 19:31:51 +00003236 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3237 CmdArgs.push_back("-foperator-arrow-depth");
3238 CmdArgs.push_back(A->getValue());
3239 }
3240
Richard Smith9a568822011-11-21 19:36:32 +00003241 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3242 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003243 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003244 }
3245
Richard Smitha3d3bd22013-05-08 02:12:03 +00003246 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3247 CmdArgs.push_back("-fconstexpr-steps");
3248 CmdArgs.push_back(A->getValue());
3249 }
3250
Richard Smithb3a14522013-02-22 01:59:51 +00003251 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3252 CmdArgs.push_back("-fbracket-depth");
3253 CmdArgs.push_back(A->getValue());
3254 }
3255
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003256 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3257 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003258 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003259 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003260 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3261 } else
3262 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003263 }
3264
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003265
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003266 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003267 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003268
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003269 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3270 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003271 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003272 }
David Chisnall5778fce2009-08-31 16:41:57 +00003273
Chris Lattnere23003d2010-01-09 21:54:33 +00003274 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3275 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003276 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003277 }
3278
Chris Lattnerb35583d2010-04-07 20:49:23 +00003279 CmdArgs.push_back("-ferror-limit");
3280 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003281 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003282 else
3283 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003284
Chandler Carrutha77a7272010-05-06 04:55:18 +00003285 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3286 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003287 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003288 }
3289
3290 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3291 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003292 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003293 }
3294
Richard Smithf6f003a2011-12-16 19:06:07 +00003295 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3296 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003297 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003298 }
3299
Daniel Dunbar2c978472009-11-04 06:24:47 +00003300 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003301 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003302 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003303 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003304 } else {
3305 // If -fmessage-length=N was not specified, determine whether this is a
3306 // terminal and, if so, implicitly define -fmessage-length appropriately.
3307 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003308 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003309 }
3310
John McCallb4a99d32013-02-19 01:57:35 +00003311 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3312 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3313 options::OPT_fvisibility_ms_compat)) {
3314 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3315 CmdArgs.push_back("-fvisibility");
3316 CmdArgs.push_back(A->getValue());
3317 } else {
3318 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3319 CmdArgs.push_back("-fvisibility");
3320 CmdArgs.push_back("hidden");
3321 CmdArgs.push_back("-ftype-visibility");
3322 CmdArgs.push_back("default");
3323 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003324 }
3325
Douglas Gregor08329632010-06-15 17:05:35 +00003326 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003327
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003328 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3329
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003330 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003331 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3332 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003333 CmdArgs.push_back("-ffreestanding");
3334
Daniel Dunbare357d562009-12-03 18:42:11 +00003335 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003336 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003337 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003338 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3339 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003340 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003341 // AltiVec language extensions aren't relevant for assembling.
3342 if (!isa<PreprocessJobAction>(JA) ||
3343 Output.getType() != types::TY_PP_Asm)
3344 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003345 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3346 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003347
Peter Collingbourne32701642013-11-01 18:16:25 +00003348 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3349 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003350
Will Dietz3676d562012-12-30 20:53:28 +00003351 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3352 options::OPT_fno_sanitize_recover,
3353 true))
3354 CmdArgs.push_back("-fno-sanitize-recover");
3355
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003356 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003357 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3358 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3359
Eric Christopher459d2712013-02-19 06:16:53 +00003360 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003361 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003362 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003363 getToolChain().getArch() == llvm::Triple::ppc64 ||
3364 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003365 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003366 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003367
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003368 if (getToolChain().SupportsProfiling())
3369 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003370
3371 // -flax-vector-conversions is default.
3372 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3373 options::OPT_fno_lax_vector_conversions))
3374 CmdArgs.push_back("-fno-lax-vector-conversions");
3375
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003376 if (Args.getLastArg(options::OPT_fapple_kext))
3377 CmdArgs.push_back("-fapple-kext");
3378
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003379 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003380 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003381 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003382 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3383 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003384
3385 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3386 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003387 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003388 }
3389
Bob Wilson14adb362012-02-03 06:27:22 +00003390 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003391
Chandler Carruth6e501032011-03-27 00:04:55 +00003392 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3393 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3394 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3395 options::OPT_fno_wrapv)) {
3396 if (A->getOption().matches(options::OPT_fwrapv))
3397 CmdArgs.push_back("-fwrapv");
3398 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3399 options::OPT_fno_strict_overflow)) {
3400 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3401 CmdArgs.push_back("-fwrapv");
3402 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003403
3404 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3405 options::OPT_fno_reroll_loops))
3406 if (A->getOption().matches(options::OPT_freroll_loops))
3407 CmdArgs.push_back("-freroll-loops");
3408
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003409 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003410 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3411 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003412
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003413 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3414
Mahesha S6a682be42012-10-27 07:47:56 +00003415
Daniel Dunbar4930e332009-11-17 08:07:36 +00003416 // -stack-protector=0 is default.
3417 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003418 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3419 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003420 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003421 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003422 if (A->getOption().matches(options::OPT_fstack_protector)) {
3423 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3424 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3425 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003426 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003427 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003428 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003429 } else {
3430 StackProtectorLevel =
3431 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3432 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003433 if (StackProtectorLevel) {
3434 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003435 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003436 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003437
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003438 // --param ssp-buffer-size=
3439 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3440 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003441 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003442 if (Str.startswith("ssp-buffer-size=")) {
3443 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003444 CmdArgs.push_back("-stack-protector-buffer-size");
3445 // FIXME: Verify the argument is a valid integer.
3446 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003447 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003448 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003449 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003450 }
3451
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003452 // Translate -mstackrealign
3453 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3454 false)) {
3455 CmdArgs.push_back("-backend-option");
3456 CmdArgs.push_back("-force-align-stack");
3457 }
3458 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3459 false)) {
3460 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3461 }
3462
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003463 if (Args.hasArg(options::OPT_mstack_alignment)) {
3464 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3465 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003466 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003467 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003468 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003469 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3470 options::OPT_munaligned_access)) {
3471 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3472 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003473 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3474 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3475 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003476 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003477 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003478 else
3479 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003480 } else {
3481 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003482 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3483 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3484 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003485 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003486 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003487 else
3488 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003489 }
Renato Golina146a482013-08-24 14:44:41 +00003490 }
Chad Rosier60027022012-11-09 17:29:19 +00003491 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003492
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003493 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3494 options::OPT_mno_restrict_it)) {
3495 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3496 CmdArgs.push_back("-backend-option");
3497 CmdArgs.push_back("-arm-restrict-it");
3498 } else {
3499 CmdArgs.push_back("-backend-option");
3500 CmdArgs.push_back("-arm-no-restrict-it");
3501 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003502 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3503 TT.getArch() == llvm::Triple::thumb)) {
3504 // Windows on ARM expects restricted IT blocks
3505 CmdArgs.push_back("-backend-option");
3506 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003507 }
3508
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003509 if (TT.getArch() == llvm::Triple::arm ||
3510 TT.getArch() == llvm::Triple::thumb) {
3511 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3512 options::OPT_mno_long_calls)) {
3513 if (A->getOption().matches(options::OPT_mlong_calls)) {
3514 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003515 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003516 }
3517 }
3518 }
3519
Daniel Dunbard18049a2009-04-07 21:16:11 +00003520 // Forward -f options with positive and negative forms; we translate
3521 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003522 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3523 StringRef fname = A->getValue();
3524 if (!llvm::sys::fs::exists(fname))
3525 D.Diag(diag::err_drv_no_such_file) << fname;
3526 else
3527 A->render(Args, CmdArgs);
3528 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003529
Diego Novillo829b1702014-04-16 16:54:24 +00003530 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3531 A->render(Args, CmdArgs);
3532
Diego Novillod23ec942014-05-29 19:55:06 +00003533 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3534 A->render(Args, CmdArgs);
3535
3536 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3537 A->render(Args, CmdArgs);
3538
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003539 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003540 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003541 CmdArgs.push_back("-fapple-kext");
3542 if (!Args.hasArg(options::OPT_fbuiltin))
3543 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003544 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003545 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003546 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003547 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003548 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003549
Nuno Lopes13c88c72009-12-16 16:59:22 +00003550 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3551 options::OPT_fno_assume_sane_operator_new))
3552 CmdArgs.push_back("-fno-assume-sane-operator-new");
3553
Daniel Dunbar4930e332009-11-17 08:07:36 +00003554 // -fblocks=0 is default.
3555 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003556 getToolChain().IsBlocksDefault()) ||
3557 (Args.hasArg(options::OPT_fgnu_runtime) &&
3558 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3559 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003560 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003561
3562 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3563 !getToolChain().hasBlocksRuntime())
3564 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003565 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003566
Douglas Gregor226173a2012-01-18 15:19:58 +00003567 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3568 // users must also pass -fcxx-modules. The latter flag will disappear once the
3569 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003570 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003571 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3572 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3573 options::OPT_fno_cxx_modules,
3574 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003575 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003576 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003577 HaveModules = true;
3578 }
3579 }
3580
Daniel Jasper07e6c402013-08-05 20:26:17 +00003581 // -fmodule-maps enables module map processing (off by default) for header
3582 // checking. It is implied by -fmodules.
3583 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3584 false)) {
3585 CmdArgs.push_back("-fmodule-maps");
3586 }
3587
Daniel Jasperac42b752013-10-21 06:34:34 +00003588 // -fmodules-decluse checks that modules used are declared so (off by
3589 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003590 if (Args.hasFlag(options::OPT_fmodules_decluse,
3591 options::OPT_fno_modules_decluse,
3592 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003593 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003594 }
3595
Daniel Jasper962b38e2014-04-11 11:47:45 +00003596 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3597 // all #included headers are part of modules.
3598 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3599 options::OPT_fno_modules_strict_decluse,
3600 false)) {
3601 CmdArgs.push_back("-fmodules-strict-decluse");
3602 }
3603
Daniel Jasperac42b752013-10-21 06:34:34 +00003604 // -fmodule-name specifies the module that is currently being built (or
3605 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003606 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003607 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003608
3609 // -fmodule-map-file can be used to specify a file containing module
3610 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003611 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003612 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003613
Justin Bognera88f0122014-06-20 22:59:50 +00003614 // -fmodule-cache-path specifies where our module files should be written.
3615 SmallString<128> ModuleCachePath;
3616 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3617 ModuleCachePath = A->getValue();
3618 if (HaveModules) {
3619 if (C.isForDiagnostics()) {
3620 // When generating crash reports, we want to emit the modules along with
3621 // the reproduction sources, so we ignore any provided module path.
3622 ModuleCachePath = Output.getFilename();
3623 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3624 llvm::sys::path::append(ModuleCachePath, "modules");
3625 } else if (ModuleCachePath.empty()) {
3626 // No module path was provided: use the default.
3627 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3628 ModuleCachePath);
3629 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3630 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3631 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003632 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003633 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3634 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3635 }
3636
3637 // When building modules and generating crashdumps, we need to dump a module
3638 // dependency VFS alongside the output.
3639 if (HaveModules && C.isForDiagnostics()) {
3640 SmallString<128> VFSDir(Output.getFilename());
3641 llvm::sys::path::replace_extension(VFSDir, ".cache");
3642 llvm::sys::path::append(VFSDir, "vfs");
3643 CmdArgs.push_back("-module-dependency-dir");
3644 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003645 }
3646
Justin Bogner5443ad52014-06-20 21:12:53 +00003647 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3648 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003649 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003650
Douglas Gregor35b04d62013-02-07 19:01:24 +00003651 // Pass through all -fmodules-ignore-macro arguments.
3652 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003653 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3654 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003655
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003656 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3657
3658 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3659 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3660 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3661
3662 Args.AddLastArg(CmdArgs,
3663 options::OPT_fmodules_validate_once_per_build_session);
3664 }
3665
Ben Langmuirdcf73862014-03-12 00:06:17 +00003666 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3667
John McCalldfea9982010-04-09 19:12:06 +00003668 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003669 if (Args.hasFlag(options::OPT_fno_access_control,
3670 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003671 false))
John McCall3155f572010-04-09 19:03:51 +00003672 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003673
Anders Carlssond470fef2010-11-21 00:09:52 +00003674 // -felide-constructors is the default.
3675 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3676 options::OPT_felide_constructors,
3677 false))
3678 CmdArgs.push_back("-fno-elide-constructors");
3679
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003680 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003681 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003682 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003683 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003684
Richard Smith52be6192012-11-05 22:04:41 +00003685 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003686 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003687 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003688 Args.getLastArg(options::OPT_mkernel,
3689 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003690 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003691 D.Diag(diag::err_drv_argument_not_allowed_with)
3692 << "-fsanitize=vptr" << NoRttiArg;
3693 }
3694 }
3695
Tony Linthicum76329bf2011-12-12 21:14:55 +00003696 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003697 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003698 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003699 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003700 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003701 CmdArgs.push_back("-fshort-enums");
3702
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003703 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003704 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003705 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003706 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003707
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003708 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003709 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003710 options::OPT_fno_threadsafe_statics))
3711 CmdArgs.push_back("-fno-threadsafe-statics");
3712
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003713 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003714 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3715 options::OPT_fno_use_cxa_atexit,
3716 !IsWindowsCygnus && !IsWindowsGNU &&
3717 getToolChain().getArch() != llvm::Triple::hexagon &&
3718 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003719 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003720 CmdArgs.push_back("-fno-use-cxa-atexit");
3721
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003722 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003723 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003724 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003725 CmdArgs.push_back("-fms-extensions");
3726
Francois Pichet1b4f1632011-09-17 04:32:15 +00003727 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003728 if (Args.hasFlag(options::OPT_fms_compatibility,
3729 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003730 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3731 options::OPT_fno_ms_extensions,
3732 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003733 CmdArgs.push_back("-fms-compatibility");
3734
Reid Klecknerc106fda2013-09-18 00:33:59 +00003735 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003736 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003737 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003738 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003739 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003740 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003741 else
3742 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3743 }
3744
3745
Eric Christopher5ecce122013-02-18 00:38:31 +00003746 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003747 if (Args.hasFlag(options::OPT_fborland_extensions,
3748 options::OPT_fno_borland_extensions, false))
3749 CmdArgs.push_back("-fborland-extensions");
3750
Francois Pichet02744872011-09-01 16:38:08 +00003751 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3752 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003753 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003754 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003755 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003756
Chandler Carruthe03aa552010-04-17 20:17:31 +00003757 // -fgnu-keywords default varies depending on language; only pass if
3758 // specified.
3759 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003760 options::OPT_fno_gnu_keywords))
3761 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003762
Rafael Espindola922a6242011-06-02 17:30:53 +00003763 if (Args.hasFlag(options::OPT_fgnu89_inline,
3764 options::OPT_fno_gnu89_inline,
3765 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003766 CmdArgs.push_back("-fgnu89-inline");
3767
Chad Rosier9c76d242012-03-15 22:31:42 +00003768 if (Args.hasArg(options::OPT_fno_inline))
3769 CmdArgs.push_back("-fno-inline");
3770
Chad Rosier64d6be92012-03-06 21:17:19 +00003771 if (Args.hasArg(options::OPT_fno_inline_functions))
3772 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003773
John McCall5fb5df92012-06-20 06:18:46 +00003774 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003775
John McCall5fb5df92012-06-20 06:18:46 +00003776 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003777 // legacy is the default. Except for deployment taget of 10.5,
3778 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3779 // gets ignored silently.
3780 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003781 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3782 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003783 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003784 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003785 if (getToolChain().UseObjCMixedDispatch())
3786 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3787 else
3788 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3789 }
3790 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003791
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003792 // When ObjectiveC legacy runtime is in effect on MacOSX,
3793 // turn on the option to do Array/Dictionary subscripting
3794 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003795 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3796 getToolChain().getTriple().isMacOSX() &&
3797 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3798 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003799 objcRuntime.isNeXTFamily())
3800 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3801
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003802 // -fencode-extended-block-signature=1 is default.
3803 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3804 CmdArgs.push_back("-fencode-extended-block-signature");
3805 }
3806
John McCall24fc0de2011-07-06 00:26:06 +00003807 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3808 // NOTE: This logic is duplicated in ToolChains.cpp.
3809 bool ARC = isObjCAutoRefCount(Args);
3810 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003811 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003812
John McCall24fc0de2011-07-06 00:26:06 +00003813 CmdArgs.push_back("-fobjc-arc");
3814
Chandler Carruth491db322011-11-04 07:34:47 +00003815 // FIXME: It seems like this entire block, and several around it should be
3816 // wrapped in isObjC, but for now we just use it here as this is where it
3817 // was being used previously.
3818 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3819 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3820 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3821 else
3822 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3823 }
3824
John McCall24fc0de2011-07-06 00:26:06 +00003825 // Allow the user to enable full exceptions code emission.
3826 // We define off for Objective-CC, on for Objective-C++.
3827 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3828 options::OPT_fno_objc_arc_exceptions,
3829 /*default*/ types::isCXX(InputType)))
3830 CmdArgs.push_back("-fobjc-arc-exceptions");
3831 }
3832
3833 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3834 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003835 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003836 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003837
John McCall24fc0de2011-07-06 00:26:06 +00003838 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3839 // takes precedence.
3840 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3841 if (!GCArg)
3842 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3843 if (GCArg) {
3844 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003845 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003846 << GCArg->getAsString(Args);
3847 } else if (getToolChain().SupportsObjCGC()) {
3848 GCArg->render(Args, CmdArgs);
3849 } else {
3850 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003851 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003852 << GCArg->getAsString(Args);
3853 }
3854 }
3855
Reid Klecknerc542d372014-06-27 17:02:02 +00003856 // Handle GCC-style exception args.
3857 if (!C.getDriver().IsCLMode())
3858 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
3859 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003860
3861 if (getToolChain().UseSjLjExceptions())
3862 CmdArgs.push_back("-fsjlj-exceptions");
3863
3864 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003865 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3866 options::OPT_fno_assume_sane_operator_new))
3867 CmdArgs.push_back("-fno-assume-sane-operator-new");
3868
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003869 // -fconstant-cfstrings is default, and may be subject to argument translation
3870 // on Darwin.
3871 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3872 options::OPT_fno_constant_cfstrings) ||
3873 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3874 options::OPT_mno_constant_cfstrings))
3875 CmdArgs.push_back("-fno-constant-cfstrings");
3876
John Thompsoned4e2952009-11-05 20:14:16 +00003877 // -fshort-wchar default varies depending on platform; only
3878 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003879 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3880 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003881 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003882
Hans Wennborg28c96312013-07-31 23:39:13 +00003883 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003884 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003885 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003886 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003887 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003888
Daniel Dunbar096ed292011-10-05 21:04:55 +00003889 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3890 // -fno-pack-struct doesn't apply to -fpack-struct=.
3891 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003892 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003893 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003894 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003895 } else if (Args.hasFlag(options::OPT_fpack_struct,
3896 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003897 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003898 }
3899
Robert Lytton0e076492013-08-13 09:43:10 +00003900 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003901 if (!Args.hasArg(options::OPT_fcommon))
3902 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003903 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003904 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003905
Daniel Dunbard18049a2009-04-07 21:16:11 +00003906 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003907 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003908 CmdArgs.push_back("-fno-common");
3909
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003910 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003911 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003912 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003913 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003914 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003915 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3916
Daniel Dunbar6358d682010-10-15 22:30:42 +00003917 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3918 if (!Args.hasFlag(options::OPT_ffor_scope,
3919 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003920 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003921 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3922
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00003923 // -finput_charset=UTF-8 is default. Reject others
3924 if (Arg *inputCharset = Args.getLastArg(
3925 options::OPT_finput_charset_EQ)) {
3926 StringRef value = inputCharset->getValue();
3927 if (value != "UTF-8")
3928 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
3929 }
3930
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003931 // -fcaret-diagnostics is default.
3932 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3933 options::OPT_fno_caret_diagnostics, true))
3934 CmdArgs.push_back("-fno-caret-diagnostics");
3935
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003936 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003937 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003938 options::OPT_fno_diagnostics_fixit_info))
3939 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003940
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003941 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003942 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003943 options::OPT_fno_diagnostics_show_option))
3944 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003945
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003946 if (const Arg *A =
3947 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3948 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003949 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003950 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003951
Douglas Gregor643c9222011-05-21 17:07:29 +00003952 if (const Arg *A =
3953 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3954 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003955 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003956 }
3957
Chandler Carruthb6766f02011-03-27 01:50:55 +00003958 if (Arg *A = Args.getLastArg(
3959 options::OPT_fdiagnostics_show_note_include_stack,
3960 options::OPT_fno_diagnostics_show_note_include_stack)) {
3961 if (A->getOption().matches(
3962 options::OPT_fdiagnostics_show_note_include_stack))
3963 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3964 else
3965 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3966 }
3967
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003968 // Color diagnostics are the default, unless the terminal doesn't support
3969 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003970 // Support both clang's -f[no-]color-diagnostics and gcc's
3971 // -f[no-]diagnostics-colors[=never|always|auto].
3972 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003973 for (const auto &Arg : Args) {
3974 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00003975 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3976 !O.matches(options::OPT_fdiagnostics_color) &&
3977 !O.matches(options::OPT_fno_color_diagnostics) &&
3978 !O.matches(options::OPT_fno_diagnostics_color) &&
3979 !O.matches(options::OPT_fdiagnostics_color_EQ))
3980 continue;
3981
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003982 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00003983 if (O.matches(options::OPT_fcolor_diagnostics) ||
3984 O.matches(options::OPT_fdiagnostics_color)) {
3985 ShowColors = Colors_On;
3986 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3987 O.matches(options::OPT_fno_diagnostics_color)) {
3988 ShowColors = Colors_Off;
3989 } else {
3990 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003991 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00003992 if (value == "always")
3993 ShowColors = Colors_On;
3994 else if (value == "never")
3995 ShowColors = Colors_Off;
3996 else if (value == "auto")
3997 ShowColors = Colors_Auto;
3998 else
3999 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4000 << ("-fdiagnostics-color=" + value).str();
4001 }
4002 }
4003 if (ShowColors == Colors_On ||
4004 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004005 CmdArgs.push_back("-fcolor-diagnostics");
4006
Nico Rieck7857d462013-09-11 00:38:02 +00004007 if (Args.hasArg(options::OPT_fansi_escape_codes))
4008 CmdArgs.push_back("-fansi-escape-codes");
4009
Daniel Dunbardb097022009-06-08 21:13:54 +00004010 if (!Args.hasFlag(options::OPT_fshow_source_location,
4011 options::OPT_fno_show_source_location))
4012 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004013
Douglas Gregor643c9222011-05-21 17:07:29 +00004014 if (!Args.hasFlag(options::OPT_fshow_column,
4015 options::OPT_fno_show_column,
4016 true))
4017 CmdArgs.push_back("-fno-show-column");
4018
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004019 if (!Args.hasFlag(options::OPT_fspell_checking,
4020 options::OPT_fno_spell_checking))
4021 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004022
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004023
Chad Rosierc8e56e82012-12-05 21:08:21 +00004024 // -fno-asm-blocks is default.
4025 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4026 false))
4027 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004028
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004029 // Enable vectorization per default according to the optimization level
4030 // selected. For optimization levels that want vectorization we use the alias
4031 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004032 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004033 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004034 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004035 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004036 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004037 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004038
Chad Rosier136d67d2014-04-28 19:30:57 +00004039 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004040 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4041 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004042 options::OPT_fslp_vectorize;
4043 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004044 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004045 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004046
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004047 // -fno-slp-vectorize-aggressive is default.
4048 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004049 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004050 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004051
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004052 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4053 A->render(Args, CmdArgs);
4054
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004055 // -fdollars-in-identifiers default varies depending on platform and
4056 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004057 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004058 options::OPT_fno_dollars_in_identifiers)) {
4059 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004060 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004061 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004062 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004063 }
4064
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004065 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4066 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004067 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004068 options::OPT_fno_unit_at_a_time)) {
4069 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004070 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004071 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004072
Eli Friedman055c9702011-11-02 01:53:16 +00004073 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4074 options::OPT_fno_apple_pragma_pack, false))
4075 CmdArgs.push_back("-fapple-pragma-pack");
4076
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004077 // le32-specific flags:
4078 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4079 // by default.
4080 if (getToolChain().getArch() == llvm::Triple::le32) {
4081 CmdArgs.push_back("-fno-math-builtin");
4082 }
4083
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004084 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004085 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004086 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004087#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004088 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004089 (getToolChain().getArch() == llvm::Triple::arm ||
4090 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004091 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4092 CmdArgs.push_back("-fno-builtin-strcat");
4093 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4094 CmdArgs.push_back("-fno-builtin-strcpy");
4095 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004096#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004097
Justin Bognera88f0122014-06-20 22:59:50 +00004098 // Enable rewrite includes if the user's asked for it or if we're generating
4099 // diagnostics.
4100 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4101 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004102 if (Args.hasFlag(options::OPT_frewrite_includes,
4103 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004104 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004105 CmdArgs.push_back("-frewrite-includes");
4106
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004107 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004108 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004109 options::OPT_traditional_cpp)) {
4110 if (isa<PreprocessJobAction>(JA))
4111 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004112 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004113 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004114 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004115
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004116 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004117 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004118
4119 // Handle serialized diagnostics.
4120 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4121 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004122 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004123 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004124
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004125 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4126 CmdArgs.push_back("-fretain-comments-from-system-headers");
4127
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004128 // Forward -fcomment-block-commands to -cc1.
4129 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004130 // Forward -fparse-all-comments to -cc1.
4131 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004132
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004133 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4134 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004135 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004136 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4137 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004138 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004139
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004140 // We translate this by hand to the -cc1 argument, since nightly test uses
4141 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004142 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004143 CmdArgs.push_back("-disable-llvm-optzns");
4144 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004145 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004146 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004147
Daniel Dunbard67a3222009-03-30 06:36:42 +00004148 if (Output.getType() == types::TY_Dependencies) {
4149 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004150 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004151 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004152 CmdArgs.push_back(Output.getFilename());
4153 } else {
4154 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004155 }
4156
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004157 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004158 addDashXForInput(Args, II, CmdArgs);
4159
Daniel Dunbarb440f562010-08-02 02:38:21 +00004160 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004161 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004162 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004163 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004164 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004165
Chris Lattnere9d7d782009-11-03 19:50:27 +00004166 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4167
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004168 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004169
4170 // Optionally embed the -cc1 level arguments into the debug info, for build
4171 // analysis.
4172 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004173 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004174 for (const auto &Arg : Args)
4175 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004176
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004177 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004178 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004179 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004180 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004181 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004182 }
4183 CmdArgs.push_back("-dwarf-debug-flags");
4184 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4185 }
4186
Eric Christopherd3804002013-02-22 20:12:52 +00004187 // Add the split debug info name to the command lines here so we
4188 // can propagate it to the backend.
4189 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004190 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004191 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004192 const char *SplitDwarfOut;
4193 if (SplitDwarf) {
4194 CmdArgs.push_back("-split-dwarf-file");
4195 SplitDwarfOut = SplitDebugName(Args, Inputs);
4196 CmdArgs.push_back(SplitDwarfOut);
4197 }
4198
4199 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004200 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004201 Output.getType() == types::TY_Object &&
4202 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg1da044a2014-06-26 19:59:02 +00004203 Command *CLCommand = getCLFallback()->GetCommand(C, JA, Output, Inputs,
4204 Args, LinkingOutput);
David Majnemerf6072342014-07-01 22:24:56 +00004205 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004206 } else {
4207 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4208 }
4209
Daniel Dunbar17731772009-03-23 19:03:36 +00004210
Eric Christopherf1545832013-02-22 23:50:16 +00004211 // Handle the debug info splitting at object creation time if we're
4212 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004213 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004214 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004215 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004216
Roman Divacky178e01602011-02-10 16:52:03 +00004217 if (Arg *A = Args.getLastArg(options::OPT_pg))
4218 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004219 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004220 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004221
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004222 // Claim some arguments which clang supports automatically.
4223
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004224 // -fpch-preprocess is used with gcc to add a special marker in the output to
4225 // include the PCH file. Clang's PTH solution is completely transparent, so we
4226 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004227 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004228
Daniel Dunbar17731772009-03-23 19:03:36 +00004229 // Claim some arguments which clang doesn't support, but we don't
4230 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004231 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4232 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004233
Rafael Espindolab0092d72013-09-04 19:37:35 +00004234 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004235 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004236}
4237
John McCall5fb5df92012-06-20 06:18:46 +00004238/// Add options related to the Objective-C runtime/ABI.
4239///
4240/// Returns true if the runtime is non-fragile.
4241ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4242 ArgStringList &cmdArgs,
4243 RewriteKind rewriteKind) const {
4244 // Look for the controlling runtime option.
4245 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4246 options::OPT_fgnu_runtime,
4247 options::OPT_fobjc_runtime_EQ);
4248
4249 // Just forward -fobjc-runtime= to the frontend. This supercedes
4250 // options about fragility.
4251 if (runtimeArg &&
4252 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4253 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004254 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004255 if (runtime.tryParse(value)) {
4256 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4257 << value;
4258 }
4259
4260 runtimeArg->render(args, cmdArgs);
4261 return runtime;
4262 }
4263
4264 // Otherwise, we'll need the ABI "version". Version numbers are
4265 // slightly confusing for historical reasons:
4266 // 1 - Traditional "fragile" ABI
4267 // 2 - Non-fragile ABI, version 1
4268 // 3 - Non-fragile ABI, version 2
4269 unsigned objcABIVersion = 1;
4270 // If -fobjc-abi-version= is present, use that to set the version.
4271 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004272 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004273 if (value == "1")
4274 objcABIVersion = 1;
4275 else if (value == "2")
4276 objcABIVersion = 2;
4277 else if (value == "3")
4278 objcABIVersion = 3;
4279 else
4280 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4281 << value;
4282 } else {
4283 // Otherwise, determine if we are using the non-fragile ABI.
4284 bool nonFragileABIIsDefault =
4285 (rewriteKind == RK_NonFragile ||
4286 (rewriteKind == RK_None &&
4287 getToolChain().IsObjCNonFragileABIDefault()));
4288 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4289 options::OPT_fno_objc_nonfragile_abi,
4290 nonFragileABIIsDefault)) {
4291 // Determine the non-fragile ABI version to use.
4292#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4293 unsigned nonFragileABIVersion = 1;
4294#else
4295 unsigned nonFragileABIVersion = 2;
4296#endif
4297
4298 if (Arg *abiArg = args.getLastArg(
4299 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004300 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004301 if (value == "1")
4302 nonFragileABIVersion = 1;
4303 else if (value == "2")
4304 nonFragileABIVersion = 2;
4305 else
4306 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4307 << value;
4308 }
4309
4310 objcABIVersion = 1 + nonFragileABIVersion;
4311 } else {
4312 objcABIVersion = 1;
4313 }
4314 }
4315
4316 // We don't actually care about the ABI version other than whether
4317 // it's non-fragile.
4318 bool isNonFragile = objcABIVersion != 1;
4319
4320 // If we have no runtime argument, ask the toolchain for its default runtime.
4321 // However, the rewriter only really supports the Mac runtime, so assume that.
4322 ObjCRuntime runtime;
4323 if (!runtimeArg) {
4324 switch (rewriteKind) {
4325 case RK_None:
4326 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4327 break;
4328 case RK_Fragile:
4329 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4330 break;
4331 case RK_NonFragile:
4332 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4333 break;
4334 }
4335
4336 // -fnext-runtime
4337 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4338 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004339 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004340 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4341
4342 // Otherwise, build for a generic macosx port.
4343 } else {
4344 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4345 }
4346
4347 // -fgnu-runtime
4348 } else {
4349 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004350 // Legacy behaviour is to target the gnustep runtime if we are i
4351 // non-fragile mode or the GCC runtime in fragile mode.
4352 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004353 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004354 else
4355 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004356 }
4357
4358 cmdArgs.push_back(args.MakeArgString(
4359 "-fobjc-runtime=" + runtime.getAsString()));
4360 return runtime;
4361}
4362
Reid Klecknerc542d372014-06-27 17:02:02 +00004363static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4364 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4365 I += HaveDash;
4366 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004367}
Reid Klecknerc542d372014-06-27 17:02:02 +00004368
4369struct EHFlags {
4370 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4371 bool Synch;
4372 bool Asynch;
4373 bool NoExceptC;
4374};
4375
4376/// /EH controls whether to run destructor cleanups when exceptions are
4377/// thrown. There are three modifiers:
4378/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4379/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4380/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4381/// - c: Assume that extern "C" functions are implicitly noexcept. This
4382/// modifier is an optimization, so we ignore it for now.
4383/// The default is /EHs-c-, meaning cleanups are disabled.
4384static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4385 EHFlags EH;
4386 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4387 for (auto EHVal : EHArgs) {
4388 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4389 switch (EHVal[I]) {
4390 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4391 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4392 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4393 default: break;
4394 }
4395 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4396 break;
4397 }
4398 }
4399 return EH;
4400}
4401
Hans Wennborg75958c42013-08-08 00:17:41 +00004402void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4403 unsigned RTOptionID = options::OPT__SLASH_MT;
4404
Hans Wennborgf1a74252013-09-10 20:18:04 +00004405 if (Args.hasArg(options::OPT__SLASH_LDd))
4406 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4407 // but defining _DEBUG is sticky.
4408 RTOptionID = options::OPT__SLASH_MTd;
4409
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004410 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004411 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004412
Hans Wennborg75958c42013-08-08 00:17:41 +00004413 switch(RTOptionID) {
4414 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004415 if (Args.hasArg(options::OPT__SLASH_LDd))
4416 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004417 CmdArgs.push_back("-D_MT");
4418 CmdArgs.push_back("-D_DLL");
4419 CmdArgs.push_back("--dependent-lib=msvcrt");
4420 break;
4421 case options::OPT__SLASH_MDd:
4422 CmdArgs.push_back("-D_DEBUG");
4423 CmdArgs.push_back("-D_MT");
4424 CmdArgs.push_back("-D_DLL");
4425 CmdArgs.push_back("--dependent-lib=msvcrtd");
4426 break;
4427 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004428 if (Args.hasArg(options::OPT__SLASH_LDd))
4429 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004430 CmdArgs.push_back("-D_MT");
4431 CmdArgs.push_back("--dependent-lib=libcmt");
4432 break;
4433 case options::OPT__SLASH_MTd:
4434 CmdArgs.push_back("-D_DEBUG");
4435 CmdArgs.push_back("-D_MT");
4436 CmdArgs.push_back("--dependent-lib=libcmtd");
4437 break;
4438 default:
4439 llvm_unreachable("Unexpected option ID.");
4440 }
4441
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004442 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4443 // users want. The /Za flag to cl.exe turns this off, but it's not
4444 // implemented in clang.
4445 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004446
Hans Wennborg0fd62072013-08-09 00:32:23 +00004447 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4448 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004449
David Majnemerf6072342014-07-01 22:24:56 +00004450 // This controls whether or not we emit RTTI data for polymorphic types.
4451 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4452 /*default=*/false))
4453 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004454
Reid Klecknerc542d372014-06-27 17:02:02 +00004455 const Driver &D = getToolChain().getDriver();
4456 EHFlags EH = parseClangCLEHFlags(D, Args);
4457 // FIXME: Do something with NoExceptC.
4458 if (EH.Synch || EH.Asynch) {
4459 CmdArgs.push_back("-fexceptions");
4460 CmdArgs.push_back("-fcxx-exceptions");
4461 }
4462
Hans Wennborge50cec32014-06-13 20:59:54 +00004463 // /EP should expand to -E -P.
4464 if (Args.hasArg(options::OPT__SLASH_EP)) {
4465 CmdArgs.push_back("-E");
4466 CmdArgs.push_back("-P");
4467 }
4468
David Majnemer86c318f2014-02-11 21:05:00 +00004469 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4470 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4471 if (MostGeneralArg && BestCaseArg)
4472 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4473 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4474
4475 if (MostGeneralArg) {
4476 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4477 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4478 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4479
4480 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4481 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4482 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4483 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4484 << FirstConflict->getAsString(Args)
4485 << SecondConflict->getAsString(Args);
4486
4487 if (SingleArg)
4488 CmdArgs.push_back("-fms-memptr-rep=single");
4489 else if (MultipleArg)
4490 CmdArgs.push_back("-fms-memptr-rep=multiple");
4491 else
4492 CmdArgs.push_back("-fms-memptr-rep=virtual");
4493 }
4494
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004495 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4496 A->render(Args, CmdArgs);
4497
Hans Wennborg81f74482013-09-10 01:07:07 +00004498 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4499 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004500 if (Args.hasArg(options::OPT__SLASH_fallback))
4501 CmdArgs.push_back("msvc-fallback");
4502 else
4503 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004504 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004505}
4506
Hans Wennborg1da044a2014-06-26 19:59:02 +00004507visualstudio::Compile *Clang::getCLFallback() const {
4508 if (!CLFallback)
4509 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4510 return CLFallback.get();
4511}
4512
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004513void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004514 const InputInfo &Output,
4515 const InputInfoList &Inputs,
4516 const ArgList &Args,
4517 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004518 ArgStringList CmdArgs;
4519
4520 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4521 const InputInfo &Input = Inputs[0];
4522
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004523 // Don't warn about "clang -w -c foo.s"
4524 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004525 // and "clang -emit-llvm -c foo.s"
4526 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004527
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004528 // Invoke ourselves in -cc1as mode.
4529 //
4530 // FIXME: Implement custom jobs for internal actions.
4531 CmdArgs.push_back("-cc1as");
4532
4533 // Add the "effective" target triple.
4534 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004535 std::string TripleStr =
4536 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004537 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4538
4539 // Set the output mode, we currently only expect to be used as a real
4540 // assembler.
4541 CmdArgs.push_back("-filetype");
4542 CmdArgs.push_back("obj");
4543
Eric Christopher45f2e712012-12-18 00:31:10 +00004544 // Set the main file name, so that debug info works even with
4545 // -save-temps or preprocessed assembly.
4546 CmdArgs.push_back("-main-file-name");
4547 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4548
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004549 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004550 const llvm::Triple &Triple = getToolChain().getTriple();
4551 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004552 if (!CPU.empty()) {
4553 CmdArgs.push_back("-target-cpu");
4554 CmdArgs.push_back(Args.MakeArgString(CPU));
4555 }
4556
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004557 // Add the target features
4558 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004559 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004560
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004561 // Ignore explicit -force_cpusubtype_ALL option.
4562 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004563
Eric Christopherfc3ee562012-01-10 00:38:01 +00004564 // Determine the original source input.
4565 const Action *SourceAction = &JA;
4566 while (SourceAction->getKind() != Action::InputClass) {
4567 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4568 SourceAction = SourceAction->getInputs()[0];
4569 }
4570
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004571 // Forward -g and handle debug info related flags, assuming we are dealing
4572 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004573 if (SourceAction->getType() == types::TY_Asm ||
4574 SourceAction->getType() == types::TY_PP_Asm) {
4575 Args.ClaimAllArgs(options::OPT_g_Group);
4576 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4577 if (!A->getOption().matches(options::OPT_g0))
4578 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004579
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004580 if (Args.hasArg(options::OPT_gdwarf_2))
4581 CmdArgs.push_back("-gdwarf-2");
4582 if (Args.hasArg(options::OPT_gdwarf_3))
4583 CmdArgs.push_back("-gdwarf-3");
4584 if (Args.hasArg(options::OPT_gdwarf_4))
4585 CmdArgs.push_back("-gdwarf-4");
4586
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004587 // Add the -fdebug-compilation-dir flag if needed.
4588 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004589
4590 // Set the AT_producer to the clang version when using the integrated
4591 // assembler on assembly source files.
4592 CmdArgs.push_back("-dwarf-debug-producer");
4593 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004594 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004595
4596 // Optionally embed the -cc1as level arguments into the debug info, for build
4597 // analysis.
4598 if (getToolChain().UseDwarfDebugFlags()) {
4599 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004600 for (const auto &Arg : Args)
4601 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004602
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004603 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004604 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4605 Flags += Exec;
4606 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4607 Flags += " ";
4608 Flags += OriginalArgs[i];
4609 }
4610 CmdArgs.push_back("-dwarf-debug-flags");
4611 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4612 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004613
4614 // FIXME: Add -static support, once we have it.
4615
David Blaikie372d9502014-01-17 03:17:40 +00004616 // Consume all the warning flags. Usually this would be handled more
4617 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4618 // doesn't handle that so rather than warning about unused flags that are
4619 // actually used, we'll lie by omission instead.
4620 // FIXME: Stop lying and consume only the appropriate driver flags
4621 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4622 ie = Args.filtered_end();
4623 it != ie; ++it)
4624 (*it)->claim();
4625
David Blaikie9260ed62013-07-25 21:19:01 +00004626 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4627 getToolChain().getDriver());
4628
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004629 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004630
4631 assert(Output.isFilename() && "Unexpected lipo output.");
4632 CmdArgs.push_back("-o");
4633 CmdArgs.push_back(Output.getFilename());
4634
Daniel Dunbarb440f562010-08-02 02:38:21 +00004635 assert(Input.isFilename() && "Invalid input.");
4636 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004637
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004638 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004639 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004640
4641 // Handle the debug info splitting at object creation time if we're
4642 // creating an object.
4643 // TODO: Currently only works on linux with newer objcopy.
4644 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004645 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004646 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4647 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004648}
4649
Daniel Dunbara3246a02009-03-18 08:07:30 +00004650void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004651 const InputInfo &Output,
4652 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004653 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004654 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004655 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004656 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004657
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004658 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004659 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004660 // Don't forward any -g arguments to assembly steps.
4661 if (isa<AssembleJobAction>(JA) &&
4662 A->getOption().matches(options::OPT_g_Group))
4663 continue;
4664
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004665 // Don't forward any -W arguments to assembly and link steps.
4666 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4667 A->getOption().matches(options::OPT_W_Group))
4668 continue;
4669
Daniel Dunbar2da02722009-03-19 07:55:12 +00004670 // It is unfortunate that we have to claim here, as this means
4671 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004672 // platforms using a generic gcc, even if we are just using gcc
4673 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004674 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004675 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004676 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004677 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004678
Daniel Dunbar4e295052010-01-25 22:35:08 +00004679 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004680
4681 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004682 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004683 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004684 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004685
4686 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004687 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004688 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004689 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004690 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004691 else if (Arch == llvm::Triple::ppc64le)
4692 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004693 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004694 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004695 }
4696
Daniel Dunbar5716d872009-05-02 21:41:52 +00004697 // Try to force gcc to match the tool chain we want, if we recognize
4698 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004699 //
4700 // FIXME: The triple class should directly provide the information we want
4701 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004702 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004703 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004704 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4705 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004706 CmdArgs.push_back("-m64");
4707
Daniel Dunbarb440f562010-08-02 02:38:21 +00004708 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004709 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004710 CmdArgs.push_back(Output.getFilename());
4711 } else {
4712 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004713 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004714 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004715
Tony Linthicum76329bf2011-12-12 21:14:55 +00004716 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4717 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004718
4719 // Only pass -x if gcc will understand it; otherwise hope gcc
4720 // understands the suffix correctly. The main use case this would go
4721 // wrong in is for linker inputs if they happened to have an odd
4722 // suffix; really the only way to get this to happen is a command
4723 // like '-x foobar a.c' which will treat a.c like a linker input.
4724 //
4725 // FIXME: For the linker case specifically, can we safely convert
4726 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004727 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004728 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004729 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4730 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004731 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004732 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004733 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004734 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004735 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004736 else if (II.getType() == types::TY_ModuleFile)
4737 D.Diag(diag::err_drv_no_module_support)
4738 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004739
Daniel Dunbara3246a02009-03-18 08:07:30 +00004740 if (types::canTypeBeUserSpecified(II.getType())) {
4741 CmdArgs.push_back("-x");
4742 CmdArgs.push_back(types::getTypeName(II.getType()));
4743 }
4744
Daniel Dunbarb440f562010-08-02 02:38:21 +00004745 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004746 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004747 else {
4748 const Arg &A = II.getInputArg();
4749
4750 // Reverse translate some rewritten options.
4751 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4752 CmdArgs.push_back("-lstdc++");
4753 continue;
4754 }
4755
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004756 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004757 A.render(Args, CmdArgs);
4758 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004759 }
4760
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004761 const std::string customGCCName = D.getCCCGenericGCCName();
4762 const char *GCCName;
4763 if (!customGCCName.empty())
4764 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004765 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004766 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004767 } else
4768 GCCName = "gcc";
4769
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004770 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004771 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004772 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004773}
4774
Daniel Dunbar4e295052010-01-25 22:35:08 +00004775void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4776 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004777 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004778}
4779
Daniel Dunbar4e295052010-01-25 22:35:08 +00004780void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4781 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004782 const Driver &D = getToolChain().getDriver();
4783
Daniel Dunbar4e295052010-01-25 22:35:08 +00004784 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004785 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4786 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004787 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004788 else {
4789 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004790 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004791 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004792
Daniel Dunbar4e295052010-01-25 22:35:08 +00004793 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004794 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004795}
4796
Daniel Dunbar4e295052010-01-25 22:35:08 +00004797void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4798 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004799 // The types are (hopefully) good enough.
4800}
4801
Tony Linthicum76329bf2011-12-12 21:14:55 +00004802// Hexagon tools start.
4803void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4804 ArgStringList &CmdArgs) const {
4805
4806}
4807void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4808 const InputInfo &Output,
4809 const InputInfoList &Inputs,
4810 const ArgList &Args,
4811 const char *LinkingOutput) const {
4812
4813 const Driver &D = getToolChain().getDriver();
4814 ArgStringList CmdArgs;
4815
4816 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004817 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004818 CmdArgs.push_back(Args.MakeArgString(MarchString));
4819
4820 RenderExtraToolArgs(JA, CmdArgs);
4821
4822 if (Output.isFilename()) {
4823 CmdArgs.push_back("-o");
4824 CmdArgs.push_back(Output.getFilename());
4825 } else {
4826 assert(Output.isNothing() && "Unexpected output");
4827 CmdArgs.push_back("-fsyntax-only");
4828 }
4829
Matthew Curtise8f80a12012-12-06 17:49:03 +00004830 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4831 if (!SmallDataThreshold.empty())
4832 CmdArgs.push_back(
4833 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004834
Matthew Curtise5df3812012-12-07 17:23:04 +00004835 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4836 options::OPT_Xassembler);
4837
Tony Linthicum76329bf2011-12-12 21:14:55 +00004838 // Only pass -x if gcc will understand it; otherwise hope gcc
4839 // understands the suffix correctly. The main use case this would go
4840 // wrong in is for linker inputs if they happened to have an odd
4841 // suffix; really the only way to get this to happen is a command
4842 // like '-x foobar a.c' which will treat a.c like a linker input.
4843 //
4844 // FIXME: For the linker case specifically, can we safely convert
4845 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004846 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004847 // Don't try to pass LLVM or AST inputs to a generic gcc.
4848 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4849 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4850 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4851 << getToolChain().getTripleString();
4852 else if (II.getType() == types::TY_AST)
4853 D.Diag(clang::diag::err_drv_no_ast_support)
4854 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004855 else if (II.getType() == types::TY_ModuleFile)
4856 D.Diag(diag::err_drv_no_module_support)
4857 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004858
4859 if (II.isFilename())
4860 CmdArgs.push_back(II.getFilename());
4861 else
4862 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4863 II.getInputArg().render(Args, CmdArgs);
4864 }
4865
4866 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004867 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004868 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004869}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004870
Tony Linthicum76329bf2011-12-12 21:14:55 +00004871void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4872 ArgStringList &CmdArgs) const {
4873 // The types are (hopefully) good enough.
4874}
4875
4876void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4877 const InputInfo &Output,
4878 const InputInfoList &Inputs,
4879 const ArgList &Args,
4880 const char *LinkingOutput) const {
4881
Matthew Curtise689b052012-12-06 15:46:07 +00004882 const toolchains::Hexagon_TC& ToolChain =
4883 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4884 const Driver &D = ToolChain.getDriver();
4885
Tony Linthicum76329bf2011-12-12 21:14:55 +00004886 ArgStringList CmdArgs;
4887
Matthew Curtise689b052012-12-06 15:46:07 +00004888 //----------------------------------------------------------------------------
4889 //
4890 //----------------------------------------------------------------------------
4891 bool hasStaticArg = Args.hasArg(options::OPT_static);
4892 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004893 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004894 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4895 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4896 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4897 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004898
Matthew Curtise689b052012-12-06 15:46:07 +00004899 //----------------------------------------------------------------------------
4900 // Silence warnings for various options
4901 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004902
Matthew Curtise689b052012-12-06 15:46:07 +00004903 Args.ClaimAllArgs(options::OPT_g_Group);
4904 Args.ClaimAllArgs(options::OPT_emit_llvm);
4905 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4906 // handled somewhere else.
4907 Args.ClaimAllArgs(options::OPT_static_libgcc);
4908
4909 //----------------------------------------------------------------------------
4910 //
4911 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004912 for (const auto &Opt : ToolChain.ExtraOpts)
4913 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004914
Matthew Curtisf10a5952012-12-06 14:16:43 +00004915 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4916 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004917
Matthew Curtise689b052012-12-06 15:46:07 +00004918 if (buildingLib) {
4919 CmdArgs.push_back("-shared");
4920 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4921 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004922 }
4923
Matthew Curtise689b052012-12-06 15:46:07 +00004924 if (hasStaticArg)
4925 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004926
Matthew Curtise8f80a12012-12-06 17:49:03 +00004927 if (buildPIE && !buildingLib)
4928 CmdArgs.push_back("-pie");
4929
4930 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4931 if (!SmallDataThreshold.empty()) {
4932 CmdArgs.push_back(
4933 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4934 }
4935
Matthew Curtise689b052012-12-06 15:46:07 +00004936 //----------------------------------------------------------------------------
4937 //
4938 //----------------------------------------------------------------------------
4939 CmdArgs.push_back("-o");
4940 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004941
Matthew Curtise689b052012-12-06 15:46:07 +00004942 const std::string MarchSuffix = "/" + MarchString;
4943 const std::string G0Suffix = "/G0";
4944 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4945 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4946 + "/";
4947 const std::string StartFilesDir = RootDir
4948 + "hexagon/lib"
4949 + (buildingLib
4950 ? MarchG0Suffix : MarchSuffix);
4951
4952 //----------------------------------------------------------------------------
4953 // moslib
4954 //----------------------------------------------------------------------------
4955 std::vector<std::string> oslibs;
4956 bool hasStandalone= false;
4957
4958 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4959 ie = Args.filtered_end(); it != ie; ++it) {
4960 (*it)->claim();
4961 oslibs.push_back((*it)->getValue());
4962 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004963 }
Matthew Curtise689b052012-12-06 15:46:07 +00004964 if (oslibs.empty()) {
4965 oslibs.push_back("standalone");
4966 hasStandalone = true;
4967 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004968
Matthew Curtise689b052012-12-06 15:46:07 +00004969 //----------------------------------------------------------------------------
4970 // Start Files
4971 //----------------------------------------------------------------------------
4972 if (incStdLib && incStartFiles) {
4973
4974 if (!buildingLib) {
4975 if (hasStandalone) {
4976 CmdArgs.push_back(
4977 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4978 }
4979 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4980 }
4981 std::string initObj = useShared ? "/initS.o" : "/init.o";
4982 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4983 }
4984
4985 //----------------------------------------------------------------------------
4986 // Library Search Paths
4987 //----------------------------------------------------------------------------
4988 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004989 for (const auto &LibPath : LibPaths)
4990 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00004991
4992 //----------------------------------------------------------------------------
4993 //
4994 //----------------------------------------------------------------------------
4995 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4996 Args.AddAllArgs(CmdArgs, options::OPT_e);
4997 Args.AddAllArgs(CmdArgs, options::OPT_s);
4998 Args.AddAllArgs(CmdArgs, options::OPT_t);
4999 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5000
5001 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5002
5003 //----------------------------------------------------------------------------
5004 // Libraries
5005 //----------------------------------------------------------------------------
5006 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005007 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005008 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5009 CmdArgs.push_back("-lm");
5010 }
5011
5012 CmdArgs.push_back("--start-group");
5013
5014 if (!buildingLib) {
5015 for(std::vector<std::string>::iterator i = oslibs.begin(),
5016 e = oslibs.end(); i != e; ++i)
5017 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5018 CmdArgs.push_back("-lc");
5019 }
5020 CmdArgs.push_back("-lgcc");
5021
5022 CmdArgs.push_back("--end-group");
5023 }
5024
5025 //----------------------------------------------------------------------------
5026 // End files
5027 //----------------------------------------------------------------------------
5028 if (incStdLib && incStartFiles) {
5029 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5030 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5031 }
5032
5033 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005034 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005035}
5036// Hexagon tools end.
5037
Bernard Ogden31561762013-12-12 13:27:11 +00005038const char *arm::getARMCPUForMArch(const ArgList &Args,
5039 const llvm::Triple &Triple) {
5040 StringRef MArch;
5041 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5042 // Otherwise, if we have -march= choose the base CPU for that arch.
5043 MArch = A->getValue();
5044 } else {
5045 // Otherwise, use the Arch from the triple.
5046 MArch = Triple.getArchName();
5047 }
5048
5049 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005050 if (MArch == "native") {
5051 std::string CPU = llvm::sys::getHostCPUName();
5052 if (CPU != "generic") {
5053 // Translate the native cpu into the architecture. The switch below will
5054 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005055 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005056 }
5057 }
5058
Argyrios Kyrtzidis1b49db62014-07-10 01:03:37 +00005059 return driver::getARMCPUForMArch(MArch, Triple);
5060}
5061
5062/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
5063//
5064// FIXME: tblgen this.
5065const char *driver::getARMCPUForMArch(StringRef MArch,
5066 const llvm::Triple &Triple) {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005067 switch (Triple.getOS()) {
5068 case llvm::Triple::NetBSD:
Bernard Ogden31561762013-12-12 13:27:11 +00005069 if (MArch == "armv6")
5070 return "arm1176jzf-s";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005071 break;
5072 case llvm::Triple::Win32:
5073 // FIXME: this is invalid for WindowsCE
5074 return "cortex-a9";
5075 default:
5076 break;
Bernard Ogden31561762013-12-12 13:27:11 +00005077 }
5078
Christian Pirker918d1092014-05-05 08:48:18 +00005079 const char *result = nullptr;
5080 size_t offset = StringRef::npos;
5081 if (MArch.startswith("arm"))
5082 offset = 3;
5083 if (MArch.startswith("thumb"))
5084 offset = 5;
5085 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
5086 offset += 2;
5087 if (offset != StringRef::npos)
5088 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
5089 .Cases("v2", "v2a", "arm2")
5090 .Case("v3", "arm6")
5091 .Case("v3m", "arm7m")
5092 .Case("v4", "strongarm")
5093 .Case("v4t", "arm7tdmi")
5094 .Cases("v5", "v5t", "arm10tdmi")
5095 .Cases("v5e", "v5te", "arm1022e")
5096 .Case("v5tej", "arm926ej-s")
5097 .Cases("v6", "v6k", "arm1136jf-s")
5098 .Case("v6j", "arm1136j-s")
5099 .Cases("v6z", "v6zk", "arm1176jzf-s")
5100 .Case("v6t2", "arm1156t2-s")
5101 .Cases("v6m", "v6-m", "cortex-m0")
5102 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
5103 .Cases("v7s", "v7-s", "swift")
5104 .Cases("v7r", "v7-r", "cortex-r4")
5105 .Cases("v7m", "v7-m", "cortex-m3")
5106 .Cases("v7em", "v7e-m", "cortex-m4")
5107 .Cases("v8", "v8a", "v8-a", "cortex-a53")
5108 .Default(nullptr);
5109 else
5110 result = llvm::StringSwitch<const char *>(MArch)
5111 .Case("ep9312", "ep9312")
5112 .Case("iwmmxt", "iwmmxt")
5113 .Case("xscale", "xscale")
5114 .Default(nullptr);
Bernard Ogden31561762013-12-12 13:27:11 +00005115
5116 if (result)
5117 return result;
5118
Christian Pirker918d1092014-05-05 08:48:18 +00005119 // If all else failed, return the most base CPU with thumb interworking
5120 // supported by LLVM.
5121 // FIXME: Should warn once that we're falling back.
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00005122 switch (Triple.getOS()) {
5123 case llvm::Triple::NetBSD:
5124 switch (Triple.getEnvironment()) {
5125 case llvm::Triple::GNUEABIHF:
5126 case llvm::Triple::GNUEABI:
5127 case llvm::Triple::EABIHF:
5128 case llvm::Triple::EABI:
5129 return "arm926ej-s";
5130 default:
5131 return "strongarm";
5132 }
5133 default:
5134 switch (Triple.getEnvironment()) {
5135 case llvm::Triple::EABIHF:
5136 case llvm::Triple::GNUEABIHF:
5137 return "arm1176jzf-s";
5138 default:
5139 return "arm7tdmi";
5140 }
5141 }
Bernard Ogden31561762013-12-12 13:27:11 +00005142}
5143
5144/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005145StringRef arm::getARMTargetCPU(const ArgList &Args,
5146 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005147 // FIXME: Warn on inconsistent use of -mcpu and -march.
5148 // If we have -mcpu=, use that.
5149 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5150 StringRef MCPU = A->getValue();
5151 // Handle -mcpu=native.
5152 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005153 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005154 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005155 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005156 }
5157
5158 return getARMCPUForMArch(Args, Triple);
5159}
5160
5161/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5162/// CPU.
5163//
5164// FIXME: This is redundant with -mcpu, why does LLVM use this.
5165// FIXME: tblgen this, or kill it!
5166const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5167 return llvm::StringSwitch<const char *>(CPU)
5168 .Case("strongarm", "v4")
5169 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5170 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5171 .Cases("arm920", "arm920t", "arm922t", "v4t")
5172 .Cases("arm940t", "ep9312","v4t")
5173 .Cases("arm10tdmi", "arm1020t", "v5")
5174 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5175 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5176 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5177 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5178 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5179 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005180 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005181 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5182 .Cases("cortex-r4", "cortex-r5", "v7r")
5183 .Case("cortex-m0", "v6m")
5184 .Case("cortex-m3", "v7m")
5185 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005186 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005187 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005188 .Cases("cortex-a53", "cortex-a57", "v8")
5189 .Default("");
5190}
5191
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005192bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5193 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5194 return A && (A->getValue() == StringRef(Value));
5195}
5196
Daniel Sanders2bf13662014-07-10 14:40:57 +00005197bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005198 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5199 return llvm::StringSwitch<bool>(NaNArg->getValue())
5200 .Case("2008", true)
5201 .Case("legacy", false)
5202 .Default(false);
5203
5204 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005205 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5206 .Cases("mips32r6", "mips64r6", true)
5207 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005208
5209 return false;
5210}
5211
Tim Northover157d9112014-01-16 08:48:16 +00005212llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005213 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5214 // archs which Darwin doesn't use.
5215
5216 // The matching this routine does is fairly pointless, since it is neither the
5217 // complete architecture list, nor a reasonable subset. The problem is that
5218 // historically the driver driver accepts this and also ties its -march=
5219 // handling to the architecture name, so we need to be careful before removing
5220 // support for it.
5221
5222 // This code must be kept in sync with Clang's Darwin specific argument
5223 // translation.
5224
5225 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5226 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5227 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5228 .Case("ppc64", llvm::Triple::ppc64)
5229 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5230 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5231 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005232 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005233 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005234 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005235 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005236 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005237 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005238 .Case("r600", llvm::Triple::r600)
5239 .Case("nvptx", llvm::Triple::nvptx)
5240 .Case("nvptx64", llvm::Triple::nvptx64)
5241 .Case("amdil", llvm::Triple::amdil)
5242 .Case("spir", llvm::Triple::spir)
5243 .Default(llvm::Triple::UnknownArch);
5244}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005245
Tim Northover157d9112014-01-16 08:48:16 +00005246void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5247 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5248 T.setArch(Arch);
5249
5250 if (Str == "x86_64h")
5251 T.setArchName(Str);
5252 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5253 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005254 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005255 }
5256}
5257
Bob Wilsondecc03e2012-11-23 06:14:39 +00005258const char *Clang::getBaseInputName(const ArgList &Args,
5259 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005260 return Args.MakeArgString(
5261 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005262}
5263
Bob Wilsondecc03e2012-11-23 06:14:39 +00005264const char *Clang::getBaseInputStem(const ArgList &Args,
5265 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005266 const char *Str = getBaseInputName(Args, Inputs);
5267
Chris Lattner906bb902011-01-16 08:14:11 +00005268 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005269 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005270
5271 return Str;
5272}
5273
Bob Wilsondecc03e2012-11-23 06:14:39 +00005274const char *Clang::getDependencyFileName(const ArgList &Args,
5275 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005276 // FIXME: Think about this more.
5277 std::string Res;
5278
5279 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005280 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005281 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005282 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005283 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005284 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005285 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005286}
5287
Daniel Dunbarbe220842009-03-20 16:06:39 +00005288void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005289 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005290 const InputInfoList &Inputs,
5291 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005292 const char *LinkingOutput) const {
5293 ArgStringList CmdArgs;
5294
5295 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5296 const InputInfo &Input = Inputs[0];
5297
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005298 // Determine the original source input.
5299 const Action *SourceAction = &JA;
5300 while (SourceAction->getKind() != Action::InputClass) {
5301 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5302 SourceAction = SourceAction->getInputs()[0];
5303 }
5304
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005305 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005306 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005307 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5308 // FIXME: at run-time detect assembler capabilities or rely on version
5309 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005310 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005311 const llvm::Triple &T(getToolChain().getTriple());
5312 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005313 CmdArgs.push_back("-Q");
5314 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005315
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005316 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005317 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005318 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005319 if (Args.hasArg(options::OPT_gstabs))
5320 CmdArgs.push_back("--gstabs");
5321 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005322 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005323 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005324
Daniel Dunbarbe220842009-03-20 16:06:39 +00005325 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005326 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005327
Daniel Dunbar6d484762010-07-22 01:47:22 +00005328 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005329 if (getToolChain().getArch() == llvm::Triple::x86 ||
5330 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005331 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5332 CmdArgs.push_back("-force_cpusubtype_ALL");
5333
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005334 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005335 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005336 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005337 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005338 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005339 CmdArgs.push_back("-static");
5340
Daniel Dunbarbe220842009-03-20 16:06:39 +00005341 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5342 options::OPT_Xassembler);
5343
5344 assert(Output.isFilename() && "Unexpected lipo output.");
5345 CmdArgs.push_back("-o");
5346 CmdArgs.push_back(Output.getFilename());
5347
Daniel Dunbarb440f562010-08-02 02:38:21 +00005348 assert(Input.isFilename() && "Invalid input.");
5349 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005350
5351 // asm_final spec is empty.
5352
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005353 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005354 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005355 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005356}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005357
Tim Northover157d9112014-01-16 08:48:16 +00005358void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005359
Tim Northover157d9112014-01-16 08:48:16 +00005360void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5361 ArgStringList &CmdArgs) const {
5362 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005363
Daniel Dunbarc1964212009-03-26 16:23:12 +00005364 // Derived from darwin_arch spec.
5365 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005366 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005367
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005368 // FIXME: Is this needed anymore?
5369 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005370 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005371}
5372
Bill Wendling3b2000f2012-10-02 18:02:50 +00005373bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5374 // We only need to generate a temp path for LTO if we aren't compiling object
5375 // files. When compiling source files, we run 'dsymutil' after linking. We
5376 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005377 for (const auto &Input : Inputs)
5378 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005379 return true;
5380
5381 return false;
5382}
5383
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005384void darwin::Link::AddLinkArgs(Compilation &C,
5385 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005386 ArgStringList &CmdArgs,
5387 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005388 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005389 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005390
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005391 unsigned Version[3] = { 0, 0, 0 };
5392 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5393 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005394 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005395 Version[1], Version[2], HadExtra) ||
5396 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005397 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005398 << A->getAsString(Args);
5399 }
5400
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005401 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005402 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005403 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5404 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005405
Bob Wilson3d27dad2013-08-02 22:25:34 +00005406 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5407 CmdArgs.push_back("-export_dynamic");
5408
Bill Wendling313b6bf2012-11-16 23:03:00 +00005409 // If we are using LTO, then automatically create a temporary file path for
5410 // the linker to use, so that it's lifetime will extend past a possible
5411 // dsymutil step.
5412 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5413 const char *TmpPath = C.getArgs().MakeArgString(
5414 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5415 C.addTempFile(TmpPath);
5416 CmdArgs.push_back("-object_path_lto");
5417 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005418 }
5419
Daniel Dunbarc1964212009-03-26 16:23:12 +00005420 // Derived from the "link" spec.
5421 Args.AddAllArgs(CmdArgs, options::OPT_static);
5422 if (!Args.hasArg(options::OPT_static))
5423 CmdArgs.push_back("-dynamic");
5424 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5425 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5426 // here. How do we wish to handle such things?
5427 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005428
Daniel Dunbarc1964212009-03-26 16:23:12 +00005429 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005430 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005431 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005432 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005433
5434 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5435 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5436 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5437
5438 Arg *A;
5439 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5440 (A = Args.getLastArg(options::OPT_current__version)) ||
5441 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005442 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005443 << A->getAsString(Args) << "-dynamiclib";
5444
5445 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5446 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5447 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5448 } else {
5449 CmdArgs.push_back("-dylib");
5450
5451 Arg *A;
5452 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5453 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5454 (A = Args.getLastArg(options::OPT_client__name)) ||
5455 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5456 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5457 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005458 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005459 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005460
Daniel Dunbarc1964212009-03-26 16:23:12 +00005461 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5462 "-dylib_compatibility_version");
5463 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5464 "-dylib_current_version");
5465
Tim Northover157d9112014-01-16 08:48:16 +00005466 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005467
5468 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5469 "-dylib_install_name");
5470 }
5471
5472 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5473 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5474 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005475 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005476 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005477 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5478 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5479 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5480 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5481 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5482 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005483 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005484 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5485 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5486 Args.AddAllArgs(CmdArgs, options::OPT_init);
5487
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005488 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005489 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005490
Daniel Dunbarc1964212009-03-26 16:23:12 +00005491 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5492 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5493 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5494 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5495 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005496
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005497 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5498 options::OPT_fno_pie,
5499 options::OPT_fno_PIE)) {
5500 if (A->getOption().matches(options::OPT_fpie) ||
5501 A->getOption().matches(options::OPT_fPIE))
5502 CmdArgs.push_back("-pie");
5503 else
5504 CmdArgs.push_back("-no_pie");
5505 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005506
5507 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5508 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5509 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5510 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5511 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5512 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5513 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5514 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5515 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5516 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5517 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5518 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5519 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5520 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5521 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5522 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005523
Daniel Dunbar84384642011-05-02 21:03:47 +00005524 // Give --sysroot= preference, over the Apple specific behavior to also use
5525 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005526 StringRef sysroot = C.getSysRoot();
5527 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005528 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005529 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005530 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5531 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005532 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005533 }
5534
Daniel Dunbarc1964212009-03-26 16:23:12 +00005535 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5536 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5537 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5538 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5539 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005540 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005541 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5542 Args.AddAllArgs(CmdArgs, options::OPT_y);
5543 Args.AddLastArg(CmdArgs, options::OPT_w);
5544 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5545 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5546 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5547 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5548 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5549 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5550 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5551 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5552 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5553 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5554 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5555 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5556}
5557
Alexey Bataev186b28a2014-03-06 05:43:53 +00005558enum LibOpenMP {
5559 LibUnknown,
5560 LibGOMP,
5561 LibIOMP5
5562};
5563
Daniel Dunbarc1964212009-03-26 16:23:12 +00005564void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005565 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005566 const InputInfoList &Inputs,
5567 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005568 const char *LinkingOutput) const {
5569 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005570
Daniel Dunbarc1964212009-03-26 16:23:12 +00005571 // The logic here is derived from gcc's behavior; most of which
5572 // comes from specs (starting with link_command). Consult gcc for
5573 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005574 ArgStringList CmdArgs;
5575
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005576 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5577 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5578 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005579 for (const auto &Arg : Args)
5580 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005581 const char *Exec =
5582 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5583 CmdArgs.push_back(Output.getFilename());
5584 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5585 return;
5586 }
5587
Daniel Dunbarc1964212009-03-26 16:23:12 +00005588 // I'm not sure why this particular decomposition exists in gcc, but
5589 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005590 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005591
Daniel Dunbarc1964212009-03-26 16:23:12 +00005592 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5593 Args.AddAllArgs(CmdArgs, options::OPT_s);
5594 Args.AddAllArgs(CmdArgs, options::OPT_t);
5595 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5596 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005597 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005598 Args.AddAllArgs(CmdArgs, options::OPT_r);
5599
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005600 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5601 // members of static archive libraries which implement Objective-C classes or
5602 // categories.
5603 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5604 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005605
Daniel Dunbarc1964212009-03-26 16:23:12 +00005606 CmdArgs.push_back("-o");
5607 CmdArgs.push_back(Output.getFilename());
5608
Chad Rosier06fd3c62012-05-16 23:45:12 +00005609 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005610 !Args.hasArg(options::OPT_nostartfiles))
5611 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005612
5613 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005614
Alexey Bataev186b28a2014-03-06 05:43:53 +00005615 LibOpenMP UsedOpenMPLib = LibUnknown;
5616 if (Args.hasArg(options::OPT_fopenmp)) {
5617 UsedOpenMPLib = LibGOMP;
5618 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5619 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5620 .Case("libgomp", LibGOMP)
5621 .Case("libiomp5", LibIOMP5)
5622 .Default(LibUnknown);
5623 if (UsedOpenMPLib == LibUnknown)
5624 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5625 << A->getOption().getName() << A->getValue();
5626 }
5627 switch (UsedOpenMPLib) {
5628 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005629 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005630 break;
5631 case LibIOMP5:
5632 CmdArgs.push_back("-liomp5");
5633 break;
5634 case LibUnknown:
5635 break;
5636 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005637
Douglas Gregor9295df02012-05-15 21:00:27 +00005638 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5639
Bob Wilson16d93952012-05-15 18:57:39 +00005640 if (isObjCRuntimeLinked(Args) &&
5641 !Args.hasArg(options::OPT_nostdlib) &&
5642 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005643 // We use arclite library for both ARC and subscripting support.
5644 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5645
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005646 CmdArgs.push_back("-framework");
5647 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005648 // Link libobj.
5649 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005650 }
John McCall31168b02011-06-15 23:02:42 +00005651
Daniel Dunbarc1964212009-03-26 16:23:12 +00005652 if (LinkingOutput) {
5653 CmdArgs.push_back("-arch_multiple");
5654 CmdArgs.push_back("-final_output");
5655 CmdArgs.push_back(LinkingOutput);
5656 }
5657
Daniel Dunbarc1964212009-03-26 16:23:12 +00005658 if (Args.hasArg(options::OPT_fnested_functions))
5659 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005660
Daniel Dunbarc1964212009-03-26 16:23:12 +00005661 if (!Args.hasArg(options::OPT_nostdlib) &&
5662 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005663 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005664 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005665
Daniel Dunbarc1964212009-03-26 16:23:12 +00005666 // link_ssp spec is empty.
5667
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005668 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005669 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005670 }
5671
Chad Rosier06fd3c62012-05-16 23:45:12 +00005672 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005673 !Args.hasArg(options::OPT_nostartfiles)) {
5674 // endfile_spec is empty.
5675 }
5676
5677 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5678 Args.AddAllArgs(CmdArgs, options::OPT_F);
5679
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005680 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005681 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005682 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005683}
5684
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005685void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005686 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005687 const InputInfoList &Inputs,
5688 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005689 const char *LinkingOutput) const {
5690 ArgStringList CmdArgs;
5691
5692 CmdArgs.push_back("-create");
5693 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005694
5695 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005696 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005697
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005698 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005699 assert(II.isFilename() && "Unexpected lipo input.");
5700 CmdArgs.push_back(II.getFilename());
5701 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005702
5703 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005704 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005705}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005706
Daniel Dunbar88299622010-06-04 18:28:36 +00005707void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005708 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005709 const InputInfoList &Inputs,
5710 const ArgList &Args,
5711 const char *LinkingOutput) const {
5712 ArgStringList CmdArgs;
5713
Daniel Dunbareb86b042011-05-09 17:23:16 +00005714 CmdArgs.push_back("-o");
5715 CmdArgs.push_back(Output.getFilename());
5716
Daniel Dunbar88299622010-06-04 18:28:36 +00005717 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5718 const InputInfo &Input = Inputs[0];
5719 assert(Input.isFilename() && "Unexpected dsymutil input.");
5720 CmdArgs.push_back(Input.getFilename());
5721
Daniel Dunbar88299622010-06-04 18:28:36 +00005722 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005723 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005724 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005725}
5726
Eric Christopher551ef452011-08-23 17:56:55 +00005727void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005728 const InputInfo &Output,
5729 const InputInfoList &Inputs,
5730 const ArgList &Args,
5731 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005732 ArgStringList CmdArgs;
5733 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005734 CmdArgs.push_back("--debug-info");
5735 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005736 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005737
5738 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5739 const InputInfo &Input = Inputs[0];
5740 assert(Input.isFilename() && "Unexpected verify input");
5741
5742 // Grabbing the output of the earlier dsymutil run.
5743 CmdArgs.push_back(Input.getFilename());
5744
5745 const char *Exec =
5746 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5747 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5748}
5749
David Chisnallf571cde2012-02-15 13:39:01 +00005750void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5751 const InputInfo &Output,
5752 const InputInfoList &Inputs,
5753 const ArgList &Args,
5754 const char *LinkingOutput) const {
5755 ArgStringList CmdArgs;
5756
5757 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5758 options::OPT_Xassembler);
5759
5760 CmdArgs.push_back("-o");
5761 CmdArgs.push_back(Output.getFilename());
5762
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005763 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005764 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005765
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005766 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Chisnallf571cde2012-02-15 13:39:01 +00005767 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5768}
5769
David Chisnallf571cde2012-02-15 13:39:01 +00005770void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5771 const InputInfo &Output,
5772 const InputInfoList &Inputs,
5773 const ArgList &Args,
5774 const char *LinkingOutput) const {
5775 // FIXME: Find a real GCC, don't hard-code versions here
5776 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5777 const llvm::Triple &T = getToolChain().getTriple();
5778 std::string LibPath = "/usr/lib/";
5779 llvm::Triple::ArchType Arch = T.getArch();
5780 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005781 case llvm::Triple::x86:
5782 GCCLibPath +=
5783 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5784 break;
5785 case llvm::Triple::x86_64:
5786 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5787 GCCLibPath += "/4.5.2/amd64/";
5788 LibPath += "amd64/";
5789 break;
5790 default:
5791 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005792 }
5793
5794 ArgStringList CmdArgs;
5795
David Chisnall272a0712012-02-29 15:06:12 +00005796 // Demangle C++ names in errors
5797 CmdArgs.push_back("-C");
5798
David Chisnallf571cde2012-02-15 13:39:01 +00005799 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5800 (!Args.hasArg(options::OPT_shared))) {
5801 CmdArgs.push_back("-e");
5802 CmdArgs.push_back("_start");
5803 }
5804
5805 if (Args.hasArg(options::OPT_static)) {
5806 CmdArgs.push_back("-Bstatic");
5807 CmdArgs.push_back("-dn");
5808 } else {
5809 CmdArgs.push_back("-Bdynamic");
5810 if (Args.hasArg(options::OPT_shared)) {
5811 CmdArgs.push_back("-shared");
5812 } else {
5813 CmdArgs.push_back("--dynamic-linker");
5814 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5815 }
5816 }
5817
5818 if (Output.isFilename()) {
5819 CmdArgs.push_back("-o");
5820 CmdArgs.push_back(Output.getFilename());
5821 } else {
5822 assert(Output.isNothing() && "Invalid output.");
5823 }
5824
5825 if (!Args.hasArg(options::OPT_nostdlib) &&
5826 !Args.hasArg(options::OPT_nostartfiles)) {
5827 if (!Args.hasArg(options::OPT_shared)) {
5828 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5829 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005830 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005831 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5832 } else {
5833 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005834 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5835 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005836 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005837 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005838 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005839 }
5840
5841 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5842
5843 Args.AddAllArgs(CmdArgs, options::OPT_L);
5844 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5845 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005846 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005847
5848 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5849
5850 if (!Args.hasArg(options::OPT_nostdlib) &&
5851 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005852 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005853 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005854 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005855 if (!Args.hasArg(options::OPT_shared)) {
5856 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005857 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005858 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005859 }
David Chisnallf571cde2012-02-15 13:39:01 +00005860 }
5861
5862 if (!Args.hasArg(options::OPT_nostdlib) &&
5863 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005864 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005865 }
David Chisnall96de9932012-02-16 16:00:47 +00005866 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005867
Alexey Samsonov7811d192014-02-20 13:57:37 +00005868 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005869
5870 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005871 Args.MakeArgString(getToolChain().GetLinkerPath());
David Chisnallf571cde2012-02-15 13:39:01 +00005872 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5873}
5874
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005875void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005876 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005877 const InputInfoList &Inputs,
5878 const ArgList &Args,
5879 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005880 ArgStringList CmdArgs;
5881
5882 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5883 options::OPT_Xassembler);
5884
5885 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005886 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005887
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005888 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00005889 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005890
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005891 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005892 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005893}
5894
5895void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005896 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005897 const InputInfoList &Inputs,
5898 const ArgList &Args,
5899 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005900 ArgStringList CmdArgs;
5901
5902 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005903 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005904 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005905 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005906 }
5907
5908 if (Args.hasArg(options::OPT_static)) {
5909 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005910 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005911 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005912// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005913 CmdArgs.push_back("-Bdynamic");
5914 if (Args.hasArg(options::OPT_shared)) {
5915 CmdArgs.push_back("-shared");
5916 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005917 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005918 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5919 }
5920 }
5921
Daniel Dunbarb440f562010-08-02 02:38:21 +00005922 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005923 CmdArgs.push_back("-o");
5924 CmdArgs.push_back(Output.getFilename());
5925 } else {
5926 assert(Output.isNothing() && "Invalid output.");
5927 }
5928
5929 if (!Args.hasArg(options::OPT_nostdlib) &&
5930 !Args.hasArg(options::OPT_nostartfiles)) {
5931 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005932 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005933 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005934 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005935 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005936 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005937 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005938 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005939 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005940 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005941 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005942 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005943 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005944 }
5945
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005946 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5947 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005948 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005949
5950 Args.AddAllArgs(CmdArgs, options::OPT_L);
5951 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5952 Args.AddAllArgs(CmdArgs, options::OPT_e);
5953
Daniel Dunbar54423b22010-09-17 00:24:54 +00005954 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005955
5956 if (!Args.hasArg(options::OPT_nostdlib) &&
5957 !Args.hasArg(options::OPT_nodefaultlibs)) {
5958 // FIXME: For some reason GCC passes -lgcc before adding
5959 // the default system libraries. Just mimic this for now.
5960 CmdArgs.push_back("-lgcc");
5961
5962 if (Args.hasArg(options::OPT_pthread))
5963 CmdArgs.push_back("-pthread");
5964 if (!Args.hasArg(options::OPT_shared))
5965 CmdArgs.push_back("-lc");
5966 CmdArgs.push_back("-lgcc");
5967 }
5968
5969 if (!Args.hasArg(options::OPT_nostdlib) &&
5970 !Args.hasArg(options::OPT_nostartfiles)) {
5971 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005972 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005973 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005974 }
5975
Alexey Samsonov7811d192014-02-20 13:57:37 +00005976 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005977
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005978 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005979 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005980 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005981}
5982
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005983void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005984 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005985 const InputInfoList &Inputs,
5986 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005987 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005988 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005989 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005990
Rafael Espindolacc126272014-02-28 01:55:21 +00005991 switch (getToolChain().getArch()) {
5992 case llvm::Triple::x86:
5993 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5994 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005995 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005996 break;
5997
5998 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005999 CmdArgs.push_back("-mppc");
6000 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006001 break;
6002
6003 case llvm::Triple::sparc:
6004 CmdArgs.push_back("-32");
6005 NeedsKPIC = true;
6006 break;
6007
6008 case llvm::Triple::sparcv9:
6009 CmdArgs.push_back("-64");
6010 CmdArgs.push_back("-Av9a");
6011 NeedsKPIC = true;
6012 break;
6013
6014 case llvm::Triple::mips64:
6015 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006016 StringRef CPUName;
6017 StringRef ABIName;
6018 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6019
6020 CmdArgs.push_back("-mabi");
6021 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6022
6023 if (getToolChain().getArch() == llvm::Triple::mips64)
6024 CmdArgs.push_back("-EB");
6025 else
6026 CmdArgs.push_back("-EL");
6027
Rafael Espindolacc126272014-02-28 01:55:21 +00006028 NeedsKPIC = true;
6029 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006030 }
6031
Rafael Espindolacc126272014-02-28 01:55:21 +00006032 default:
6033 break;
6034 }
6035
6036 if (NeedsKPIC)
6037 addAssemblerKPIC(Args, CmdArgs);
6038
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006039 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6040 options::OPT_Xassembler);
6041
6042 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006043 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006044
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006045 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006046 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006047
6048 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006049 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006050 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006051}
6052
6053void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006054 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006055 const InputInfoList &Inputs,
6056 const ArgList &Args,
6057 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006058 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006059 ArgStringList CmdArgs;
6060
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006061 // Silence warning for "clang -g foo.o -o foo"
6062 Args.ClaimAllArgs(options::OPT_g_Group);
6063 // and "clang -emit-llvm foo.o -o foo"
6064 Args.ClaimAllArgs(options::OPT_emit_llvm);
6065 // and for "clang -w foo.o -o foo". Other warning options are already
6066 // handled somewhere else.
6067 Args.ClaimAllArgs(options::OPT_w);
6068
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006069 if (getToolChain().getArch() == llvm::Triple::mips64)
6070 CmdArgs.push_back("-EB");
6071 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6072 CmdArgs.push_back("-EL");
6073
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006074 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006075 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006076 CmdArgs.push_back("-e");
6077 CmdArgs.push_back("__start");
6078 }
6079
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006080 if (Args.hasArg(options::OPT_static)) {
6081 CmdArgs.push_back("-Bstatic");
6082 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006083 if (Args.hasArg(options::OPT_rdynamic))
6084 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006085 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006086 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006087 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006088 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006089 } else {
6090 CmdArgs.push_back("-dynamic-linker");
6091 CmdArgs.push_back("/usr/libexec/ld.so");
6092 }
6093 }
6094
Rafael Espindola044f7832013-06-05 04:28:55 +00006095 if (Args.hasArg(options::OPT_nopie))
6096 CmdArgs.push_back("-nopie");
6097
Daniel Dunbarb440f562010-08-02 02:38:21 +00006098 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006099 CmdArgs.push_back("-o");
6100 CmdArgs.push_back(Output.getFilename());
6101 } else {
6102 assert(Output.isNothing() && "Invalid output.");
6103 }
6104
6105 if (!Args.hasArg(options::OPT_nostdlib) &&
6106 !Args.hasArg(options::OPT_nostartfiles)) {
6107 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006108 if (Args.hasArg(options::OPT_pg))
6109 CmdArgs.push_back(Args.MakeArgString(
6110 getToolChain().GetFilePath("gcrt0.o")));
6111 else
6112 CmdArgs.push_back(Args.MakeArgString(
6113 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006114 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006115 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006116 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006117 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006118 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006119 }
6120 }
6121
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006122 std::string Triple = getToolChain().getTripleString();
6123 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006124 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006125 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006126 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006127
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006128 Args.AddAllArgs(CmdArgs, options::OPT_L);
6129 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6130 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006131 Args.AddAllArgs(CmdArgs, options::OPT_s);
6132 Args.AddAllArgs(CmdArgs, options::OPT_t);
6133 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6134 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006135
Daniel Dunbar54423b22010-09-17 00:24:54 +00006136 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006137
6138 if (!Args.hasArg(options::OPT_nostdlib) &&
6139 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006140 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006141 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006142 if (Args.hasArg(options::OPT_pg))
6143 CmdArgs.push_back("-lm_p");
6144 else
6145 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006146 }
6147
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006148 // FIXME: For some reason GCC passes -lgcc before adding
6149 // the default system libraries. Just mimic this for now.
6150 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006151
Eric Christopher17674ec2012-09-13 06:32:34 +00006152 if (Args.hasArg(options::OPT_pthread)) {
6153 if (!Args.hasArg(options::OPT_shared) &&
6154 Args.hasArg(options::OPT_pg))
6155 CmdArgs.push_back("-lpthread_p");
6156 else
6157 CmdArgs.push_back("-lpthread");
6158 }
6159
Chandler Carruth45661652011-12-17 22:32:42 +00006160 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006161 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006162 CmdArgs.push_back("-lc_p");
6163 else
6164 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006165 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006166
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006167 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006168 }
6169
6170 if (!Args.hasArg(options::OPT_nostdlib) &&
6171 !Args.hasArg(options::OPT_nostartfiles)) {
6172 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006173 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006174 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006175 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006176 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006177 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006178 }
6179
6180 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006181 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006182 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006183}
Ed Schoutene33194b2009-04-02 19:13:12 +00006184
Eli Friedman9fa28852012-08-08 23:57:20 +00006185void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6186 const InputInfo &Output,
6187 const InputInfoList &Inputs,
6188 const ArgList &Args,
6189 const char *LinkingOutput) const {
6190 ArgStringList CmdArgs;
6191
6192 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6193 options::OPT_Xassembler);
6194
6195 CmdArgs.push_back("-o");
6196 CmdArgs.push_back(Output.getFilename());
6197
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006198 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006199 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006200
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006201 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Eli Friedman9fa28852012-08-08 23:57:20 +00006202 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6203}
6204
6205void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6206 const InputInfo &Output,
6207 const InputInfoList &Inputs,
6208 const ArgList &Args,
6209 const char *LinkingOutput) const {
6210 const Driver &D = getToolChain().getDriver();
6211 ArgStringList CmdArgs;
6212
6213 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6214 (!Args.hasArg(options::OPT_shared))) {
6215 CmdArgs.push_back("-e");
6216 CmdArgs.push_back("__start");
6217 }
6218
6219 if (Args.hasArg(options::OPT_static)) {
6220 CmdArgs.push_back("-Bstatic");
6221 } else {
6222 if (Args.hasArg(options::OPT_rdynamic))
6223 CmdArgs.push_back("-export-dynamic");
6224 CmdArgs.push_back("--eh-frame-hdr");
6225 CmdArgs.push_back("-Bdynamic");
6226 if (Args.hasArg(options::OPT_shared)) {
6227 CmdArgs.push_back("-shared");
6228 } else {
6229 CmdArgs.push_back("-dynamic-linker");
6230 CmdArgs.push_back("/usr/libexec/ld.so");
6231 }
6232 }
6233
6234 if (Output.isFilename()) {
6235 CmdArgs.push_back("-o");
6236 CmdArgs.push_back(Output.getFilename());
6237 } else {
6238 assert(Output.isNothing() && "Invalid output.");
6239 }
6240
6241 if (!Args.hasArg(options::OPT_nostdlib) &&
6242 !Args.hasArg(options::OPT_nostartfiles)) {
6243 if (!Args.hasArg(options::OPT_shared)) {
6244 if (Args.hasArg(options::OPT_pg))
6245 CmdArgs.push_back(Args.MakeArgString(
6246 getToolChain().GetFilePath("gcrt0.o")));
6247 else
6248 CmdArgs.push_back(Args.MakeArgString(
6249 getToolChain().GetFilePath("crt0.o")));
6250 CmdArgs.push_back(Args.MakeArgString(
6251 getToolChain().GetFilePath("crtbegin.o")));
6252 } else {
6253 CmdArgs.push_back(Args.MakeArgString(
6254 getToolChain().GetFilePath("crtbeginS.o")));
6255 }
6256 }
6257
6258 Args.AddAllArgs(CmdArgs, options::OPT_L);
6259 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6260 Args.AddAllArgs(CmdArgs, options::OPT_e);
6261
6262 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6263
6264 if (!Args.hasArg(options::OPT_nostdlib) &&
6265 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006266 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006267 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6268 if (Args.hasArg(options::OPT_pg))
6269 CmdArgs.push_back("-lm_p");
6270 else
6271 CmdArgs.push_back("-lm");
6272 }
6273
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006274 if (Args.hasArg(options::OPT_pthread)) {
6275 if (!Args.hasArg(options::OPT_shared) &&
6276 Args.hasArg(options::OPT_pg))
6277 CmdArgs.push_back("-lpthread_p");
6278 else
6279 CmdArgs.push_back("-lpthread");
6280 }
6281
Eli Friedman9fa28852012-08-08 23:57:20 +00006282 if (!Args.hasArg(options::OPT_shared)) {
6283 if (Args.hasArg(options::OPT_pg))
6284 CmdArgs.push_back("-lc_p");
6285 else
6286 CmdArgs.push_back("-lc");
6287 }
6288
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006289 StringRef MyArch;
6290 switch (getToolChain().getTriple().getArch()) {
6291 case llvm::Triple::arm:
6292 MyArch = "arm";
6293 break;
6294 case llvm::Triple::x86:
6295 MyArch = "i386";
6296 break;
6297 case llvm::Triple::x86_64:
6298 MyArch = "amd64";
6299 break;
6300 default:
6301 llvm_unreachable("Unsupported architecture");
6302 }
6303 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006304 }
6305
6306 if (!Args.hasArg(options::OPT_nostdlib) &&
6307 !Args.hasArg(options::OPT_nostartfiles)) {
6308 if (!Args.hasArg(options::OPT_shared))
6309 CmdArgs.push_back(Args.MakeArgString(
6310 getToolChain().GetFilePath("crtend.o")));
6311 else
6312 CmdArgs.push_back(Args.MakeArgString(
6313 getToolChain().GetFilePath("crtendS.o")));
6314 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006315
6316 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006317 Args.MakeArgString(getToolChain().GetLinkerPath());
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006318 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006319}
6320
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006321void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006322 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006323 const InputInfoList &Inputs,
6324 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006325 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006326 ArgStringList CmdArgs;
6327
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006328 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6329 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006330 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006331 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006332 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006333 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006334 else if (getToolChain().getArch() == llvm::Triple::mips ||
6335 getToolChain().getArch() == llvm::Triple::mipsel ||
6336 getToolChain().getArch() == llvm::Triple::mips64 ||
6337 getToolChain().getArch() == llvm::Triple::mips64el) {
6338 StringRef CPUName;
6339 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006340 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006341
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006342 CmdArgs.push_back("-march");
6343 CmdArgs.push_back(CPUName.data());
6344
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006345 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006346 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006347
6348 if (getToolChain().getArch() == llvm::Triple::mips ||
6349 getToolChain().getArch() == llvm::Triple::mips64)
6350 CmdArgs.push_back("-EB");
6351 else
6352 CmdArgs.push_back("-EL");
6353
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006354 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006355 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006356 getToolChain().getArch() == llvm::Triple::armeb ||
6357 getToolChain().getArch() == llvm::Triple::thumb ||
6358 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006359 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006360 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006361 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6362
6363 if (FloatABI == "hard") {
6364 CmdArgs.push_back("-mfpu=vfp");
6365 } else {
6366 CmdArgs.push_back("-mfpu=softvfp");
6367 }
6368
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006369 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006370 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006371 case llvm::Triple::GNUEABI:
6372 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006373 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006374 break;
6375
6376 default:
6377 CmdArgs.push_back("-matpcs");
6378 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006379 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006380 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006381 if (getToolChain().getArch() == llvm::Triple::sparc)
6382 CmdArgs.push_back("-Av8plusa");
6383 else
6384 CmdArgs.push_back("-Av9a");
6385
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006386 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006387 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006388
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006389 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6390 options::OPT_Xassembler);
6391
6392 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006393 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006394
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006395 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006396 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006397
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006398 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006399 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006400}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006401
6402void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006403 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006404 const InputInfoList &Inputs,
6405 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006406 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006407 const toolchains::FreeBSD& ToolChain =
6408 static_cast<const toolchains::FreeBSD&>(getToolChain());
6409 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006410 const bool IsPIE =
6411 !Args.hasArg(options::OPT_shared) &&
6412 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006413 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006414
6415 // Silence warning for "clang -g foo.o -o foo"
6416 Args.ClaimAllArgs(options::OPT_g_Group);
6417 // and "clang -emit-llvm foo.o -o foo"
6418 Args.ClaimAllArgs(options::OPT_emit_llvm);
6419 // and for "clang -w foo.o -o foo". Other warning options are already
6420 // handled somewhere else.
6421 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006422
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006423 if (!D.SysRoot.empty())
6424 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6425
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006426 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006427 CmdArgs.push_back("-pie");
6428
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006429 if (Args.hasArg(options::OPT_static)) {
6430 CmdArgs.push_back("-Bstatic");
6431 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006432 if (Args.hasArg(options::OPT_rdynamic))
6433 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006434 CmdArgs.push_back("--eh-frame-hdr");
6435 if (Args.hasArg(options::OPT_shared)) {
6436 CmdArgs.push_back("-Bshareable");
6437 } else {
6438 CmdArgs.push_back("-dynamic-linker");
6439 CmdArgs.push_back("/libexec/ld-elf.so.1");
6440 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006441 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6442 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006443 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6444 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6445 CmdArgs.push_back("--hash-style=both");
6446 }
6447 }
6448 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006449 }
6450
6451 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6452 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006453 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006454 CmdArgs.push_back("-m");
6455 CmdArgs.push_back("elf_i386_fbsd");
6456 }
6457
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006458 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006459 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006460 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006461 }
6462
Daniel Dunbarb440f562010-08-02 02:38:21 +00006463 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006464 CmdArgs.push_back("-o");
6465 CmdArgs.push_back(Output.getFilename());
6466 } else {
6467 assert(Output.isNothing() && "Invalid output.");
6468 }
6469
6470 if (!Args.hasArg(options::OPT_nostdlib) &&
6471 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006472 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006473 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006474 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006475 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006476 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006477 crt1 = "Scrt1.o";
6478 else
6479 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006480 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006481 if (crt1)
6482 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6483
6484 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6485
Craig Topper92fc2df2014-05-17 16:56:41 +00006486 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006487 if (Args.hasArg(options::OPT_static))
6488 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006489 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006490 crtbegin = "crtbeginS.o";
6491 else
6492 crtbegin = "crtbegin.o";
6493
6494 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006495 }
6496
6497 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006498 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006499 for (const auto &Path : Paths)
6500 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006501 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6502 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006503 Args.AddAllArgs(CmdArgs, options::OPT_s);
6504 Args.AddAllArgs(CmdArgs, options::OPT_t);
6505 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6506 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006507
Alp Tokerce365ca2013-12-02 12:43:03 +00006508 if (D.IsUsingLTO(Args))
6509 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006510
Roman Divackyafe2f232012-08-28 15:09:03 +00006511 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006512
6513 if (!Args.hasArg(options::OPT_nostdlib) &&
6514 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006515 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006516 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006517 if (Args.hasArg(options::OPT_pg))
6518 CmdArgs.push_back("-lm_p");
6519 else
6520 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006521 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006522 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6523 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006524 if (Args.hasArg(options::OPT_pg))
6525 CmdArgs.push_back("-lgcc_p");
6526 else
6527 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006528 if (Args.hasArg(options::OPT_static)) {
6529 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006530 } else if (Args.hasArg(options::OPT_pg)) {
6531 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006532 } else {
6533 CmdArgs.push_back("--as-needed");
6534 CmdArgs.push_back("-lgcc_s");
6535 CmdArgs.push_back("--no-as-needed");
6536 }
6537
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006538 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006539 if (Args.hasArg(options::OPT_pg))
6540 CmdArgs.push_back("-lpthread_p");
6541 else
6542 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006543 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006544
Roman Divacky66f22762011-02-10 16:59:40 +00006545 if (Args.hasArg(options::OPT_pg)) {
6546 if (Args.hasArg(options::OPT_shared))
6547 CmdArgs.push_back("-lc");
6548 else
6549 CmdArgs.push_back("-lc_p");
6550 CmdArgs.push_back("-lgcc_p");
6551 } else {
6552 CmdArgs.push_back("-lc");
6553 CmdArgs.push_back("-lgcc");
6554 }
6555
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006556 if (Args.hasArg(options::OPT_static)) {
6557 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006558 } else if (Args.hasArg(options::OPT_pg)) {
6559 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006560 } else {
6561 CmdArgs.push_back("--as-needed");
6562 CmdArgs.push_back("-lgcc_s");
6563 CmdArgs.push_back("--no-as-needed");
6564 }
6565 }
6566
6567 if (!Args.hasArg(options::OPT_nostdlib) &&
6568 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006569 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006570 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006571 else
6572 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006573 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006574 }
6575
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006576 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6577
Alexey Samsonov7811d192014-02-20 13:57:37 +00006578 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006579
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006580 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006581 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006582 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006583}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006584
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006585void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6586 const InputInfo &Output,
6587 const InputInfoList &Inputs,
6588 const ArgList &Args,
6589 const char *LinkingOutput) const {
6590 ArgStringList CmdArgs;
6591
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006592 // GNU as needs different flags for creating the correct output format
6593 // on architectures with different ABIs or optional feature sets.
6594 switch (getToolChain().getArch()) {
6595 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006596 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006597 break;
6598 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006599 case llvm::Triple::armeb:
6600 case llvm::Triple::thumb:
6601 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006602 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006603 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006604 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006605 }
6606
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006607 case llvm::Triple::mips:
6608 case llvm::Triple::mipsel:
6609 case llvm::Triple::mips64:
6610 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006611 StringRef CPUName;
6612 StringRef ABIName;
6613 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6614
6615 CmdArgs.push_back("-march");
6616 CmdArgs.push_back(CPUName.data());
6617
6618 CmdArgs.push_back("-mabi");
6619 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6620
6621 if (getToolChain().getArch() == llvm::Triple::mips ||
6622 getToolChain().getArch() == llvm::Triple::mips64)
6623 CmdArgs.push_back("-EB");
6624 else
6625 CmdArgs.push_back("-EL");
6626
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006627 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006628 break;
6629 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006630
6631 case llvm::Triple::sparc:
6632 CmdArgs.push_back("-32");
6633 addAssemblerKPIC(Args, CmdArgs);
6634 break;
6635
6636 case llvm::Triple::sparcv9:
6637 CmdArgs.push_back("-64");
6638 CmdArgs.push_back("-Av9");
6639 addAssemblerKPIC(Args, CmdArgs);
6640 break;
6641
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006642 default:
6643 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006644 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006645
6646 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6647 options::OPT_Xassembler);
6648
6649 CmdArgs.push_back("-o");
6650 CmdArgs.push_back(Output.getFilename());
6651
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006652 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006653 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006654
David Chisnallddbd68f2011-09-27 22:03:18 +00006655 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006656 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6657}
6658
6659void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6660 const InputInfo &Output,
6661 const InputInfoList &Inputs,
6662 const ArgList &Args,
6663 const char *LinkingOutput) const {
6664 const Driver &D = getToolChain().getDriver();
6665 ArgStringList CmdArgs;
6666
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006667 if (!D.SysRoot.empty())
6668 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6669
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006670 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006671 if (Args.hasArg(options::OPT_static)) {
6672 CmdArgs.push_back("-Bstatic");
6673 } else {
6674 if (Args.hasArg(options::OPT_rdynamic))
6675 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006676 if (Args.hasArg(options::OPT_shared)) {
6677 CmdArgs.push_back("-Bshareable");
6678 } else {
6679 CmdArgs.push_back("-dynamic-linker");
6680 CmdArgs.push_back("/libexec/ld.elf_so");
6681 }
6682 }
6683
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006684 // Many NetBSD architectures support more than one ABI.
6685 // Determine the correct emulation for ld.
6686 switch (getToolChain().getArch()) {
6687 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006688 CmdArgs.push_back("-m");
6689 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006690 break;
6691 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006692 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006693 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006694 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006695 CmdArgs.push_back("-m");
6696 switch (getToolChain().getTriple().getEnvironment()) {
6697 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006698 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006699 CmdArgs.push_back("armelf_nbsd_eabi");
6700 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006701 case llvm::Triple::EABIHF:
6702 case llvm::Triple::GNUEABIHF:
6703 CmdArgs.push_back("armelf_nbsd_eabihf");
6704 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006705 default:
6706 CmdArgs.push_back("armelf_nbsd");
6707 break;
6708 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006709 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006710 case llvm::Triple::mips64:
6711 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006712 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006713 CmdArgs.push_back("-m");
6714 if (getToolChain().getArch() == llvm::Triple::mips64)
6715 CmdArgs.push_back("elf32btsmip");
6716 else
6717 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006718 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006719 CmdArgs.push_back("-m");
6720 if (getToolChain().getArch() == llvm::Triple::mips64)
6721 CmdArgs.push_back("elf64btsmip");
6722 else
6723 CmdArgs.push_back("elf64ltsmip");
6724 }
6725 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006726
6727 case llvm::Triple::sparc:
6728 CmdArgs.push_back("-m");
6729 CmdArgs.push_back("elf32_sparc");
6730 break;
6731
6732 case llvm::Triple::sparcv9:
6733 CmdArgs.push_back("-m");
6734 CmdArgs.push_back("elf64_sparc");
6735 break;
6736
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006737 default:
6738 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006739 }
6740
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006741 if (Output.isFilename()) {
6742 CmdArgs.push_back("-o");
6743 CmdArgs.push_back(Output.getFilename());
6744 } else {
6745 assert(Output.isNothing() && "Invalid output.");
6746 }
6747
6748 if (!Args.hasArg(options::OPT_nostdlib) &&
6749 !Args.hasArg(options::OPT_nostartfiles)) {
6750 if (!Args.hasArg(options::OPT_shared)) {
6751 CmdArgs.push_back(Args.MakeArgString(
6752 getToolChain().GetFilePath("crt0.o")));
6753 CmdArgs.push_back(Args.MakeArgString(
6754 getToolChain().GetFilePath("crti.o")));
6755 CmdArgs.push_back(Args.MakeArgString(
6756 getToolChain().GetFilePath("crtbegin.o")));
6757 } else {
6758 CmdArgs.push_back(Args.MakeArgString(
6759 getToolChain().GetFilePath("crti.o")));
6760 CmdArgs.push_back(Args.MakeArgString(
6761 getToolChain().GetFilePath("crtbeginS.o")));
6762 }
6763 }
6764
6765 Args.AddAllArgs(CmdArgs, options::OPT_L);
6766 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6767 Args.AddAllArgs(CmdArgs, options::OPT_e);
6768 Args.AddAllArgs(CmdArgs, options::OPT_s);
6769 Args.AddAllArgs(CmdArgs, options::OPT_t);
6770 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6771 Args.AddAllArgs(CmdArgs, options::OPT_r);
6772
6773 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6774
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006775 unsigned Major, Minor, Micro;
6776 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6777 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006778 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006779 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006780 case llvm::Triple::arm:
6781 case llvm::Triple::armeb:
6782 case llvm::Triple::thumb:
6783 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006784 case llvm::Triple::x86:
6785 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006786 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006787 break;
6788 default:
6789 break;
6790 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006791 }
6792
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006793 if (!Args.hasArg(options::OPT_nostdlib) &&
6794 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006795 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006796 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6797 CmdArgs.push_back("-lm");
6798 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006799 if (Args.hasArg(options::OPT_pthread))
6800 CmdArgs.push_back("-lpthread");
6801 CmdArgs.push_back("-lc");
6802
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006803 if (useLibgcc) {
6804 if (Args.hasArg(options::OPT_static)) {
6805 // libgcc_eh depends on libc, so resolve as much as possible,
6806 // pull in any new requirements from libc and then get the rest
6807 // of libgcc.
6808 CmdArgs.push_back("-lgcc_eh");
6809 CmdArgs.push_back("-lc");
6810 CmdArgs.push_back("-lgcc");
6811 } else {
6812 CmdArgs.push_back("-lgcc");
6813 CmdArgs.push_back("--as-needed");
6814 CmdArgs.push_back("-lgcc_s");
6815 CmdArgs.push_back("--no-as-needed");
6816 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006817 }
6818 }
6819
6820 if (!Args.hasArg(options::OPT_nostdlib) &&
6821 !Args.hasArg(options::OPT_nostartfiles)) {
6822 if (!Args.hasArg(options::OPT_shared))
6823 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6824 "crtend.o")));
6825 else
6826 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6827 "crtendS.o")));
6828 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6829 "crtn.o")));
6830 }
6831
Alexey Samsonov7811d192014-02-20 13:57:37 +00006832 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006833
Logan Chieneb9162f2014-06-26 14:23:45 +00006834 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006835 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6836}
6837
Thomas Schwinge4e555262013-03-28 19:04:25 +00006838void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6839 const InputInfo &Output,
6840 const InputInfoList &Inputs,
6841 const ArgList &Args,
6842 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006843 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006844 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006845
6846 // Add --32/--64 to make sure we get the format we want.
6847 // This is incomplete
6848 if (getToolChain().getArch() == llvm::Triple::x86) {
6849 CmdArgs.push_back("--32");
6850 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6851 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006852 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6853 CmdArgs.push_back("-a32");
6854 CmdArgs.push_back("-mppc");
6855 CmdArgs.push_back("-many");
6856 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6857 CmdArgs.push_back("-a64");
6858 CmdArgs.push_back("-mppc64");
6859 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006860 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6861 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006862 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006863 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006864 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006865 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6866 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006867 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006868 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006869 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6870 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006871 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006872 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006873 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6874 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006875 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006876 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6877 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006878 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6879 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006880 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006881
Tim Northover9c7e0352013-12-12 11:55:52 +00006882 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6883 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006884 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006885
6886 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006887
6888 // FIXME: remove krait check when GNU tools support krait cpu
6889 // for now replace it with -march=armv7-a to avoid a lower
6890 // march from being picked in the absence of a cpu flag.
6891 Arg *A;
6892 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6893 StringRef(A->getValue()) == "krait")
6894 CmdArgs.push_back("-march=armv7-a");
6895 else
6896 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006897 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006898 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6899 getToolChain().getArch() == llvm::Triple::mipsel ||
6900 getToolChain().getArch() == llvm::Triple::mips64 ||
6901 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006902 StringRef CPUName;
6903 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006904 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006905
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006906 CmdArgs.push_back("-march");
6907 CmdArgs.push_back(CPUName.data());
6908
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006909 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006910 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006911
6912 if (getToolChain().getArch() == llvm::Triple::mips ||
6913 getToolChain().getArch() == llvm::Triple::mips64)
6914 CmdArgs.push_back("-EB");
6915 else
6916 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006917
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006918 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6919 if (StringRef(A->getValue()) == "2008")
6920 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6921 }
6922
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006923 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006924 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6925 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6926 options::OPT_mno_micromips);
6927 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6928 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6929
Simon Atanasyanbd986632013-11-26 11:58:04 +00006930 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6931 // Do not use AddLastArg because not all versions of MIPS assembler
6932 // support -mmsa / -mno-msa options.
6933 if (A->getOption().matches(options::OPT_mmsa))
6934 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6935 }
6936
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006937 NeedsKPIC = true;
6938 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6939 // Always pass an -march option, since our default of z10 is later
6940 // than the GNU assembler's default.
6941 StringRef CPUName = getSystemZTargetCPU(Args);
6942 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6943 }
6944
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006945 if (NeedsKPIC)
6946 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006947
6948 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6949 options::OPT_Xassembler);
6950
6951 CmdArgs.push_back("-o");
6952 CmdArgs.push_back(Output.getFilename());
6953
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006954 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00006955 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00006956
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006957 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Rafael Espindola92b00932010-08-10 00:25:48 +00006958 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006959
6960 // Handle the debug info splitting at object creation time if we're
6961 // creating an object.
6962 // TODO: Currently only works on linux with newer objcopy.
6963 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006964 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006965 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6966 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006967}
6968
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006969static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006970 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006971 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006972 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6973 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006974 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006975 CmdArgs.push_back("-lgcc");
6976
Logan Chien3d3373c2012-11-19 12:04:11 +00006977 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006978 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006979 CmdArgs.push_back("-lgcc");
6980 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006981 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006982 CmdArgs.push_back("--as-needed");
6983 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006984 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006985 CmdArgs.push_back("--no-as-needed");
6986 }
6987
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006988 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006989 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006990 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006991 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006992
6993 // According to Android ABI, we have to link with libdl if we are
6994 // linking with non-static libgcc.
6995 //
6996 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6997 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6998 if (isAndroid && !StaticLibgcc)
6999 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007000}
7001
Simon Atanasyan14ce18d2014-06-25 05:00:59 +00007002static StringRef getLinuxDynamicLinker(const ArgList &Args,
7003 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007004 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7005 if (ToolChain.getTriple().isArch64Bit())
7006 return "/system/bin/linker64";
7007 else
7008 return "/system/bin/linker";
7009 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7010 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007011 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00007012 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7013 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007014 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00007015 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7016 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007017 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007018 else if (ToolChain.getArch() == llvm::Triple::arm ||
7019 ToolChain.getArch() == llvm::Triple::thumb) {
7020 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7021 return "/lib/ld-linux-armhf.so.3";
7022 else
7023 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007024 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7025 ToolChain.getArch() == llvm::Triple::thumbeb) {
7026 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7027 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7028 else
7029 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007030 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007031 ToolChain.getArch() == llvm::Triple::mipsel) {
Daniel Sanders2bf13662014-07-10 14:40:57 +00007032 if (mips::isNaN2008(Args, ToolChain.getTriple()))
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007033 return "/lib/ld-linux-mipsn8.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007034 return "/lib/ld.so.1";
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007035 } else if (ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007036 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007037 if (mips::hasMipsAbiArg(Args, "n32"))
Daniel Sanders2bf13662014-07-10 14:40:57 +00007038 return mips::isNaN2008(Args, ToolChain.getTriple())
7039 ? "/lib32/ld-linux-mipsn8.so.1" : "/lib32/ld.so.1";
7040 return mips::isNaN2008(Args, ToolChain.getTriple())
7041 ? "/lib64/ld-linux-mipsn8.so.1" : "/lib64/ld.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007042 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7043 return "/lib/ld.so.1";
7044 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
7045 ToolChain.getArch() == llvm::Triple::systemz)
7046 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007047 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7048 return "/lib64/ld64.so.2";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007049 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7050 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007051 else
7052 return "/lib64/ld-linux-x86-64.so.2";
7053}
7054
Renato Golinc4b49242014-02-13 10:01:16 +00007055static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7056 ArgStringList &CmdArgs, const ArgList &Args) {
7057 // Make use of compiler-rt if --rtlib option is used
7058 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7059
7060 switch(RLT) {
7061 case ToolChain::RLT_CompilerRT:
7062 addClangRTLinux(TC, Args, CmdArgs);
7063 break;
7064 case ToolChain::RLT_Libgcc:
7065 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7066 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007067 }
7068}
7069
Thomas Schwinge4e555262013-03-28 19:04:25 +00007070void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7071 const InputInfo &Output,
7072 const InputInfoList &Inputs,
7073 const ArgList &Args,
7074 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007075 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007076 static_cast<const toolchains::Linux&>(getToolChain());
7077 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007078 const bool isAndroid =
7079 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007080 const bool IsPIE =
7081 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007082 !Args.hasArg(options::OPT_static) &&
7083 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7084 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007085 // Cannot use isPIEDefault here since otherwise
7086 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007087 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007088
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007089 ArgStringList CmdArgs;
7090
Rafael Espindolad1002f62010-11-15 18:28:16 +00007091 // Silence warning for "clang -g foo.o -o foo"
7092 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007093 // and "clang -emit-llvm foo.o -o foo"
7094 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007095 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007096 // handled somewhere else.
7097 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007098
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007099 if (!D.SysRoot.empty())
7100 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007101
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007102 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007103 CmdArgs.push_back("-pie");
7104
Rafael Espindola1c76c592010-11-07 22:57:16 +00007105 if (Args.hasArg(options::OPT_rdynamic))
7106 CmdArgs.push_back("-export-dynamic");
7107
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007108 if (Args.hasArg(options::OPT_s))
7109 CmdArgs.push_back("-s");
7110
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007111 for (const auto &Opt : ToolChain.ExtraOpts)
7112 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007113
7114 if (!Args.hasArg(options::OPT_static)) {
7115 CmdArgs.push_back("--eh-frame-hdr");
7116 }
7117
7118 CmdArgs.push_back("-m");
7119 if (ToolChain.getArch() == llvm::Triple::x86)
7120 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007121 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7122 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007123 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007124 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7125 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007126 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007127 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007128 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007129 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007130 else if (ToolChain.getArch() == llvm::Triple::armeb
7131 || ToolChain.getArch() == llvm::Triple::thumbeb)
7132 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007133 else if (ToolChain.getArch() == llvm::Triple::ppc)
7134 CmdArgs.push_back("elf32ppclinux");
7135 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7136 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007137 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7138 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007139 else if (ToolChain.getArch() == llvm::Triple::sparc)
7140 CmdArgs.push_back("elf32_sparc");
7141 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7142 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007143 else if (ToolChain.getArch() == llvm::Triple::mips)
7144 CmdArgs.push_back("elf32btsmip");
7145 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7146 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007147 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007148 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007149 CmdArgs.push_back("elf32btsmipn32");
7150 else
7151 CmdArgs.push_back("elf64btsmip");
7152 }
7153 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007154 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007155 CmdArgs.push_back("elf32ltsmipn32");
7156 else
7157 CmdArgs.push_back("elf64ltsmip");
7158 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007159 else if (ToolChain.getArch() == llvm::Triple::systemz)
7160 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007161 else
7162 CmdArgs.push_back("elf_x86_64");
7163
7164 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007165 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007166 ToolChain.getArch() == llvm::Triple::armeb ||
7167 ToolChain.getArch() == llvm::Triple::thumb ||
7168 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007169 CmdArgs.push_back("-Bstatic");
7170 else
7171 CmdArgs.push_back("-static");
7172 } else if (Args.hasArg(options::OPT_shared)) {
7173 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00007174 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007175 CmdArgs.push_back("-Bsymbolic");
7176 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007177 }
7178
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007179 if (ToolChain.getArch() == llvm::Triple::arm ||
7180 ToolChain.getArch() == llvm::Triple::armeb ||
7181 ToolChain.getArch() == llvm::Triple::thumb ||
7182 ToolChain.getArch() == llvm::Triple::thumbeb ||
7183 (!Args.hasArg(options::OPT_static) &&
7184 !Args.hasArg(options::OPT_shared))) {
7185 CmdArgs.push_back("-dynamic-linker");
7186 CmdArgs.push_back(Args.MakeArgString(
7187 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7188 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007189
7190 CmdArgs.push_back("-o");
7191 CmdArgs.push_back(Output.getFilename());
7192
Rafael Espindola81937ec2010-12-01 01:52:43 +00007193 if (!Args.hasArg(options::OPT_nostdlib) &&
7194 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007195 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007196 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007197 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007198 if (Args.hasArg(options::OPT_pg))
7199 crt1 = "gcrt1.o";
7200 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007201 crt1 = "Scrt1.o";
7202 else
7203 crt1 = "crt1.o";
7204 }
7205 if (crt1)
7206 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007207
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007208 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7209 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007210
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007211 const char *crtbegin;
7212 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007213 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007214 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007215 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007216 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007217 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007218 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007219 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007220 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007221
7222 // Add crtfastmath.o if available and fast math is enabled.
7223 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007224 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007225
7226 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007227 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007228
7229 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7230
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007231 for (const auto &Path : Paths)
7232 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007233
Alp Tokerce365ca2013-12-02 12:43:03 +00007234 if (D.IsUsingLTO(Args))
7235 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007236
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007237 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7238 CmdArgs.push_back("--no-demangle");
7239
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007240 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7241
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007242 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007243 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007244 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007245
Hans Wennborg70850d82013-07-18 20:29:38 +00007246 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007247 !Args.hasArg(options::OPT_nostdlib) &&
7248 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007249 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7250 !Args.hasArg(options::OPT_static);
7251 if (OnlyLibstdcxxStatic)
7252 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007253 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007254 if (OnlyLibstdcxxStatic)
7255 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007256 CmdArgs.push_back("-lm");
7257 }
7258
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007259 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007260 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7261 if (Args.hasArg(options::OPT_static))
7262 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007263
Alexey Bataev186b28a2014-03-06 05:43:53 +00007264 LibOpenMP UsedOpenMPLib = LibUnknown;
7265 if (Args.hasArg(options::OPT_fopenmp)) {
7266 UsedOpenMPLib = LibGOMP;
7267 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7268 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7269 .Case("libgomp", LibGOMP)
7270 .Case("libiomp5", LibIOMP5)
7271 .Default(LibUnknown);
7272 if (UsedOpenMPLib == LibUnknown)
7273 D.Diag(diag::err_drv_unsupported_option_argument)
7274 << A->getOption().getName() << A->getValue();
7275 }
7276 switch (UsedOpenMPLib) {
7277 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007278 CmdArgs.push_back("-lgomp");
7279
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007280 // FIXME: Exclude this for platforms with libgomp that don't require
7281 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007282 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007283 break;
7284 case LibIOMP5:
7285 CmdArgs.push_back("-liomp5");
7286 break;
7287 case LibUnknown:
7288 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007289 }
Renato Golinc4b49242014-02-13 10:01:16 +00007290 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007291
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007292 if ((Args.hasArg(options::OPT_pthread) ||
7293 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7294 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007295 CmdArgs.push_back("-lpthread");
7296
7297 CmdArgs.push_back("-lc");
7298
7299 if (Args.hasArg(options::OPT_static))
7300 CmdArgs.push_back("--end-group");
7301 else
Renato Golinc4b49242014-02-13 10:01:16 +00007302 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007303 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007304
Rafael Espindola81937ec2010-12-01 01:52:43 +00007305 if (!Args.hasArg(options::OPT_nostartfiles)) {
7306 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007307 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007308 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007309 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007310 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007311 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007312 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007313
Rafael Espindola81937ec2010-12-01 01:52:43 +00007314 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007315 if (!isAndroid)
7316 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007317 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007318 }
7319
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007320 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007321}
7322
Chris Lattner3e2ee142010-07-07 16:01:42 +00007323void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007324 const InputInfo &Output,
7325 const InputInfoList &Inputs,
7326 const ArgList &Args,
7327 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007328 ArgStringList CmdArgs;
7329
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007330 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007331
7332 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007333 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007334
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007335 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007336 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007337
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007338 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007339 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007340}
7341
7342void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007343 const InputInfo &Output,
7344 const InputInfoList &Inputs,
7345 const ArgList &Args,
7346 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007347 const Driver &D = getToolChain().getDriver();
7348 ArgStringList CmdArgs;
7349
Daniel Dunbarb440f562010-08-02 02:38:21 +00007350 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007351 CmdArgs.push_back("-o");
7352 CmdArgs.push_back(Output.getFilename());
7353 } else {
7354 assert(Output.isNothing() && "Invalid output.");
7355 }
7356
7357 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007358 !Args.hasArg(options::OPT_nostartfiles)) {
7359 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7360 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7361 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7362 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7363 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007364
7365 Args.AddAllArgs(CmdArgs, options::OPT_L);
7366 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7367 Args.AddAllArgs(CmdArgs, options::OPT_e);
7368
Daniel Dunbar54423b22010-09-17 00:24:54 +00007369 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007370
Alexey Samsonov7811d192014-02-20 13:57:37 +00007371 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007372
Chris Lattner3e2ee142010-07-07 16:01:42 +00007373 if (!Args.hasArg(options::OPT_nostdlib) &&
7374 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007375 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007376 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007377 CmdArgs.push_back("-lm");
7378 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007379 }
7380
7381 if (!Args.hasArg(options::OPT_nostdlib) &&
7382 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007383 if (Args.hasArg(options::OPT_pthread))
7384 CmdArgs.push_back("-lpthread");
7385 CmdArgs.push_back("-lc");
7386 CmdArgs.push_back("-lCompilerRT-Generic");
7387 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7388 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007389 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007390 }
7391
Logan Chieneb9162f2014-06-26 14:23:45 +00007392 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007393 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007394}
7395
Daniel Dunbarcc912342009-05-02 18:28:39 +00007396/// DragonFly Tools
7397
7398// For now, DragonFly Assemble does just about the same as for
7399// FreeBSD, but this may change soon.
7400void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007401 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007402 const InputInfoList &Inputs,
7403 const ArgList &Args,
7404 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007405 ArgStringList CmdArgs;
7406
7407 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7408 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007409 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007410 CmdArgs.push_back("--32");
7411
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007412 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007413
7414 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007415 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007416
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007417 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007418 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007419
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007420 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007421 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007422}
7423
7424void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007425 const InputInfo &Output,
7426 const InputInfoList &Inputs,
7427 const ArgList &Args,
7428 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007429 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007430 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007431 ArgStringList CmdArgs;
7432
John McCall65b8da02013-04-11 22:55:55 +00007433 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7434 UseGCC47 = false;
7435
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007436 if (!D.SysRoot.empty())
7437 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7438
John McCall65b8da02013-04-11 22:55:55 +00007439 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007440 if (Args.hasArg(options::OPT_static)) {
7441 CmdArgs.push_back("-Bstatic");
7442 } else {
John McCall65b8da02013-04-11 22:55:55 +00007443 if (Args.hasArg(options::OPT_rdynamic))
7444 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007445 if (Args.hasArg(options::OPT_shared))
7446 CmdArgs.push_back("-Bshareable");
7447 else {
7448 CmdArgs.push_back("-dynamic-linker");
7449 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7450 }
John McCall65b8da02013-04-11 22:55:55 +00007451 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007452 }
7453
7454 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7455 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007456 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007457 CmdArgs.push_back("-m");
7458 CmdArgs.push_back("elf_i386");
7459 }
7460
Daniel Dunbarb440f562010-08-02 02:38:21 +00007461 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007462 CmdArgs.push_back("-o");
7463 CmdArgs.push_back(Output.getFilename());
7464 } else {
7465 assert(Output.isNothing() && "Invalid output.");
7466 }
7467
7468 if (!Args.hasArg(options::OPT_nostdlib) &&
7469 !Args.hasArg(options::OPT_nostartfiles)) {
7470 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007471 if (Args.hasArg(options::OPT_pg))
7472 CmdArgs.push_back(Args.MakeArgString(
7473 getToolChain().GetFilePath("gcrt1.o")));
7474 else {
7475 if (Args.hasArg(options::OPT_pie))
7476 CmdArgs.push_back(Args.MakeArgString(
7477 getToolChain().GetFilePath("Scrt1.o")));
7478 else
7479 CmdArgs.push_back(Args.MakeArgString(
7480 getToolChain().GetFilePath("crt1.o")));
7481 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007482 }
John McCall65b8da02013-04-11 22:55:55 +00007483 CmdArgs.push_back(Args.MakeArgString(
7484 getToolChain().GetFilePath("crti.o")));
7485 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7486 CmdArgs.push_back(Args.MakeArgString(
7487 getToolChain().GetFilePath("crtbeginS.o")));
7488 else
7489 CmdArgs.push_back(Args.MakeArgString(
7490 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007491 }
7492
7493 Args.AddAllArgs(CmdArgs, options::OPT_L);
7494 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7495 Args.AddAllArgs(CmdArgs, options::OPT_e);
7496
Daniel Dunbar54423b22010-09-17 00:24:54 +00007497 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007498
7499 if (!Args.hasArg(options::OPT_nostdlib) &&
7500 !Args.hasArg(options::OPT_nodefaultlibs)) {
7501 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7502 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007503 if (UseGCC47)
7504 CmdArgs.push_back("-L/usr/lib/gcc47");
7505 else
7506 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007507
7508 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007509 if (UseGCC47) {
7510 CmdArgs.push_back("-rpath");
7511 CmdArgs.push_back("/usr/lib/gcc47");
7512 } else {
7513 CmdArgs.push_back("-rpath");
7514 CmdArgs.push_back("/usr/lib/gcc44");
7515 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007516 }
7517
Hans Wennborg70850d82013-07-18 20:29:38 +00007518 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007519 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007520 CmdArgs.push_back("-lm");
7521 }
7522
Daniel Dunbarcc912342009-05-02 18:28:39 +00007523 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007524 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007525
7526 if (!Args.hasArg(options::OPT_nolibc)) {
7527 CmdArgs.push_back("-lc");
7528 }
7529
John McCall65b8da02013-04-11 22:55:55 +00007530 if (UseGCC47) {
7531 if (Args.hasArg(options::OPT_static) ||
7532 Args.hasArg(options::OPT_static_libgcc)) {
7533 CmdArgs.push_back("-lgcc");
7534 CmdArgs.push_back("-lgcc_eh");
7535 } else {
7536 if (Args.hasArg(options::OPT_shared_libgcc)) {
7537 CmdArgs.push_back("-lgcc_pic");
7538 if (!Args.hasArg(options::OPT_shared))
7539 CmdArgs.push_back("-lgcc");
7540 } else {
7541 CmdArgs.push_back("-lgcc");
7542 CmdArgs.push_back("--as-needed");
7543 CmdArgs.push_back("-lgcc_pic");
7544 CmdArgs.push_back("--no-as-needed");
7545 }
7546 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007547 } else {
John McCall65b8da02013-04-11 22:55:55 +00007548 if (Args.hasArg(options::OPT_shared)) {
7549 CmdArgs.push_back("-lgcc_pic");
7550 } else {
7551 CmdArgs.push_back("-lgcc");
7552 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007553 }
7554 }
7555
7556 if (!Args.hasArg(options::OPT_nostdlib) &&
7557 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007558 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007559 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007560 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007561 else
7562 CmdArgs.push_back(Args.MakeArgString(
7563 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007564 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007565 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007566 }
7567
Alexey Samsonov7811d192014-02-20 13:57:37 +00007568 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007569
Logan Chieneb9162f2014-06-26 14:23:45 +00007570 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007571 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007572}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007573
Alexey Samsonov6424e022014-05-12 20:20:20 +00007574static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7575 ArgStringList &CmdArgs,
7576 const StringRef RTName) {
7577 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7578 llvm::sys::path::append(LibSanitizer,
7579 Twine("clang_rt.") + RTName + ".lib");
7580 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7581}
7582
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007583void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7584 const InputInfo &Output,
7585 const InputInfoList &Inputs,
7586 const ArgList &Args,
7587 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007588 ArgStringList CmdArgs;
7589
7590 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007591 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7592 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007593 } else {
7594 assert(Output.isNothing() && "Invalid output.");
7595 }
7596
7597 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007598 !Args.hasArg(options::OPT_nostartfiles) &&
7599 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007600 CmdArgs.push_back("-defaultlib:libcmt");
7601 }
7602
7603 CmdArgs.push_back("-nologo");
7604
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007605 if (Args.hasArg(options::OPT_g_Group)) {
7606 CmdArgs.push_back("-debug");
7607 }
7608
Hans Wennborgf1a74252013-09-10 20:18:04 +00007609 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7610
7611 if (DLL) {
7612 CmdArgs.push_back(Args.MakeArgString("-dll"));
7613
7614 SmallString<128> ImplibName(Output.getFilename());
7615 llvm::sys::path::replace_extension(ImplibName, "lib");
7616 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7617 ImplibName.str()));
7618 }
7619
Peter Collingbourne32701642013-11-01 18:16:25 +00007620 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007621 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007622 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007623 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007624 if (DLL) {
7625 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7626 "asan_dll_thunk-i386");
7627 } else {
7628 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7629 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7630 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007631 }
7632
Michael J. Spencere2f49362012-06-18 16:56:04 +00007633 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007634 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007635
7636 // Add filenames immediately.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007637 for (const auto &Input : Inputs)
7638 if (Input.isFilename())
7639 CmdArgs.push_back(Input.getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007640 else
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007641 Input.getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007642
7643 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007644 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007645 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7646}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007647
7648void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7649 const InputInfo &Output,
7650 const InputInfoList &Inputs,
7651 const ArgList &Args,
7652 const char *LinkingOutput) const {
7653 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7654}
7655
Hans Wennborg188382e2013-09-20 18:16:35 +00007656// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7657// If one cannot be found, return FallbackName.
7658// We do this special search to prevent clang-cl from falling back onto itself
7659// if it's available as cl.exe on the path.
7660static std::string FindFallback(const char *FallbackName,
7661 const char *ClangProgramPath) {
7662 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7663 if (!OptPath.hasValue())
7664 return FallbackName;
7665
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007666 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Hans Wennborg188382e2013-09-20 18:16:35 +00007667 SmallVector<StringRef, 8> PathSegments;
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007668 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
Hans Wennborg188382e2013-09-20 18:16:35 +00007669
7670 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7671 const StringRef &PathSegment = PathSegments[i];
7672 if (PathSegment.empty())
7673 continue;
7674
7675 SmallString<128> FilePath(PathSegment);
7676 llvm::sys::path::append(FilePath, FallbackName);
7677 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7678 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7679 return FilePath.str();
7680 }
7681
7682 return FallbackName;
7683}
7684
Hans Wennborg87cfa712013-09-19 20:32:16 +00007685Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7686 const InputInfo &Output,
7687 const InputInfoList &Inputs,
7688 const ArgList &Args,
7689 const char *LinkingOutput) const {
7690 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007691 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007692 CmdArgs.push_back("/c"); // Compile only.
7693 CmdArgs.push_back("/W0"); // No warnings.
7694
7695 // The goal is to be able to invoke this tool correctly based on
7696 // any flag accepted by clang-cl.
7697
7698 // These are spelled the same way in clang and cl.exe,.
7699 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7700 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007701
7702 // Optimization level.
7703 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7704 if (A->getOption().getID() == options::OPT_O0) {
7705 CmdArgs.push_back("/Od");
7706 } else {
7707 StringRef OptLevel = A->getValue();
7708 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7709 A->render(Args, CmdArgs);
7710 else if (OptLevel == "3")
7711 CmdArgs.push_back("/Ox");
7712 }
7713 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007714
7715 // Flags for which clang-cl have an alias.
7716 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7717
David Majnemerf6072342014-07-01 22:24:56 +00007718 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
7719 /*default=*/false))
7720 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007721 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7722 options::OPT_fno_function_sections))
7723 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7724 ? "/Gy"
7725 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007726 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7727 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007728 CmdArgs.push_back(
7729 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007730 if (Args.hasArg(options::OPT_fsyntax_only))
7731 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007732 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7733 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007734
Hans Wennborg260ff402013-09-27 17:54:18 +00007735 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007736 for (const auto &Include : Includes)
7737 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007738
Hans Wennborg87cfa712013-09-19 20:32:16 +00007739 // Flags that can simply be passed through.
7740 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7741 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00007742 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007743
7744 // The order of these flags is relevant, so pick the last one.
7745 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7746 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7747 A->render(Args, CmdArgs);
7748
7749
7750 // Input filename.
7751 assert(Inputs.size() == 1);
7752 const InputInfo &II = Inputs[0];
7753 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7754 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7755 if (II.isFilename())
7756 CmdArgs.push_back(II.getFilename());
7757 else
7758 II.getInputArg().renderAsInput(Args, CmdArgs);
7759
7760 // Output filename.
7761 assert(Output.getType() == types::TY_Object);
7762 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7763 Output.getFilename());
7764 CmdArgs.push_back(Fo);
7765
Hans Wennborg188382e2013-09-20 18:16:35 +00007766 const Driver &D = getToolChain().getDriver();
7767 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg188382e2013-09-20 18:16:35 +00007768 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007769}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007770
7771
7772/// XCore Tools
7773// We pass assemble and link construction to the xcc tool.
7774
7775void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7776 const InputInfo &Output,
7777 const InputInfoList &Inputs,
7778 const ArgList &Args,
7779 const char *LinkingOutput) const {
7780 ArgStringList CmdArgs;
7781
7782 CmdArgs.push_back("-o");
7783 CmdArgs.push_back(Output.getFilename());
7784
7785 CmdArgs.push_back("-c");
7786
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007787 if (Args.hasArg(options::OPT_v))
7788 CmdArgs.push_back("-v");
7789
Robert Lytton894d25c2014-05-02 09:33:25 +00007790 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7791 if (!A->getOption().matches(options::OPT_g0))
7792 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007793
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007794 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7795 false))
7796 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007797
7798 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7799 options::OPT_Xassembler);
7800
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007801 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007802 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007803
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007804 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007805 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7806}
7807
7808void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7809 const InputInfo &Output,
7810 const InputInfoList &Inputs,
7811 const ArgList &Args,
7812 const char *LinkingOutput) const {
7813 ArgStringList CmdArgs;
7814
7815 if (Output.isFilename()) {
7816 CmdArgs.push_back("-o");
7817 CmdArgs.push_back(Output.getFilename());
7818 } else {
7819 assert(Output.isNothing() && "Invalid output.");
7820 }
7821
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007822 if (Args.hasArg(options::OPT_v))
7823 CmdArgs.push_back("-v");
7824
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007825 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7826 if (EH.ShouldUseExceptionTables)
7827 CmdArgs.push_back("-fexceptions");
7828
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007829 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7830
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007831 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007832 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7833}