blob: 99e34e4be0cf8e5eb73caba87c5fe14fbe2db1b1 [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);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000204 else if (A.getOption().matches(options::OPT_z)) {
205 // Pass -z prefix for gcc linker compatibility.
206 A.claim();
207 A.render(Args, CmdArgs);
208 } else {
209 A.renderAsInput(Args, CmdArgs);
210 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000211 }
Bill Wendling281ca292012-03-12 21:22:35 +0000212
213 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000214 // and only supported on native toolchains.
215 if (!TC.isCrossCompiling())
216 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000217}
218
John McCall31168b02011-06-15 23:02:42 +0000219/// \brief Determine whether Objective-C automated reference counting is
220/// enabled.
221static bool isObjCAutoRefCount(const ArgList &Args) {
222 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
223}
224
Ted Kremeneke65b0862012-03-06 20:05:56 +0000225/// \brief Determine whether we are linking the ObjC runtime.
226static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000227 if (isObjCAutoRefCount(Args)) {
228 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000229 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000230 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000231 return Args.hasArg(options::OPT_fobjc_link_runtime);
232}
233
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000234static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000235 // Don't forward inputs from the original command line. They are added from
236 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000237 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000238 !O.hasFlag(options::DriverOption) &&
239 !O.hasFlag(options::LinkerInput);
240}
241
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000242void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000243 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000244 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000245 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000246 ArgStringList &CmdArgs,
247 const InputInfo &Output,
248 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000249 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000250
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000251 CheckPreprocessingOptions(D, Args);
252
253 Args.AddLastArg(CmdArgs, options::OPT_C);
254 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000255
256 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000257 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000258 (A = Args.getLastArg(options::OPT_MD)) ||
259 (A = Args.getLastArg(options::OPT_MMD))) {
260 // Determine the output location.
261 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000262 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000263 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000264 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000265 } else if (Output.getType() == types::TY_Dependencies) {
266 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000267 } else if (A->getOption().matches(options::OPT_M) ||
268 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000269 DepFile = "-";
270 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000271 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000272 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000273 }
274 CmdArgs.push_back("-dependency-file");
275 CmdArgs.push_back(DepFile);
276
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000277 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000278 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
279 const char *DepTarget;
280
281 // If user provided -o, that is the dependency target, except
282 // when we are only generating a dependency file.
283 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
284 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000285 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000286 } else {
287 // Otherwise derive from the base input.
288 //
289 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000290 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000291 llvm::sys::path::replace_extension(P, "o");
292 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000293 }
294
295 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000296 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000297 QuoteTarget(DepTarget, Quoted);
298 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000299 }
300
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000301 if (A->getOption().matches(options::OPT_M) ||
302 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000303 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000304
305 if (isa<PrecompileJobAction>(JA))
306 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000307 }
308
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000309 if (Args.hasArg(options::OPT_MG)) {
310 if (!A || A->getOption().matches(options::OPT_MD) ||
311 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000312 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000313 CmdArgs.push_back("-MG");
314 }
315
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000316 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000317
318 // Convert all -MQ <target> args to -MT <quoted target>
319 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
320 options::OPT_MQ),
321 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000322 const Arg *A = *it;
323 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000324
Daniel Dunbara442fd52010-06-11 22:00:13 +0000325 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000326 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000327 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000328 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000329 CmdArgs.push_back(Args.MakeArgString(Quoted));
330
331 // -MT flag - no change
332 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000333 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000334 }
335 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000336
Douglas Gregor111af7d2009-04-18 00:34:01 +0000337 // Add -i* options, and automatically translate to
338 // -include-pch/-include-pth for transparent PCH support. It's
339 // wonky, but we include looking for .gch so we can support seamless
340 // replacement into a build system already set up to be generating
341 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000342 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000343 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
344 ie = Args.filtered_end(); it != ie; ++it) {
345 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000346
347 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000348 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
349 RenderedImplicitInclude = true;
350
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000351 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000352 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000353
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000354 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000355 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000356 SmallString<128> P(A->getValue());
357 // We want the files to have a name like foo.h.pch. Add a dummy extension
358 // so that replace_extension does the right thing.
359 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000360 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000361 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000362 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000363 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000364 }
365
Douglas Gregor111af7d2009-04-18 00:34:01 +0000366 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000367 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000368 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000369 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000370 }
371
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000373 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000374 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000375 FoundPCH = UsePCH;
376 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000377 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000378 }
379
380 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000381 if (IsFirstImplicitInclude) {
382 A->claim();
383 if (UsePCH)
384 CmdArgs.push_back("-include-pch");
385 else
386 CmdArgs.push_back("-include-pth");
387 CmdArgs.push_back(Args.MakeArgString(P.str()));
388 continue;
389 } else {
390 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000391 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000392 << P.str() << A->getAsString(Args);
393 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000394 }
395 }
396
397 // Not translated, render as usual.
398 A->claim();
399 A->render(Args, CmdArgs);
400 }
401
402 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000403 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
404 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000405
406 // Add -Wp, and -Xassembler if using the preprocessor.
407
408 // FIXME: There is a very unfortunate problem here, some troubled
409 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
410 // really support that we would have to parse and then translate
411 // those options. :(
412 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
413 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000414
415 // -I- is a deprecated GCC feature, reject it.
416 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000417 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000418
419 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
420 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000421 StringRef sysroot = C.getSysRoot();
422 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000423 if (!Args.hasArg(options::OPT_isysroot)) {
424 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000425 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000426 }
427 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000428
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000429 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000430 // FIXME: We should probably sink the logic for handling these from the
431 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000432 // CPATH - included following the user specified includes (but prior to
433 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000434 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000435 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000436 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000437 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000438 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000439 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000440 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000441 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000442 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000443
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000444 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000445 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000446 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000447
448 // Add system include arguments.
449 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000450}
451
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000452// FIXME: Move to target hook.
453static bool isSignedCharDefault(const llvm::Triple &Triple) {
454 switch (Triple.getArch()) {
455 default:
456 return true;
457
Tim Northover9bb857a2013-01-31 12:13:10 +0000458 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000459 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000460 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000461 case llvm::Triple::armeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000462 if (Triple.isOSDarwin() || Triple.isOSWindows())
463 return true;
464 return false;
465
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000466 case llvm::Triple::ppc:
467 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000468 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000469 return true;
470 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000471
Bill Schmidt778d3872013-07-26 01:36:11 +0000472 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000473 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000474 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000475 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000476 }
477}
478
Robert Lytton0e076492013-08-13 09:43:10 +0000479static bool isNoCommonDefault(const llvm::Triple &Triple) {
480 switch (Triple.getArch()) {
481 default:
482 return false;
483
484 case llvm::Triple::xcore:
485 return true;
486 }
487}
488
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000489// Handle -mhwdiv=.
490static void getARMHWDivFeatures(const Driver &D, const Arg *A,
491 const ArgList &Args,
492 std::vector<const char *> &Features) {
493 StringRef HWDiv = A->getValue();
494 if (HWDiv == "arm") {
495 Features.push_back("+hwdiv-arm");
496 Features.push_back("-hwdiv");
497 } else if (HWDiv == "thumb") {
498 Features.push_back("-hwdiv-arm");
499 Features.push_back("+hwdiv");
500 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
501 Features.push_back("+hwdiv-arm");
502 Features.push_back("+hwdiv");
503 } else if (HWDiv == "none") {
504 Features.push_back("-hwdiv-arm");
505 Features.push_back("-hwdiv");
506 } else
507 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
508}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000509
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000510// Handle -mfpu=.
511//
512// FIXME: Centralize feature selection, defaulting shouldn't be also in the
513// frontend target.
514static void getARMFPUFeatures(const Driver &D, const Arg *A,
515 const ArgList &Args,
516 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000517 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000518
519 // Set the target features based on the FPU.
520 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
521 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000522 Features.push_back("-vfp2");
523 Features.push_back("-vfp3");
524 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000525 } else if (FPU == "vfp") {
526 Features.push_back("+vfp2");
527 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000528 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000529 Features.push_back("+vfp3");
530 Features.push_back("+d16");
531 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000532 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000533 Features.push_back("+vfp3");
534 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000535 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
536 Features.push_back("+vfp4");
537 Features.push_back("+d16");
538 Features.push_back("-neon");
539 } else if (FPU == "vfp4" || FPU == "vfpv4") {
540 Features.push_back("+vfp4");
541 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000542 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
543 Features.push_back("+vfp4");
544 Features.push_back("+d16");
545 Features.push_back("+fp-only-sp");
546 Features.push_back("-neon");
Oliver Stannardbfd3ea32014-10-01 09:03:02 +0000547 } else if (FPU == "fp5-sp-d16" || FPU == "fpv5-sp-d16") {
548 Features.push_back("+fp-armv8");
549 Features.push_back("+fp-only-sp");
550 Features.push_back("+d16");
551 Features.push_back("-neon");
552 Features.push_back("-crypto");
553 } else if (FPU == "fp5-dp-d16" || FPU == "fpv5-dp-d16" ||
554 FPU == "fp5-d16" || FPU == "fpv5-d16") {
555 Features.push_back("+fp-armv8");
556 Features.push_back("+d16");
557 Features.push_back("-neon");
558 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000559 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000560 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000561 Features.push_back("-neon");
562 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000563 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000564 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000565 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000566 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000567 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000568 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000569 Features.push_back("+neon");
570 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000571 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000572 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000573 } else if (FPU == "none") {
574 Features.push_back("-vfp2");
575 Features.push_back("-vfp3");
576 Features.push_back("-vfp4");
577 Features.push_back("-fp-armv8");
578 Features.push_back("-crypto");
579 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000580 } else
581 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
582}
583
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000584// Select the float ABI as determined by -msoft-float, -mhard-float, and
585// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000586StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000587 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000588 StringRef FloatABI;
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000589 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
590 options::OPT_mhard_float,
591 options::OPT_mfloat_abi_EQ)) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000592 if (A->getOption().matches(options::OPT_msoft_float))
593 FloatABI = "soft";
594 else if (A->getOption().matches(options::OPT_mhard_float))
595 FloatABI = "hard";
596 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000597 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000598 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000599 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000600 << A->getAsString(Args);
601 FloatABI = "soft";
602 }
603 }
604 }
605
606 // If unspecified, choose the default based on the platform.
607 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000608 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000609 case llvm::Triple::Darwin:
610 case llvm::Triple::MacOSX:
611 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000612 // Darwin defaults to "softfp" for v6 and v7.
613 //
614 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000615 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000616 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000617 if (StringRef(ArchName).startswith("v6") ||
618 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000619 FloatABI = "softfp";
620 else
621 FloatABI = "soft";
622 break;
623 }
624
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000625 // FIXME: this is invalid for WindowsCE
626 case llvm::Triple::Win32:
627 FloatABI = "hard";
628 break;
629
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000630 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000631 switch(Triple.getEnvironment()) {
632 case llvm::Triple::GNUEABIHF:
633 FloatABI = "hard";
634 break;
635 default:
636 // FreeBSD defaults to soft float
637 FloatABI = "soft";
638 break;
639 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000640 break;
641
Daniel Dunbar78485922009-09-10 23:00:09 +0000642 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000643 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000644 case llvm::Triple::GNUEABIHF:
645 FloatABI = "hard";
646 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000647 case llvm::Triple::GNUEABI:
648 FloatABI = "softfp";
649 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000650 case llvm::Triple::EABIHF:
651 FloatABI = "hard";
652 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000653 case llvm::Triple::EABI:
654 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
655 FloatABI = "softfp";
656 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000657 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000658 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000659 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000660 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000661 FloatABI = "softfp";
662 else
663 FloatABI = "soft";
664 break;
665 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000666 default:
667 // Assume "soft", but warn the user we are guessing.
668 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000669 if (Triple.getOS() != llvm::Triple::UnknownOS ||
670 !Triple.isOSBinFormatMachO())
671 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000672 break;
673 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000674 }
675 }
676
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000677 return FloatABI;
678}
679
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000680static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
681 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000682 std::vector<const char *> &Features,
683 bool ForAS) {
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000684 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000685 if (!ForAS) {
686 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
687 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
688 // stripped out by the ARM target. We should probably pass this a new
689 // -target-option, which is handled by the -cc1/-cc1as invocation.
690 //
691 // FIXME2: For consistency, it would be ideal if we set up the target
692 // machine state the same when using the frontend or the assembler. We don't
693 // currently do that for the assembler, we pass the options directly to the
694 // backend and never even instantiate the frontend TargetInfo. If we did,
695 // and used its handleTargetFeatures hook, then we could ensure the
696 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000697
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000698 // Use software floating point operations?
699 if (FloatABI == "soft")
700 Features.push_back("+soft-float");
701
702 // Use software floating point argument passing?
703 if (FloatABI != "hard")
704 Features.push_back("+soft-float-abi");
705 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000706
707 // Honor -mfpu=.
708 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000709 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000710 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
711 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000712
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000713 // Setting -msoft-float effectively disables NEON because of the GCC
714 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000715 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000716 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000717 // Also need to explicitly disable features which imply NEON.
718 Features.push_back("-crypto");
719 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000720
721 // En/disable crc
722 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
723 options::OPT_mnocrc)) {
724 if (A->getOption().matches(options::OPT_mcrc))
725 Features.push_back("+crc");
726 else
727 Features.push_back("-crc");
728 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000729}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000730
731void Clang::AddARMTargetArgs(const ArgList &Args,
732 ArgStringList &CmdArgs,
733 bool KernelOrKext) const {
734 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000735 // Get the effective triple, which takes into account the deployment target.
736 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
737 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000738 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000739
740 // Select the ABI to use.
741 //
742 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000743 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000744 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000745 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000746 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000747 // The backend is hardwired to assume AAPCS for M-class processors, ensure
748 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000749 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000750 (Triple.getOS() == llvm::Triple::UnknownOS &&
751 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000752 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000753 ABIName = "aapcs";
754 } else {
755 ABIName = "apcs-gnu";
756 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000757 } else if (Triple.isOSWindows()) {
758 // FIXME: this is invalid for WindowsCE
759 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000760 } else {
761 // Select the default based on the platform.
762 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000763 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000764 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000765 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000766 ABIName = "aapcs-linux";
767 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000768 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000769 case llvm::Triple::EABI:
770 ABIName = "aapcs";
771 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000772 default:
773 if (Triple.getOS() == llvm::Triple::NetBSD)
774 ABIName = "apcs-gnu";
775 else
776 ABIName = "aapcs";
777 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000778 }
779 }
780 CmdArgs.push_back("-target-abi");
781 CmdArgs.push_back(ABIName);
782
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000783 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000784 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000785 if (FloatABI == "soft") {
786 // Floating point operations and argument passing are soft.
787 //
788 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000789 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000790 CmdArgs.push_back("-mfloat-abi");
791 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000792 } else if (FloatABI == "softfp") {
793 // Floating point operations are hard, but argument passing is soft.
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 {
797 // Floating point operations and argument passing are hard.
798 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000799 CmdArgs.push_back("-mfloat-abi");
800 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000801 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000802
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000803 // Kernel code has more strict alignment requirements.
804 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000805 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000806 CmdArgs.push_back("-backend-option");
807 CmdArgs.push_back("-arm-long-calls");
808 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000809
Daniel Dunbar12100e22011-03-22 16:48:17 +0000810 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000811 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000812
813 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000814 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000815 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000816 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000817
Bob Wilson0874e532014-07-29 00:23:18 +0000818 // -mkernel implies -mstrict-align; don't add the redundant option.
819 if (!KernelOrKext) {
820 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
821 options::OPT_munaligned_access)) {
822 CmdArgs.push_back("-backend-option");
823 if (A->getOption().matches(options::OPT_mno_unaligned_access))
824 CmdArgs.push_back("-arm-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000825 else {
826 if (getToolChain().getTriple().getSubArch() ==
827 llvm::Triple::SubArchType::ARMSubArch_v6m)
828 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
Bob Wilson0874e532014-07-29 00:23:18 +0000829 CmdArgs.push_back("-arm-no-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000830 }
Bob Wilson0874e532014-07-29 00:23:18 +0000831 }
832 }
833
Chad Rosierba3df1d2011-08-26 00:26:29 +0000834 // Setting -mno-global-merge disables the codegen global merge pass. Setting
835 // -mglobal-merge has no effect as the pass is enabled by default.
836 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
837 options::OPT_mno_global_merge)) {
838 if (A->getOption().matches(options::OPT_mno_global_merge))
839 CmdArgs.push_back("-mno-global-merge");
840 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000841
Bob Wilson9c8af452013-04-11 18:53:25 +0000842 if (!Args.hasFlag(options::OPT_mimplicit_float,
843 options::OPT_mno_implicit_float,
844 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000845 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000846
Logan Chien749763e2014-04-03 13:12:44 +0000847 // llvm does not support reserving registers in general. There is support
848 // for reserving r9 on ARM though (defined as a platform-specific register
849 // in ARM EABI).
850 if (Args.hasArg(options::OPT_ffixed_r9)) {
851 CmdArgs.push_back("-backend-option");
852 CmdArgs.push_back("-arm-reserve-r9");
853 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000854}
855
Tim Northover573cbee2014-05-24 12:52:07 +0000856/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
857/// targeting.
858static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000859 Arg *A;
860 std::string CPU;
861 // If we have -mtune or -mcpu, use that.
862 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
863 CPU = A->getValue();
864 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
865 StringRef Mcpu = A->getValue();
866 CPU = Mcpu.split("+").first;
Tim Northovera2ee4332014-03-29 15:09:45 +0000867 }
868
Kevin Qin110db6f2014-07-18 07:03:22 +0000869 // Handle CPU name is 'native'.
870 if (CPU == "native")
871 return llvm::sys::getHostCPUName();
872 else if (CPU.size())
873 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000874
James Molloy9b1586b2014-04-17 12:51:17 +0000875 // Make sure we pick "cyclone" if -arch is used.
876 // FIXME: Should this be picked by checking the target triple instead?
877 if (Args.getLastArg(options::OPT_arch))
878 return "cyclone";
879
880 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000881}
882
Tim Northover573cbee2014-05-24 12:52:07 +0000883void Clang::AddAArch64TargetArgs(const ArgList &Args,
884 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000885 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
886 llvm::Triple Triple(TripleStr);
887
888 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
889 Args.hasArg(options::OPT_mkernel) ||
890 Args.hasArg(options::OPT_fapple_kext))
891 CmdArgs.push_back("-disable-red-zone");
892
893 if (!Args.hasFlag(options::OPT_mimplicit_float,
894 options::OPT_mno_implicit_float, true))
895 CmdArgs.push_back("-no-implicit-float");
896
Craig Topper92fc2df2014-05-17 16:56:41 +0000897 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000898 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
899 ABIName = A->getValue();
900 else if (Triple.isOSDarwin())
901 ABIName = "darwinpcs";
902 else
903 ABIName = "aapcs";
904
905 CmdArgs.push_back("-target-abi");
906 CmdArgs.push_back(ABIName);
907
Bob Wilson0874e532014-07-29 00:23:18 +0000908 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
909 options::OPT_munaligned_access)) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000910 CmdArgs.push_back("-backend-option");
Bob Wilson0874e532014-07-29 00:23:18 +0000911 if (A->getOption().matches(options::OPT_mno_unaligned_access))
912 CmdArgs.push_back("-aarch64-strict-align");
913 else
914 CmdArgs.push_back("-aarch64-no-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000915 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000916
917 // Setting -mno-global-merge disables the codegen global merge pass. Setting
918 // -mglobal-merge has no effect as the pass is enabled by default.
919 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
920 options::OPT_mno_global_merge)) {
921 if (A->getOption().matches(options::OPT_mno_global_merge))
922 CmdArgs.push_back("-mno-global-merge");
923 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000924}
925
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000926// Get CPU and ABI names. They are not independent
927// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000928void mips::getMipsCPUAndABI(const ArgList &Args,
929 const llvm::Triple &Triple,
930 StringRef &CPUName,
931 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000932 const char *DefMips32CPU = "mips32r2";
933 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000934
Daniel Sanders2bf13662014-07-10 14:40:57 +0000935 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
936 // default for mips64(el)?-img-linux-gnu.
937 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
938 Triple.getEnvironment() == llvm::Triple::GNU) {
939 DefMips32CPU = "mips32r6";
940 DefMips64CPU = "mips64r6";
941 }
942
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000943 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000944 options::OPT_mcpu_EQ))
945 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000946
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000947 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000948 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000949 // Convert a GNU style Mips ABI name to the name
950 // accepted by LLVM Mips backend.
951 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
952 .Case("32", "o32")
953 .Case("64", "n64")
954 .Default(ABIName);
955 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000956
957 // Setup default CPU and ABI names.
958 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000959 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000960 default:
961 llvm_unreachable("Unexpected triple arch name");
962 case llvm::Triple::mips:
963 case llvm::Triple::mipsel:
964 CPUName = DefMips32CPU;
965 break;
966 case llvm::Triple::mips64:
967 case llvm::Triple::mips64el:
968 CPUName = DefMips64CPU;
969 break;
970 }
971 }
972
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000973 if (ABIName.empty()) {
974 // Deduce ABI name from the target triple.
975 if (Triple.getArch() == llvm::Triple::mips ||
976 Triple.getArch() == llvm::Triple::mipsel)
977 ABIName = "o32";
978 else
979 ABIName = "n64";
980 }
981
982 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000983 // Deduce CPU name from ABI name.
984 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000985 .Cases("o32", "eabi", DefMips32CPU)
986 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000987 .Default("");
988 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +0000989
990 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000991}
992
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000993// Convert ABI name to the GNU tools acceptable variant.
994static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
995 return llvm::StringSwitch<llvm::StringRef>(ABI)
996 .Case("o32", "32")
997 .Case("n64", "64")
998 .Default(ABI);
999}
1000
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001001// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1002// and -mfloat-abi=.
1003static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001004 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001005 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001006 options::OPT_mhard_float,
1007 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001008 if (A->getOption().matches(options::OPT_msoft_float))
1009 FloatABI = "soft";
1010 else if (A->getOption().matches(options::OPT_mhard_float))
1011 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001012 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001013 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001014 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001015 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001016 FloatABI = "hard";
1017 }
1018 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001019 }
1020
1021 // If unspecified, choose the default based on the platform.
1022 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001023 // Assume "hard", because it's a default value used by gcc.
1024 // When we start to recognize specific target MIPS processors,
1025 // we will be able to select the default more correctly.
1026 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001027 }
1028
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001029 return FloatABI;
1030}
1031
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001032static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001033 std::vector<const char *> &Features,
1034 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001035 StringRef FeatureName) {
1036 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001037 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001038 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001039 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001040 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001041 }
1042}
1043
Daniel Sanders379d44b2014-07-16 11:52:23 +00001044static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1045 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001046 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001047 StringRef CPUName;
1048 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001049 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001050 ABIName = getGnuCompatibleMipsABIName(ABIName);
1051
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001052 // Always override the backend's default ABI.
Aaron Ballman9eef74232014-07-17 13:28:50 +00001053 std::string ABIFeature = llvm::StringSwitch<StringRef>(ABIName)
1054 .Case("32", "+o32")
1055 .Case("n32", "+n32")
1056 .Case("64", "+n64")
1057 .Case("eabi", "+eabi")
1058 .Default(("+" + ABIName).str());
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001059 Features.push_back("-o32");
1060 Features.push_back("-n64");
1061 Features.push_back(Args.MakeArgString(ABIFeature));
1062
Daniel Sandersfeb61302014-08-08 15:47:17 +00001063 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1064 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001065
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001066 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001067 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001068 // FIXME: Note, this is a hack. We need to pass the selected float
1069 // mode to the MipsTargetInfoBase to define appropriate macros there.
1070 // Now it is the only method.
1071 Features.push_back("+soft-float");
1072 }
1073
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001074 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001075 StringRef Val = StringRef(A->getValue());
1076 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001077 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001078 else if (Val == "legacy")
1079 Features.push_back("-nan2008");
1080 else
1081 D.Diag(diag::err_drv_unsupported_option_argument)
1082 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001083 }
1084
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001085 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1086 options::OPT_mdouble_float, "single-float");
1087 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1088 "mips16");
1089 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1090 options::OPT_mno_micromips, "micromips");
1091 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1092 "dsp");
1093 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1094 "dspr2");
1095 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1096 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001097
1098 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1099 // pass -mfpxx
1100 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1101 options::OPT_mfp64)) {
1102 if (A->getOption().matches(options::OPT_mfp32))
1103 Features.push_back(Args.MakeArgString("-fp64"));
1104 else if (A->getOption().matches(options::OPT_mfpxx)) {
1105 Features.push_back(Args.MakeArgString("+fpxx"));
1106 Features.push_back(Args.MakeArgString("+nooddspreg"));
1107 } else
1108 Features.push_back(Args.MakeArgString("+fp64"));
1109 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001110 Features.push_back(Args.MakeArgString("+fpxx"));
1111 Features.push_back(Args.MakeArgString("+nooddspreg"));
1112 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001113
Daniel Sanders28e5d392014-07-10 10:39:51 +00001114 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1115 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001116}
1117
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001118void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001119 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001120 const Driver &D = getToolChain().getDriver();
1121 StringRef CPUName;
1122 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001123 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001124 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001125
1126 CmdArgs.push_back("-target-abi");
1127 CmdArgs.push_back(ABIName.data());
1128
1129 StringRef FloatABI = getMipsFloatABI(D, Args);
1130
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001131 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001132 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001133 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001134 CmdArgs.push_back("-mfloat-abi");
1135 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001136 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001137 else {
1138 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001139 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001140 CmdArgs.push_back("-mfloat-abi");
1141 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001142 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001143
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001144 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1145 if (A->getOption().matches(options::OPT_mxgot)) {
1146 CmdArgs.push_back("-mllvm");
1147 CmdArgs.push_back("-mxgot");
1148 }
1149 }
1150
Simon Atanasyanc580b322013-05-11 06:33:44 +00001151 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1152 options::OPT_mno_ldc1_sdc1)) {
1153 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1154 CmdArgs.push_back("-mllvm");
1155 CmdArgs.push_back("-mno-ldc1-sdc1");
1156 }
1157 }
1158
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001159 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1160 options::OPT_mno_check_zero_division)) {
1161 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1162 CmdArgs.push_back("-mllvm");
1163 CmdArgs.push_back("-mno-check-zero-division");
1164 }
1165 }
1166
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001167 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001168 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001169 CmdArgs.push_back("-mllvm");
1170 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1171 A->claim();
1172 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001173}
1174
Hal Finkel8eb59282012-06-11 22:35:19 +00001175/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1176static std::string getPPCTargetCPU(const ArgList &Args) {
1177 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001178 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001179
1180 if (CPUName == "native") {
1181 std::string CPU = llvm::sys::getHostCPUName();
1182 if (!CPU.empty() && CPU != "generic")
1183 return CPU;
1184 else
1185 return "";
1186 }
1187
1188 return llvm::StringSwitch<const char *>(CPUName)
1189 .Case("common", "generic")
1190 .Case("440", "440")
1191 .Case("440fp", "440")
1192 .Case("450", "450")
1193 .Case("601", "601")
1194 .Case("602", "602")
1195 .Case("603", "603")
1196 .Case("603e", "603e")
1197 .Case("603ev", "603ev")
1198 .Case("604", "604")
1199 .Case("604e", "604e")
1200 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001201 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001202 .Case("G3", "g3")
1203 .Case("7400", "7400")
1204 .Case("G4", "g4")
1205 .Case("7450", "7450")
1206 .Case("G4+", "g4+")
1207 .Case("750", "750")
1208 .Case("970", "970")
1209 .Case("G5", "g5")
1210 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001211 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001212 .Case("e500mc", "e500mc")
1213 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001214 .Case("power3", "pwr3")
1215 .Case("power4", "pwr4")
1216 .Case("power5", "pwr5")
1217 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001218 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001219 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001220 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001221 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001222 .Case("pwr3", "pwr3")
1223 .Case("pwr4", "pwr4")
1224 .Case("pwr5", "pwr5")
1225 .Case("pwr5x", "pwr5x")
1226 .Case("pwr6", "pwr6")
1227 .Case("pwr6x", "pwr6x")
1228 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001229 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001230 .Case("powerpc", "ppc")
1231 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001232 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001233 .Default("");
1234 }
1235
1236 return "";
1237}
1238
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001239static void getPPCTargetFeatures(const ArgList &Args,
1240 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001241 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1242 ie = Args.filtered_end();
1243 it != ie; ++it) {
1244 StringRef Name = (*it)->getOption().getName();
1245 (*it)->claim();
1246
1247 // Skip over "-m".
1248 assert(Name.startswith("m") && "Invalid feature name.");
1249 Name = Name.substr(1);
1250
1251 bool IsNegative = Name.startswith("no-");
1252 if (IsNegative)
1253 Name = Name.substr(3);
1254
1255 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1256 // pass the correct option to the backend while calling the frontend
1257 // option the same.
1258 // TODO: Change the LLVM backend option maybe?
1259 if (Name == "mfcrf")
1260 Name = "mfocrf";
1261
1262 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1263 }
1264
1265 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001266 AddTargetFeature(Args, Features, options::OPT_faltivec,
1267 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001268}
1269
Ulrich Weigand8afad612014-07-28 13:17:52 +00001270void Clang::AddPPCTargetArgs(const ArgList &Args,
1271 ArgStringList &CmdArgs) const {
1272 // Select the ABI to use.
1273 const char *ABIName = nullptr;
1274 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1275 ABIName = A->getValue();
1276 } else if (getToolChain().getTriple().isOSLinux())
1277 switch(getToolChain().getArch()) {
1278 case llvm::Triple::ppc64:
1279 ABIName = "elfv1";
1280 break;
1281 case llvm::Triple::ppc64le:
1282 ABIName = "elfv2";
1283 break;
1284 default:
1285 break;
1286 }
1287
1288 if (ABIName) {
1289 CmdArgs.push_back("-target-abi");
1290 CmdArgs.push_back(ABIName);
1291 }
1292}
1293
1294bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1295 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1296 return A && (A->getValue() == StringRef(Value));
1297}
1298
Tom Stellard6674c702013-04-01 20:56:53 +00001299/// Get the (LLVM) name of the R600 gpu we are targeting.
1300static std::string getR600TargetGPU(const ArgList &Args) {
1301 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001302 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001303 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001304 .Cases("rv630", "rv635", "r600")
1305 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001306 .Case("rv740", "rv770")
1307 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001308 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001309 .Case("hemlock", "cypress")
1310 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001311 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001312 }
1313 return "";
1314}
1315
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001316static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001317 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001318 bool SoftFloatABI = true;
1319 if (Arg *A =
1320 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1321 if (A->getOption().matches(options::OPT_mhard_float))
1322 SoftFloatABI = false;
1323 }
1324 if (SoftFloatABI)
1325 Features.push_back("+soft-float");
1326}
1327
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001328void Clang::AddSparcTargetArgs(const ArgList &Args,
1329 ArgStringList &CmdArgs) const {
1330 const Driver &D = getToolChain().getDriver();
1331
Brad Smith10cd0f42014-07-11 20:12:08 +00001332 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001333 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001334 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1335 options::OPT_mhard_float)) {
1336 if (A->getOption().matches(options::OPT_msoft_float))
1337 FloatABI = "soft";
1338 else if (A->getOption().matches(options::OPT_mhard_float))
1339 FloatABI = "hard";
1340 }
1341
1342 // If unspecified, choose the default based on the platform.
1343 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001344 // Assume "soft", but warn the user we are guessing.
1345 FloatABI = "soft";
1346 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001347 }
1348
1349 if (FloatABI == "soft") {
1350 // Floating point operations and argument passing are soft.
1351 //
1352 // FIXME: This changes CPP defines, we need -target-soft-float.
1353 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001354 } else {
1355 assert(FloatABI == "hard" && "Invalid float abi!");
1356 CmdArgs.push_back("-mhard-float");
1357 }
1358}
1359
Richard Sandiford4652d892013-07-19 16:51:51 +00001360static const char *getSystemZTargetCPU(const ArgList &Args) {
1361 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1362 return A->getValue();
1363 return "z10";
1364}
1365
Chandler Carruth953fb082013-01-13 11:46:33 +00001366static const char *getX86TargetCPU(const ArgList &Args,
1367 const llvm::Triple &Triple) {
1368 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001369 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001370 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001371 return "core-avx2";
1372
Chandler Carruth953fb082013-01-13 11:46:33 +00001373 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001374 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001375
1376 // FIXME: Reject attempts to use -march=native unless the target matches
1377 // the host.
1378 //
1379 // FIXME: We should also incorporate the detected target features for use
1380 // with -native.
1381 std::string CPU = llvm::sys::getHostCPUName();
1382 if (!CPU.empty() && CPU != "generic")
1383 return Args.MakeArgString(CPU);
1384 }
1385
1386 // Select the default CPU if none was given (or detection failed).
1387
1388 if (Triple.getArch() != llvm::Triple::x86_64 &&
1389 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001390 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001391
1392 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1393
1394 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001395 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001396 if (Triple.getArchName() == "x86_64h")
1397 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001398 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001399 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001400
Alexey Bataev286d1b92014-01-31 04:07:13 +00001401 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001402 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001403 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001404
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001405 // Everything else goes to x86-64 in 64-bit mode.
1406 if (Is64Bit)
1407 return "x86-64";
1408
1409 switch (Triple.getOS()) {
1410 case llvm::Triple::FreeBSD:
1411 case llvm::Triple::NetBSD:
1412 case llvm::Triple::OpenBSD:
1413 return "i486";
1414 case llvm::Triple::Haiku:
1415 return "i586";
1416 case llvm::Triple::Bitrig:
1417 return "i686";
1418 default:
1419 // Fallback to p4.
1420 return "pentium4";
1421 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001422}
1423
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001424static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1425 switch(T.getArch()) {
1426 default:
1427 return "";
1428
Amara Emerson703da2e2013-10-31 09:32:33 +00001429 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001430 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001431 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001432
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001433 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001434 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001435 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001436 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001437 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001438
1439 case llvm::Triple::mips:
1440 case llvm::Triple::mipsel:
1441 case llvm::Triple::mips64:
1442 case llvm::Triple::mips64el: {
1443 StringRef CPUName;
1444 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001445 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001446 return CPUName;
1447 }
1448
1449 case llvm::Triple::ppc:
1450 case llvm::Triple::ppc64:
1451 case llvm::Triple::ppc64le: {
1452 std::string TargetCPUName = getPPCTargetCPU(Args);
1453 // LLVM may default to generating code for the native CPU,
1454 // but, like gcc, we default to a more generic option for
1455 // each architecture. (except on Darwin)
1456 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1457 if (T.getArch() == llvm::Triple::ppc64)
1458 TargetCPUName = "ppc64";
1459 else if (T.getArch() == llvm::Triple::ppc64le)
1460 TargetCPUName = "ppc64le";
1461 else
1462 TargetCPUName = "ppc";
1463 }
1464 return TargetCPUName;
1465 }
1466
1467 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001468 case llvm::Triple::sparcv9:
1469 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001470 return A->getValue();
1471 return "";
1472
1473 case llvm::Triple::x86:
1474 case llvm::Triple::x86_64:
1475 return getX86TargetCPU(Args, T);
1476
1477 case llvm::Triple::hexagon:
1478 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1479
1480 case llvm::Triple::systemz:
1481 return getSystemZTargetCPU(Args);
1482
1483 case llvm::Triple::r600:
1484 return getR600TargetGPU(Args);
1485 }
1486}
1487
Alp Tokerce365ca2013-12-02 12:43:03 +00001488static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1489 ArgStringList &CmdArgs) {
1490 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1491 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1492 // forward.
1493 CmdArgs.push_back("-plugin");
1494 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1495 CmdArgs.push_back(Args.MakeArgString(Plugin));
1496
1497 // Try to pass driver level flags relevant to LTO code generation down to
1498 // the plugin.
1499
1500 // Handle flags for selecting CPU variants.
1501 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1502 if (!CPU.empty())
1503 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1504}
1505
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001506static void getX86TargetFeatures(const Driver & D,
1507 const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001508 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001509 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001510 if (Triple.getArchName() == "x86_64h") {
1511 // x86_64h implies quite a few of the more modern subtarget features
1512 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1513 Features.push_back("-rdrnd");
1514 Features.push_back("-aes");
1515 Features.push_back("-pclmul");
1516 Features.push_back("-rtm");
1517 Features.push_back("-hle");
1518 Features.push_back("-fsgsbase");
1519 }
1520
Alexey Volkov54ff0802014-06-25 12:15:36 +00001521 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001522 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001523 if (Triple.getArch() == llvm::Triple::x86_64) {
1524 Features.push_back("+sse4.2");
1525 Features.push_back("+popcnt");
1526 } else
1527 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001528 }
1529
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001530 // Set features according to the -arch flag on MSVC
1531 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1532 StringRef Arch = A->getValue();
1533 bool ArchUsed = false;
1534 // First, look for flags that are shared in x86 and x86-64.
1535 if (Triple.getArch() == llvm::Triple::x86_64 ||
1536 Triple.getArch() == llvm::Triple::x86) {
1537 if (Arch == "AVX" || Arch == "AVX2") {
1538 ArchUsed = true;
1539 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1540 }
1541 }
1542 // Then, look for x86-specific flags.
1543 if (Triple.getArch() == llvm::Triple::x86) {
1544 if (Arch == "IA32") {
1545 ArchUsed = true;
1546 } else if (Arch == "SSE" || Arch == "SSE2") {
1547 ArchUsed = true;
1548 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1549 }
1550 }
1551 if (!ArchUsed)
1552 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1553 }
1554
Jim Grosbach82eee262013-11-16 00:53:35 +00001555 // Now add any that the user explicitly requested on the command line,
1556 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001557 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1558 ie = Args.filtered_end();
1559 it != ie; ++it) {
1560 StringRef Name = (*it)->getOption().getName();
1561 (*it)->claim();
1562
1563 // Skip over "-m".
1564 assert(Name.startswith("m") && "Invalid feature name.");
1565 Name = Name.substr(1);
1566
1567 bool IsNegative = Name.startswith("no-");
1568 if (IsNegative)
1569 Name = Name.substr(3);
1570
1571 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1572 }
1573}
1574
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001575void Clang::AddX86TargetArgs(const ArgList &Args,
1576 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001577 if (!Args.hasFlag(options::OPT_mred_zone,
1578 options::OPT_mno_red_zone,
1579 true) ||
1580 Args.hasArg(options::OPT_mkernel) ||
1581 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001582 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001583
Bob Wilson2616e2e2013-02-10 16:01:41 +00001584 // Default to avoid implicit floating-point for kernel/kext code, but allow
1585 // that to be overridden with -mno-soft-float.
1586 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1587 Args.hasArg(options::OPT_fapple_kext));
1588 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1589 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001590 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001591 options::OPT_mno_implicit_float)) {
1592 const Option &O = A->getOption();
1593 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1594 O.matches(options::OPT_msoft_float));
1595 }
1596 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001597 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001598
1599 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1600 StringRef Value = A->getValue();
1601 if (Value == "intel" || Value == "att") {
1602 CmdArgs.push_back("-mllvm");
1603 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1604 } else {
1605 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1606 << A->getOption().getName() << Value;
1607 }
1608 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001609}
1610
Matthew Curtise8f80a12012-12-06 17:49:03 +00001611static inline bool HasPICArg(const ArgList &Args) {
1612 return Args.hasArg(options::OPT_fPIC)
1613 || Args.hasArg(options::OPT_fpic);
1614}
1615
1616static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1617 return Args.getLastArg(options::OPT_G,
1618 options::OPT_G_EQ,
1619 options::OPT_msmall_data_threshold_EQ);
1620}
1621
1622static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1623 std::string value;
1624 if (HasPICArg(Args))
1625 value = "0";
1626 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1627 value = A->getValue();
1628 A->claim();
1629 }
1630 return value;
1631}
1632
Tony Linthicum76329bf2011-12-12 21:14:55 +00001633void Clang::AddHexagonTargetArgs(const ArgList &Args,
1634 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001635 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001636 CmdArgs.push_back("-mqdsp6-compat");
1637 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001638
Matthew Curtise8f80a12012-12-06 17:49:03 +00001639 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1640 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001641 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001642 CmdArgs.push_back(Args.MakeArgString(
1643 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001644 }
1645
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001646 if (!Args.hasArg(options::OPT_fno_short_enums))
1647 CmdArgs.push_back("-fshort-enums");
1648 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1649 CmdArgs.push_back ("-mllvm");
1650 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1651 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001652 CmdArgs.push_back ("-mllvm");
1653 CmdArgs.push_back ("-machine-sink-split=0");
1654}
1655
Kevin Qin110db6f2014-07-18 07:03:22 +00001656// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001657static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001658 std::vector<const char *> &Features) {
1659 SmallVector<StringRef, 8> Split;
1660 text.split(Split, StringRef("+"), -1, false);
1661
1662 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1663 const char *result = llvm::StringSwitch<const char *>(Split[I])
1664 .Case("fp", "+fp-armv8")
1665 .Case("simd", "+neon")
1666 .Case("crc", "+crc")
1667 .Case("crypto", "+crypto")
1668 .Case("nofp", "-fp-armv8")
1669 .Case("nosimd", "-neon")
1670 .Case("nocrc", "-crc")
1671 .Case("nocrypto", "-crypto")
1672 .Default(nullptr);
1673 if (result)
1674 Features.push_back(result);
1675 else if (Split[I] == "neon" || Split[I] == "noneon")
1676 D.Diag(diag::err_drv_no_neon_modifier);
1677 else
1678 return false;
1679 }
1680 return true;
1681}
1682
1683// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1684// decode CPU and feature.
1685static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1686 std::vector<const char *> &Features) {
1687 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1688 CPU = Split.first;
1689 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57") {
1690 Features.push_back("+neon");
1691 Features.push_back("+crc");
1692 Features.push_back("+crypto");
1693 } else if (CPU == "generic") {
1694 Features.push_back("+neon");
1695 } else {
1696 return false;
1697 }
1698
1699 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1700 return false;
1701
1702 return true;
1703}
1704
1705static bool
1706getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1707 const ArgList &Args,
1708 std::vector<const char *> &Features) {
1709 std::pair<StringRef, StringRef> Split = March.split("+");
1710 if (Split.first != "armv8-a")
1711 return false;
1712
1713 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1714 return false;
1715
1716 return true;
1717}
1718
1719static bool
1720getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1721 const ArgList &Args,
1722 std::vector<const char *> &Features) {
1723 StringRef CPU;
1724 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1725 return false;
1726
1727 return true;
1728}
1729
1730static bool
1731getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1732 const ArgList &Args,
1733 std::vector<const char *> &Features) {
1734 // Handle CPU name is 'native'.
1735 if (Mtune == "native")
1736 Mtune = llvm::sys::getHostCPUName();
1737 if (Mtune == "cyclone") {
1738 Features.push_back("+zcm");
1739 Features.push_back("+zcz");
1740 }
1741 return true;
1742}
1743
1744static bool
1745getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1746 const ArgList &Args,
1747 std::vector<const char *> &Features) {
1748 StringRef CPU;
1749 std::vector<const char *> DecodedFeature;
1750 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1751 return false;
1752
1753 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1754}
1755
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001756static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1757 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001758 Arg *A;
1759 bool success = true;
1760 // Enable NEON by default.
1761 Features.push_back("+neon");
1762 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1763 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1764 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1765 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1766
1767 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1768 success =
1769 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1770 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1771 success =
1772 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1773
1774 if (!success)
1775 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001776
1777 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1778 Features.push_back("-fp-armv8");
1779 Features.push_back("-crypto");
1780 Features.push_back("-neon");
1781 }
Bradley Smith418c5932014-05-02 15:17:51 +00001782
1783 // En/disable crc
1784 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1785 options::OPT_mnocrc)) {
1786 if (A->getOption().matches(options::OPT_mcrc))
1787 Features.push_back("+crc");
1788 else
1789 Features.push_back("-crc");
1790 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001791}
1792
1793static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001794 const ArgList &Args, ArgStringList &CmdArgs,
1795 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001796 std::vector<const char *> Features;
1797 switch (Triple.getArch()) {
1798 default:
1799 break;
1800 case llvm::Triple::mips:
1801 case llvm::Triple::mipsel:
1802 case llvm::Triple::mips64:
1803 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001804 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001805 break;
1806
1807 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001808 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001809 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001810 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001811 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001812 break;
1813
1814 case llvm::Triple::ppc:
1815 case llvm::Triple::ppc64:
1816 case llvm::Triple::ppc64le:
1817 getPPCTargetFeatures(Args, Features);
1818 break;
1819 case llvm::Triple::sparc:
Brad Smithf436e9e2014-08-19 21:50:15 +00001820 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001821 getSparcTargetFeatures(Args, Features);
1822 break;
1823 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001824 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001825 getAArch64TargetFeatures(D, Args, Features);
1826 break;
1827 case llvm::Triple::x86:
1828 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001829 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001830 break;
1831 }
Rafael Espindola43964802013-08-21 17:34:32 +00001832
1833 // Find the last of each feature.
1834 llvm::StringMap<unsigned> LastOpt;
1835 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1836 const char *Name = Features[I];
1837 assert(Name[0] == '-' || Name[0] == '+');
1838 LastOpt[Name + 1] = I;
1839 }
1840
1841 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1842 // If this feature was overridden, ignore it.
1843 const char *Name = Features[I];
1844 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1845 assert(LastI != LastOpt.end());
1846 unsigned Last = LastI->second;
1847 if (Last != I)
1848 continue;
1849
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001850 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001851 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001852 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001853}
1854
Eric Christopher84fbdb42011-08-19 00:30:14 +00001855static bool
John McCall5fb5df92012-06-20 06:18:46 +00001856shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001857 const llvm::Triple &Triple) {
1858 // We use the zero-cost exception tables for Objective-C if the non-fragile
1859 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1860 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001861 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001862 return true;
1863
Bob Wilson83e723a2013-12-05 19:38:42 +00001864 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001865 return false;
1866
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001867 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001868 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001869 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001870}
1871
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001872namespace {
1873 struct ExceptionSettings {
1874 bool ExceptionsEnabled;
1875 bool ShouldUseExceptionTables;
1876 ExceptionSettings() : ExceptionsEnabled(false),
1877 ShouldUseExceptionTables(false) {}
1878 };
1879} // end anonymous namespace.
1880
Nico Webere8e53112014-05-11 01:04:02 +00001881// exceptionSettings() exists to share the logic between -cc1 and linker
1882// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001883static ExceptionSettings exceptionSettings(const ArgList &Args,
1884 const llvm::Triple &Triple) {
1885 ExceptionSettings ES;
1886
1887 // Are exceptions enabled by default?
1888 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1889
1890 // This keeps track of whether exceptions were explicitly turned on or off.
1891 bool DidHaveExplicitExceptionFlag = false;
1892
1893 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1894 options::OPT_fno_exceptions)) {
1895 if (A->getOption().matches(options::OPT_fexceptions))
1896 ES.ExceptionsEnabled = true;
1897 else
1898 ES.ExceptionsEnabled = false;
1899
1900 DidHaveExplicitExceptionFlag = true;
1901 }
1902
1903 // Exception tables and cleanups can be enabled with -fexceptions even if the
1904 // language itself doesn't support exceptions.
1905 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1906 ES.ShouldUseExceptionTables = true;
1907
1908 return ES;
1909}
1910
Anders Carlssone96ab552011-02-28 02:27:16 +00001911/// addExceptionArgs - Adds exception related arguments to the driver command
1912/// arguments. There's a master flag, -fexceptions and also language specific
1913/// flags to enable/disable C++ and Objective-C exceptions.
1914/// This makes it possible to for example disable C++ exceptions but enable
1915/// Objective-C exceptions.
1916static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1917 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001918 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001919 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001920 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001921 if (KernelOrKext) {
1922 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1923 // arguments now to avoid warnings about unused arguments.
1924 Args.ClaimAllArgs(options::OPT_fexceptions);
1925 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1926 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1927 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1928 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1929 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001930 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001931 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001932
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001933 // Gather the exception settings from the command line arguments.
1934 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001935
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001936 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1937 // is not necessarily sensible, but follows GCC.
1938 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001939 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001940 options::OPT_fno_objc_exceptions,
1941 true)) {
1942 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001943
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001944 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001945 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001946 }
1947
1948 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001949 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001950
Eric Christopher84fbdb42011-08-19 00:30:14 +00001951 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1952 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001953 options::OPT_fexceptions,
1954 options::OPT_fno_exceptions)) {
1955 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1956 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001957 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001958 CXXExceptionsEnabled = false;
1959 }
1960
1961 if (CXXExceptionsEnabled) {
1962 CmdArgs.push_back("-fcxx-exceptions");
1963
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001964 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001965 }
1966 }
1967
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001968 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001969 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001970}
1971
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001972static bool ShouldDisableAutolink(const ArgList &Args,
1973 const ToolChain &TC) {
1974 bool Default = true;
1975 if (TC.getTriple().isOSDarwin()) {
1976 // The native darwin assembler doesn't support the linker_option directives,
1977 // so we disable them if we think the .s file will be passed to it.
1978 Default = TC.useIntegratedAs();
1979 }
1980 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1981 Default);
1982}
1983
Ted Kremenek62093662013-03-12 17:02:12 +00001984static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1985 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001986 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1987 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001988 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001989 return !UseDwarfDirectory;
1990}
1991
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001992/// \brief Check whether the given input tree contains any compilation actions.
1993static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001994 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001995 return true;
1996
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001997 for (const auto &Act : *A)
1998 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001999 return true;
2000
2001 return false;
2002}
2003
2004/// \brief Check if -relax-all should be passed to the internal assembler.
2005/// This is done by default when compiling non-assembler source with -O0.
2006static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2007 bool RelaxDefault = true;
2008
2009 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2010 RelaxDefault = A->getOption().matches(options::OPT_O0);
2011
2012 if (RelaxDefault) {
2013 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002014 for (const auto &Act : C.getActions()) {
2015 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002016 RelaxDefault = true;
2017 break;
2018 }
2019 }
2020 }
2021
2022 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2023 RelaxDefault);
2024}
2025
David Blaikie9260ed62013-07-25 21:19:01 +00002026static void CollectArgsForIntegratedAssembler(Compilation &C,
2027 const ArgList &Args,
2028 ArgStringList &CmdArgs,
2029 const Driver &D) {
2030 if (UseRelaxAll(C, Args))
2031 CmdArgs.push_back("-mrelax-all");
2032
David Peixottodfb66142013-11-14 22:52:58 +00002033 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002034 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002035 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2036 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2037 // arg after parsing the '-I' arg.
2038 bool TakeNextArg = false;
2039
David Blaikie9260ed62013-07-25 21:19:01 +00002040 // When using an integrated assembler, translate -Wa, and -Xassembler
2041 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002042 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00002043 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
2044 options::OPT_Xassembler),
2045 ie = Args.filtered_end(); it != ie; ++it) {
2046 const Arg *A = *it;
2047 A->claim();
2048
2049 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2050 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002051 if (TakeNextArg) {
2052 CmdArgs.push_back(Value.data());
2053 TakeNextArg = false;
2054 continue;
2055 }
David Blaikie9260ed62013-07-25 21:19:01 +00002056
2057 if (Value == "-force_cpusubtype_ALL") {
2058 // Do nothing, this is the default and we don't support anything else.
2059 } else if (Value == "-L") {
2060 CmdArgs.push_back("-msave-temp-labels");
2061 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002062 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002063 } else if (Value == "--noexecstack") {
2064 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002065 } else if (Value == "-compress-debug-sections" ||
2066 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002067 CompressDebugSections = true;
2068 } else if (Value == "-nocompress-debug-sections" ||
2069 Value == "--nocompress-debug-sections") {
2070 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002071 } else if (Value.startswith("-I")) {
2072 CmdArgs.push_back(Value.data());
2073 // We need to consume the next argument if the current arg is a plain
2074 // -I. The next arg will be the include directory.
2075 if (Value == "-I")
2076 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002077 } else if (Value.startswith("-gdwarf-")) {
2078 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002079 } else {
2080 D.Diag(diag::err_drv_unsupported_option_argument)
2081 << A->getOption().getName() << Value;
2082 }
2083 }
2084 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002085 if (CompressDebugSections) {
2086 if (llvm::zlib::isAvailable())
2087 CmdArgs.push_back("-compress-debug-sections");
2088 else
2089 D.Diag(diag::warn_debug_compression_unavailable);
2090 }
David Blaikie9260ed62013-07-25 21:19:01 +00002091}
2092
Renato Goline807c122014-01-31 11:47:28 +00002093// Until ARM libraries are build separately, we have them all in one library
2094static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002095 if (TC.getArch() == llvm::Triple::arm ||
2096 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002097 return "arm";
2098 else
2099 return TC.getArchName();
2100}
2101
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002102static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2103 // The runtimes are located in the OS-specific resource directory.
2104 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002105 const llvm::Triple &Triple = TC.getTriple();
2106 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
2107 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
2108 "freebsd" : TC.getOS();
2109 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002110 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002111}
2112
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002113// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002114// FIXME: Make sure we can also emit shared objects if they're requested
2115// and available, check for possible errors, etc.
2116static void addClangRTLinux(
2117 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002118 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002119 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
2120 getArchNameForCompilerRTLib(TC) +
2121 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00002122
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002123 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00002124 CmdArgs.push_back("-lgcc_s");
2125 if (TC.getDriver().CCCIsCXX())
2126 CmdArgs.push_back("-lgcc_eh");
2127}
2128
Alexey Samsonov7811d192014-02-20 13:57:37 +00002129static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00002130 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002131 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2132 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002133 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002134 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002135 Args.hasArg(options::OPT_fcreate_profile) ||
2136 Args.hasArg(options::OPT_coverage)))
2137 return;
2138
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00002139 // -fprofile-instr-generate requires position-independent code to build with
2140 // shared objects. Link against the right archive.
2141 const char *Lib = "libclang_rt.profile-";
2142 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2143 Args.hasArg(options::OPT_shared))
2144 Lib = "libclang_rt.profile-pic-";
2145
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002146 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
2147 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00002148 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00002149
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00002150 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00002151}
2152
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002153static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
Craig Topperbf3e3272014-08-30 16:55:52 +00002154 StringRef Sanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002155 bool Shared) {
2156 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
2157 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
2158 const char *EnvSuffix =
2159 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002160 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
2161 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002162 Twine("libclang_rt.") + Sanitizer + "-" +
2163 getArchNameForCompilerRTLib(TC) + EnvSuffix +
2164 (Shared ? ".so" : ".a"));
2165 return LibSanitizer;
2166}
2167
Alexey Samsonov52550342014-09-15 19:58:40 +00002168static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2169 ArgStringList &CmdArgs, StringRef Sanitizer,
2170 bool IsShared) {
2171 SmallString<128> LibSanitizer = getSanitizerRTLibName(TC, Sanitizer, IsShared);
2172 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002173 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002174 if (!IsShared)
2175 CmdArgs.push_back("-whole-archive");
2176 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
2177 if (!IsShared)
2178 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002179}
2180
Alexey Samsonov52550342014-09-15 19:58:40 +00002181// Tries to use a file with the list of dynamic symbols that need to be exported
2182// from the runtime library. Returns true if the file was found.
2183static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2184 ArgStringList &CmdArgs,
2185 StringRef Sanitizer) {
2186 SmallString<128> LibSanitizer = getSanitizerRTLibName(TC, Sanitizer, false);
2187 if (llvm::sys::fs::exists(LibSanitizer + ".syms")) {
2188 CmdArgs.push_back(
2189 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
2190 return true;
2191 }
2192 return false;
2193}
2194
2195static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2196 ArgStringList &CmdArgs) {
2197 // Force linking against the system libraries sanitizers depends on
2198 // (see PR15823 why this is necessary).
2199 CmdArgs.push_back("--no-as-needed");
2200 CmdArgs.push_back("-lpthread");
2201 CmdArgs.push_back("-lrt");
2202 CmdArgs.push_back("-lm");
2203 // There's no libdl on FreeBSD.
2204 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2205 CmdArgs.push_back("-ldl");
2206}
2207
2208static void
2209collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2210 SmallVectorImpl<StringRef> &SharedRuntimes,
2211 SmallVectorImpl<StringRef> &StaticRuntimes,
2212 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2213 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2214 // Collect shared runtimes.
2215 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2216 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002217 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002218
Alexey Samsonov52550342014-09-15 19:58:40 +00002219 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002220 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002221 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2222 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002223 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002224 }
2225 if (SanArgs.needsAsanRt()) {
2226 if (SanArgs.needsSharedAsanRt()) {
2227 HelperStaticRuntimes.push_back("asan-preinit");
2228 } else {
2229 StaticRuntimes.push_back("asan");
2230 if (SanArgs.linkCXXRuntimes())
2231 StaticRuntimes.push_back("asan_cxx");
2232 }
2233 }
2234 if (SanArgs.needsDfsanRt())
2235 StaticRuntimes.push_back("dfsan");
2236 if (SanArgs.needsLsanRt())
2237 StaticRuntimes.push_back("lsan");
2238 if (SanArgs.needsMsanRt())
2239 StaticRuntimes.push_back("msan");
2240 if (SanArgs.needsTsanRt())
2241 StaticRuntimes.push_back("tsan");
2242 // WARNING: UBSan should always go last.
2243 if (SanArgs.needsUbsanRt()) {
2244 // If UBSan is not combined with another sanitizer, we need to pull in
2245 // sanitizer_common explicitly.
2246 if (StaticRuntimes.empty())
2247 HelperStaticRuntimes.push_back("san");
2248 StaticRuntimes.push_back("ubsan");
2249 if (SanArgs.linkCXXRuntimes())
2250 StaticRuntimes.push_back("ubsan_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002251 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002252}
2253
Alexey Samsonov52550342014-09-15 19:58:40 +00002254// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2255// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2256static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002257 ArgStringList &CmdArgs) {
Alexey Samsonov58ae9ae2014-09-26 21:22:08 +00002258 // Don't link in any sanitizer runtimes if we have no system libraries.
2259 if (Args.hasArg(options::OPT_nostdlib) ||
2260 Args.hasArg(options::OPT_nodefaultlibs))
2261 return false;
Alexey Samsonov52550342014-09-15 19:58:40 +00002262 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2263 HelperStaticRuntimes;
2264 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2265 HelperStaticRuntimes);
2266 for (auto RT : SharedRuntimes)
2267 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2268 for (auto RT : HelperStaticRuntimes)
2269 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2270 bool AddExportDynamic = false;
2271 for (auto RT : StaticRuntimes) {
2272 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2273 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2274 }
2275 // If there is a static runtime with no dynamic list, force all the symbols
2276 // to be dynamic to be sure we export sanitizer interface functions.
2277 if (AddExportDynamic)
2278 CmdArgs.push_back("-export-dynamic");
2279 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002280}
2281
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002282static bool shouldUseFramePointerForTarget(const ArgList &Args,
2283 const llvm::Triple &Triple) {
2284 switch (Triple.getArch()) {
2285 // Don't use a frame pointer on linux if optimizing for certain targets.
2286 case llvm::Triple::mips64:
2287 case llvm::Triple::mips64el:
2288 case llvm::Triple::mips:
2289 case llvm::Triple::mipsel:
2290 case llvm::Triple::systemz:
2291 case llvm::Triple::x86:
2292 case llvm::Triple::x86_64:
2293 if (Triple.isOSLinux())
2294 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2295 if (!A->getOption().matches(options::OPT_O0))
2296 return false;
2297 return true;
2298 case llvm::Triple::xcore:
2299 return false;
2300 default:
2301 return true;
2302 }
2303}
2304
Rafael Espindola224dd632011-12-14 21:02:23 +00002305static bool shouldUseFramePointer(const ArgList &Args,
2306 const llvm::Triple &Triple) {
2307 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2308 options::OPT_fomit_frame_pointer))
2309 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2310
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002311 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002312}
2313
Eric Christopherb7d97e92013-04-03 01:58:53 +00002314static bool shouldUseLeafFramePointer(const ArgList &Args,
2315 const llvm::Triple &Triple) {
2316 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2317 options::OPT_momit_leaf_frame_pointer))
2318 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2319
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002320 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002321}
2322
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002323/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002324static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002325 SmallString<128> cwd;
2326 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002327 CmdArgs.push_back("-fdebug-compilation-dir");
2328 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002329 }
2330}
2331
Eric Christopherd3804002013-02-22 20:12:52 +00002332static const char *SplitDebugName(const ArgList &Args,
2333 const InputInfoList &Inputs) {
2334 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2335 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2336 SmallString<128> T(FinalOutput->getValue());
2337 llvm::sys::path::replace_extension(T, "dwo");
2338 return Args.MakeArgString(T);
2339 } else {
2340 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002341 SmallString<128> T(
2342 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002343 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2344 llvm::sys::path::replace_extension(F, "dwo");
2345 T += F;
2346 return Args.MakeArgString(F);
2347 }
2348}
2349
2350static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2351 const Tool &T, const JobAction &JA,
2352 const ArgList &Args, const InputInfo &Output,
2353 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002354 ArgStringList ExtractArgs;
2355 ExtractArgs.push_back("--extract-dwo");
2356
2357 ArgStringList StripArgs;
2358 StripArgs.push_back("--strip-dwo");
2359
2360 // Grabbing the output of the earlier compile step.
2361 StripArgs.push_back(Output.getFilename());
2362 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002363 ExtractArgs.push_back(OutFile);
2364
2365 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002366 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002367
2368 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002369 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002370
2371 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002372 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002373}
2374
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002375/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002376/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2377static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002378 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002379 if (A->getOption().matches(options::OPT_O4) ||
2380 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002381 return true;
2382
2383 if (A->getOption().matches(options::OPT_O0))
2384 return false;
2385
2386 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2387
Rafael Espindola91780de2013-08-26 14:05:41 +00002388 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002389 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002390 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002391 return true;
2392
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002393 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002394 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002395 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002396
2397 unsigned OptLevel = 0;
2398 if (S.getAsInteger(10, OptLevel))
2399 return false;
2400
2401 return OptLevel > 1;
2402 }
2403
2404 return false;
2405}
2406
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002407/// Add -x lang to \p CmdArgs for \p Input.
2408static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2409 ArgStringList &CmdArgs) {
2410 // When using -verify-pch, we don't want to provide the type
2411 // 'precompiled-header' if it was inferred from the file extension
2412 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2413 return;
2414
2415 CmdArgs.push_back("-x");
2416 if (Args.hasArg(options::OPT_rewrite_objc))
2417 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2418 else
2419 CmdArgs.push_back(types::getTypeName(Input.getType()));
2420}
2421
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002422static std::string getMSCompatibilityVersion(const char *VersionStr) {
2423 unsigned Version;
2424 if (StringRef(VersionStr).getAsInteger(10, Version))
2425 return "0";
2426
2427 if (Version < 100)
2428 return llvm::utostr_32(Version) + ".0";
2429
2430 if (Version < 10000)
2431 return llvm::utostr_32(Version / 100) + "." +
2432 llvm::utostr_32(Version % 100);
2433
2434 unsigned Build = 0, Factor = 1;
2435 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2436 Build = Build + (Version % 10) * Factor;
2437 return llvm::utostr_32(Version / 100) + "." +
2438 llvm::utostr_32(Version % 100) + "." +
2439 llvm::utostr_32(Build);
2440}
2441
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002442void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002443 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002444 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002445 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002446 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002447 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2448 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002449 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002450 ArgStringList CmdArgs;
2451
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002452 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002453 bool IsWindowsCygnus =
2454 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002455 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2456
Daniel Dunbare521a892009-03-31 20:53:55 +00002457 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2458
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002459 // Invoke ourselves in -cc1 mode.
2460 //
2461 // FIXME: Implement custom jobs for internal actions.
2462 CmdArgs.push_back("-cc1");
2463
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002464 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002465 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002466 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002467 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002468
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002469 const llvm::Triple TT(TripleStr);
2470 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2471 TT.getArch() == llvm::Triple::thumb)) {
2472 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2473 unsigned Version;
2474 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2475 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002476 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2477 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002478 }
2479
Tim Northover336f1892014-03-29 13:16:12 +00002480 // Push all default warning arguments that are specific to
2481 // the given target. These come before user provided warning options
2482 // are provided.
2483 getToolChain().addClangWarningOptions(CmdArgs);
2484
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002485 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002486 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002487
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002488 if (isa<AnalyzeJobAction>(JA)) {
2489 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2490 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002491 } else if (isa<MigrateJobAction>(JA)) {
2492 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002493 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002494 if (Output.getType() == types::TY_Dependencies)
2495 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002496 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002497 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002498 if (Args.hasArg(options::OPT_rewrite_objc) &&
2499 !Args.hasArg(options::OPT_g_Group))
2500 CmdArgs.push_back("-P");
2501 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002502 } else if (isa<AssembleJobAction>(JA)) {
2503 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002504
David Blaikie9260ed62013-07-25 21:19:01 +00002505 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002506
2507 // Also ignore explicit -force_cpusubtype_ALL option.
2508 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002509 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002510 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002511 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002512
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002513 if (JA.getType() == types::TY_Nothing)
2514 CmdArgs.push_back("-fsyntax-only");
2515 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002516 CmdArgs.push_back("-emit-pch");
2517 else
2518 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002519 } else if (isa<VerifyPCHJobAction>(JA)) {
2520 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002521 } else {
2522 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002523
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002524 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002525 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002526 } else if (JA.getType() == types::TY_LLVM_IR ||
2527 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002528 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002529 } else if (JA.getType() == types::TY_LLVM_BC ||
2530 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002531 CmdArgs.push_back("-emit-llvm-bc");
2532 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002533 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002534 } else if (JA.getType() == types::TY_AST) {
2535 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002536 } else if (JA.getType() == types::TY_ModuleFile) {
2537 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002538 } else if (JA.getType() == types::TY_RewrittenObjC) {
2539 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002540 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002541 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2542 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002543 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002544 } else {
2545 assert(JA.getType() == types::TY_PP_Asm &&
2546 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002547 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002548 }
2549
Justin Bognera88f0122014-06-20 22:59:50 +00002550 // We normally speed up the clang process a bit by skipping destructors at
2551 // exit, but when we're generating diagnostics we can rely on some of the
2552 // cleanup.
2553 if (!C.isForDiagnostics())
2554 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002555
John McCallbb79b5f2010-02-13 03:50:24 +00002556 // Disable the verification pass in -asserts builds.
2557#ifdef NDEBUG
2558 CmdArgs.push_back("-disable-llvm-verifier");
2559#endif
2560
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002561 // Set the main file name, so that debug info works even with
2562 // -save-temps.
2563 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002564 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002565
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002566 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002567 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002568 if (Args.hasArg(options::OPT_static))
2569 CmdArgs.push_back("-static-define");
2570
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002571 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002572 // Enable region store model by default.
2573 CmdArgs.push_back("-analyzer-store=region");
2574
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002575 // Treat blocks as analysis entry points.
2576 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2577
Ted Kremenek49c79792011-03-24 00:28:47 +00002578 CmdArgs.push_back("-analyzer-eagerly-assume");
2579
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002580 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002581 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002582 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002583
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002584 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002585 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002586
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002587 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002588 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002589
2590 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002591
Jordan Rose10ad0812013-04-05 17:55:07 +00002592 if (types::isCXX(Inputs[0].getType()))
2593 CmdArgs.push_back("-analyzer-checker=cplusplus");
2594
Nico Webere8e53112014-05-11 01:04:02 +00002595 // Enable the following experimental checkers for testing.
2596 CmdArgs.push_back(
2597 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002598 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2599 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2600 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2601 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2602 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002603 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002604
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002605 // Set the output format. The default is plist, for (lame) historical
2606 // reasons.
2607 CmdArgs.push_back("-analyzer-output");
2608 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002609 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002610 else
2611 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002612
Ted Kremenekfe449a22010-03-22 22:32:05 +00002613 // Disable the presentation of standard compiler warnings when
2614 // using --analyze. We only want to show static analyzer diagnostics
2615 // or frontend errors.
2616 CmdArgs.push_back("-w");
2617
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002618 // Add -Xanalyzer arguments when running as analyzer.
2619 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002620 }
2621
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002622 CheckCodeGenerationOptions(D, Args);
2623
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002624 bool PIE = getToolChain().isPIEDefault();
2625 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002626 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002627
Alexey Bataev40e75222014-01-28 06:30:35 +00002628 // Android-specific defaults for PIC/PIE
2629 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2630 switch (getToolChain().getTriple().getArch()) {
2631 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002632 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002633 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002634 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002635 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002636 case llvm::Triple::mips:
2637 case llvm::Triple::mipsel:
2638 case llvm::Triple::mips64:
2639 case llvm::Triple::mips64el:
2640 PIC = true; // "-fpic"
2641 break;
2642
2643 case llvm::Triple::x86:
2644 case llvm::Triple::x86_64:
2645 PIC = true; // "-fPIC"
2646 IsPICLevelTwo = true;
2647 break;
2648
2649 default:
2650 break;
2651 }
2652 }
2653
Brad Smith5b05db82014-06-24 19:51:29 +00002654 // OpenBSD-specific defaults for PIE
2655 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2656 switch (getToolChain().getTriple().getArch()) {
2657 case llvm::Triple::mips64:
2658 case llvm::Triple::mips64el:
2659 case llvm::Triple::sparc:
2660 case llvm::Triple::x86:
2661 case llvm::Triple::x86_64:
2662 IsPICLevelTwo = false; // "-fpie"
2663 break;
2664
2665 case llvm::Triple::ppc:
2666 case llvm::Triple::sparcv9:
2667 IsPICLevelTwo = true; // "-fPIE"
2668 break;
2669
2670 default:
2671 break;
2672 }
2673 }
2674
Alexey Samsonov090301e2013-04-09 12:28:19 +00002675 // For the PIC and PIE flag options, this logic is different from the
2676 // legacy logic in very old versions of GCC, as that logic was just
2677 // a bug no one had ever fixed. This logic is both more rational and
2678 // consistent with GCC's new logic now that the bugs are fixed. The last
2679 // argument relating to either PIC or PIE wins, and no other argument is
2680 // used. If the last argument is any flavor of the '-fno-...' arguments,
2681 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2682 // at the same level.
2683 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2684 options::OPT_fpic, options::OPT_fno_pic,
2685 options::OPT_fPIE, options::OPT_fno_PIE,
2686 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002687 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2688 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002689 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002690 if (LastPICArg) {
2691 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002692 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2693 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2694 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2695 PIC = PIE || O.matches(options::OPT_fPIC) ||
2696 O.matches(options::OPT_fpic);
2697 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2698 O.matches(options::OPT_fPIC);
2699 } else {
2700 PIE = PIC = false;
2701 }
2702 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002703 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002704
Nick Lewycky609dd662013-10-11 03:33:53 +00002705 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002706 // specified while enabling PIC enabled level 1 PIC, just force it back to
2707 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2708 // informal testing).
2709 if (PIC && getToolChain().getTriple().isOSDarwin())
2710 IsPICLevelTwo |= getToolChain().isPICDefault();
2711
Chandler Carruthc0c04552012-04-08 16:40:35 +00002712 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2713 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002714 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002715 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002716 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002717 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002718 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002719 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002720
Chandler Carruth76a943b2012-11-19 03:52:03 +00002721 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2722 // This is a very special mode. It trumps the other modes, almost no one
2723 // uses it, and it isn't even valid on any OS but Darwin.
2724 if (!getToolChain().getTriple().isOSDarwin())
2725 D.Diag(diag::err_drv_unsupported_opt_for_target)
2726 << A->getSpelling() << getToolChain().getTriple().str();
2727
2728 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2729
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002730 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002731 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002732
Chandler Carruth76a943b2012-11-19 03:52:03 +00002733 // Only a forced PIC mode can cause the actual compile to have PIC defines
2734 // etc., no flags are sufficient. This behavior was selected to closely
2735 // match that of llvm-gcc and Apple GCC before that.
2736 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2737 CmdArgs.push_back("-pic-level");
2738 CmdArgs.push_back("2");
2739 }
2740 } else {
2741 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2742 // handled in Clang's IRGen by the -pie-level flag.
2743 CmdArgs.push_back("-mrelocation-model");
2744 CmdArgs.push_back(PIC ? "pic" : "static");
2745
2746 if (PIC) {
2747 CmdArgs.push_back("-pic-level");
2748 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2749 if (PIE) {
2750 CmdArgs.push_back("-pie-level");
2751 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2752 }
2753 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002754 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002755
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002756 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2757 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002758 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002759
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002760 // LLVM Code Generator Options.
2761
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002762 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2763 StringRef v = A->getValue();
2764 CmdArgs.push_back("-mllvm");
2765 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2766 A->claim();
2767 }
2768
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002769 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2770 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002771 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002772 }
2773
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002774 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2775 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002776 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002777 D.Diag(diag::err_drv_unsupported_opt_for_target)
2778 << A->getSpelling() << getToolChain().getTriple().str();
2779 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2780 CmdArgs.push_back("-fpcc-struct-return");
2781 } else {
2782 assert(A->getOption().matches(options::OPT_freg_struct_return));
2783 CmdArgs.push_back("-freg-struct-return");
2784 }
2785 }
2786
Roman Divacky65b88cd2011-03-01 17:40:53 +00002787 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2788 CmdArgs.push_back("-mrtd");
2789
Rafael Espindola224dd632011-12-14 21:02:23 +00002790 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002791 CmdArgs.push_back("-mdisable-fp-elim");
2792 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2793 options::OPT_fno_zero_initialized_in_bss))
2794 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002795
2796 bool OFastEnabled = isOptimizationLevelFast(Args);
2797 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2798 // enabled. This alias option is being used to simplify the hasFlag logic.
2799 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2800 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002801 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2802 // doesn't do any TBAA.
2803 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002804 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002805 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002806 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002807 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2808 options::OPT_fno_struct_path_tbaa))
2809 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002810 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2811 false))
2812 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002813 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2814 options::OPT_fno_optimize_sibling_calls))
2815 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002816
Eric Christopher006208c2013-04-04 06:29:47 +00002817 // Handle segmented stacks.
2818 if (Args.hasArg(options::OPT_fsplit_stack))
2819 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002820
2821 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2822 // This alias option is being used to simplify the getLastArg logic.
2823 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2824 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002825
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002826 // Handle various floating point optimization flags, mapping them to the
2827 // appropriate LLVM code generation flags. The pattern for all of these is to
2828 // default off the codegen optimizations, and if any flag enables them and no
2829 // flag disables them after the flag enabling them, enable the codegen
2830 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002831 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002832 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002833 options::OPT_ffinite_math_only,
2834 options::OPT_fno_finite_math_only,
2835 options::OPT_fhonor_infinities,
2836 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002837 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2838 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002839 A->getOption().getID() != options::OPT_fhonor_infinities)
2840 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002841 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002842 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002843 options::OPT_ffinite_math_only,
2844 options::OPT_fno_finite_math_only,
2845 options::OPT_fhonor_nans,
2846 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002847 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2848 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002849 A->getOption().getID() != options::OPT_fhonor_nans)
2850 CmdArgs.push_back("-menable-no-nans");
2851
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002852 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2853 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002854 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002855 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002856 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002857 options::OPT_fno_math_errno)) {
2858 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2859 // However, turning *off* -ffast_math merely restores the toolchain default
2860 // (which may be false).
2861 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2862 A->getOption().getID() == options::OPT_ffast_math ||
2863 A->getOption().getID() == options::OPT_Ofast)
2864 MathErrno = false;
2865 else if (A->getOption().getID() == options::OPT_fmath_errno)
2866 MathErrno = true;
2867 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002868 if (MathErrno)
2869 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002870
2871 // There are several flags which require disabling very specific
2872 // optimizations. Any of these being disabled forces us to turn off the
2873 // entire set of LLVM optimizations, so collect them through all the flag
2874 // madness.
2875 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002876 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002877 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002878 options::OPT_funsafe_math_optimizations,
2879 options::OPT_fno_unsafe_math_optimizations,
2880 options::OPT_fassociative_math,
2881 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002882 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2883 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002884 A->getOption().getID() != options::OPT_fno_associative_math)
2885 AssociativeMath = true;
2886 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002887 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002888 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002889 options::OPT_funsafe_math_optimizations,
2890 options::OPT_fno_unsafe_math_optimizations,
2891 options::OPT_freciprocal_math,
2892 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002893 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2894 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002895 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2896 ReciprocalMath = true;
2897 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002898 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002899 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002900 options::OPT_funsafe_math_optimizations,
2901 options::OPT_fno_unsafe_math_optimizations,
2902 options::OPT_fsigned_zeros,
2903 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002904 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2905 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002906 A->getOption().getID() != options::OPT_fsigned_zeros)
2907 SignedZeros = false;
2908 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002909 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002910 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002911 options::OPT_funsafe_math_optimizations,
2912 options::OPT_fno_unsafe_math_optimizations,
2913 options::OPT_ftrapping_math,
2914 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002915 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2916 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002917 A->getOption().getID() != options::OPT_ftrapping_math)
2918 TrappingMath = false;
2919 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2920 !TrappingMath)
2921 CmdArgs.push_back("-menable-unsafe-fp-math");
2922
Lang Hamesaa53b932012-07-06 00:59:19 +00002923
2924 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002925 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002926 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002927 options::OPT_ffp_contract)) {
2928 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002929 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002930 if (Val == "fast" || Val == "on" || Val == "off") {
2931 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2932 } else {
2933 D.Diag(diag::err_drv_unsupported_option_argument)
2934 << A->getOption().getName() << Val;
2935 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002936 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2937 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002938 // If fast-math is set then set the fp-contract mode to fast.
2939 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2940 }
2941 }
2942
Bob Wilson6a039162012-07-19 03:52:53 +00002943 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2944 // and if we find them, tell the frontend to provide the appropriate
2945 // preprocessor macros. This is distinct from enabling any optimizations as
2946 // these options induce language changes which must survive serialization
2947 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002948 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2949 options::OPT_fno_fast_math))
2950 if (!A->getOption().matches(options::OPT_fno_fast_math))
2951 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002952 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2953 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002954 if (A->getOption().matches(options::OPT_ffinite_math_only))
2955 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002956
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002957 // Decide whether to use verbose asm. Verbose assembly is the default on
2958 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002959 bool IsIntegratedAssemblerDefault =
2960 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002961 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002962 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002963 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002964 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002965
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002966 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002967 IsIntegratedAssemblerDefault))
2968 CmdArgs.push_back("-no-integrated-as");
2969
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002970 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2971 CmdArgs.push_back("-mdebug-pass");
2972 CmdArgs.push_back("Structure");
2973 }
2974 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2975 CmdArgs.push_back("-mdebug-pass");
2976 CmdArgs.push_back("Arguments");
2977 }
2978
John McCall8517abc2010-02-19 02:45:38 +00002979 // Enable -mconstructor-aliases except on darwin, where we have to
2980 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002981 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002982 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002983
John McCall7ef5cb32011-03-18 02:56:14 +00002984 // Darwin's kernel doesn't support guard variables; just die if we
2985 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002986 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002987 CmdArgs.push_back("-fforbid-guard-variables");
2988
Douglas Gregordbe39272011-02-01 15:15:22 +00002989 if (Args.hasArg(options::OPT_mms_bitfields)) {
2990 CmdArgs.push_back("-mms-bitfields");
2991 }
John McCall8517abc2010-02-19 02:45:38 +00002992
Daniel Dunbar306945d2009-09-16 06:17:29 +00002993 // This is a coarse approximation of what llvm-gcc actually does, both
2994 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2995 // complicated ways.
2996 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002997 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2998 options::OPT_fno_asynchronous_unwind_tables,
2999 (getToolChain().IsUnwindTablesDefault() ||
3000 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3001 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003002 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3003 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003004 CmdArgs.push_back("-munwind-tables");
3005
Chandler Carruth05fb5852012-11-21 23:40:23 +00003006 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003007
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003008 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3009 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003010 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003011 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003012
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003013 // FIXME: Handle -mtune=.
3014 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003015
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003016 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003017 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003018 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003019 }
3020
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003021 // Add the target cpu
3022 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3023 llvm::Triple ETriple(ETripleStr);
3024 std::string CPU = getCPUName(Args, ETriple);
3025 if (!CPU.empty()) {
3026 CmdArgs.push_back("-target-cpu");
3027 CmdArgs.push_back(Args.MakeArgString(CPU));
3028 }
3029
Rafael Espindolaeb265472013-08-21 21:59:03 +00003030 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3031 CmdArgs.push_back("-mfpmath");
3032 CmdArgs.push_back(A->getValue());
3033 }
3034
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003035 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003036 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003037
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003038 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003039 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003040 default:
3041 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003042
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003043 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003044 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003045 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003046 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003047 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003048 break;
3049
Tim Northover573cbee2014-05-24 12:52:07 +00003050 case llvm::Triple::aarch64:
3051 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003052 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003053 break;
3054
Eric Christopher0b26a612010-03-02 02:41:08 +00003055 case llvm::Triple::mips:
3056 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003057 case llvm::Triple::mips64:
3058 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003059 AddMIPSTargetArgs(Args, CmdArgs);
3060 break;
3061
Ulrich Weigand8afad612014-07-28 13:17:52 +00003062 case llvm::Triple::ppc:
3063 case llvm::Triple::ppc64:
3064 case llvm::Triple::ppc64le:
3065 AddPPCTargetArgs(Args, CmdArgs);
3066 break;
3067
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003068 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003069 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003070 AddSparcTargetArgs(Args, CmdArgs);
3071 break;
3072
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003073 case llvm::Triple::x86:
3074 case llvm::Triple::x86_64:
3075 AddX86TargetArgs(Args, CmdArgs);
3076 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003077
3078 case llvm::Triple::hexagon:
3079 AddHexagonTargetArgs(Args, CmdArgs);
3080 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003081 }
3082
Hans Wennborg75958c42013-08-08 00:17:41 +00003083 // Add clang-cl arguments.
3084 if (getToolChain().getDriver().IsCLMode())
3085 AddClangCLArgs(Args, CmdArgs);
3086
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003087 // Pass the linker version in use.
3088 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3089 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003090 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003091 }
3092
Eric Christopherb7d97e92013-04-03 01:58:53 +00003093 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003094 CmdArgs.push_back("-momit-leaf-frame-pointer");
3095
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003096 // Explicitly error on some things we know we don't support and can't just
3097 // ignore.
3098 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003099 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3100 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003101 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003102 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003103 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003104 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3105 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003106 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003107 << Unsupported->getOption().getName();
3108 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003109 }
3110
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003111 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003112 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003113 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003114 CmdArgs.push_back("-header-include-file");
3115 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3116 D.CCPrintHeadersFilename : "-");
3117 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003118 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003119 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003120
Chad Rosierbe10f982011-08-02 17:58:04 +00003121 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003122 CmdArgs.push_back("-diagnostic-log-file");
3123 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3124 D.CCLogDiagnosticsFilename : "-");
3125 }
3126
Manman Ren17bdb0f2013-11-20 20:22:14 +00003127 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3128 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003129 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003130 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00003131 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003132 // FIXME: we should support specifying dwarf version with
3133 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003134 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00003135 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
3136 const llvm::Triple &Triple = getToolChain().getTriple();
3137 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3138 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003139 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003140 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003141 CmdArgs.push_back("-gdwarf-2");
3142 else if (A->getOption().matches(options::OPT_gdwarf_3))
3143 CmdArgs.push_back("-gdwarf-3");
3144 else if (A->getOption().matches(options::OPT_gdwarf_4))
3145 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003146 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003147 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00003148 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
3149 const llvm::Triple &Triple = getToolChain().getTriple();
3150 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3151 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003152 CmdArgs.push_back("-gdwarf-2");
3153 else
3154 CmdArgs.push_back("-g");
3155 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003156 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003157
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003158 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3159 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003160 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3161 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003162 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003163
Eric Christopher138c32b2013-09-13 22:37:55 +00003164 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003165 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3166 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003167 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003168 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003169 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003170 CmdArgs.push_back("-g");
3171 CmdArgs.push_back("-backend-option");
3172 CmdArgs.push_back("-split-dwarf=Enable");
3173 }
3174
Eric Christopher138c32b2013-09-13 22:37:55 +00003175 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3176 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3177 CmdArgs.push_back("-backend-option");
3178 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3179 }
Eric Christophereec89c22013-06-18 00:03:50 +00003180
Eric Christopher0d403d22014-02-14 01:27:03 +00003181 // -gdwarf-aranges turns on the emission of the aranges section in the
3182 // backend.
3183 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3184 CmdArgs.push_back("-backend-option");
3185 CmdArgs.push_back("-generate-arange-section");
3186 }
3187
David Blaikief36d9ba2014-01-27 18:52:43 +00003188 if (Args.hasFlag(options::OPT_fdebug_types_section,
3189 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003190 CmdArgs.push_back("-backend-option");
3191 CmdArgs.push_back("-generate-type-units");
3192 }
Eric Christophereec89c22013-06-18 00:03:50 +00003193
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003194 if (Args.hasFlag(options::OPT_ffunction_sections,
3195 options::OPT_fno_function_sections, false)) {
3196 CmdArgs.push_back("-ffunction-sections");
3197 }
3198
3199 if (Args.hasFlag(options::OPT_fdata_sections,
3200 options::OPT_fno_data_sections, false)) {
3201 CmdArgs.push_back("-fdata-sections");
3202 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003203
Chris Lattner3c77a352010-06-22 00:03:40 +00003204 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3205
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003206 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3207 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3208 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3209 D.Diag(diag::err_drv_argument_not_allowed_with)
3210 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3211
3212 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3213
3214 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3215 A->render(Args, CmdArgs);
3216 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3217 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3218
Nick Lewycky207bce32011-04-21 23:44:07 +00003219 if (Args.hasArg(options::OPT_ftest_coverage) ||
3220 Args.hasArg(options::OPT_coverage))
3221 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003222 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3223 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003224 Args.hasArg(options::OPT_coverage))
3225 CmdArgs.push_back("-femit-coverage-data");
3226
Alex Lorenzee024992014-08-04 18:41:51 +00003227 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
3228 !Args.hasArg(options::OPT_fprofile_instr_generate))
3229 D.Diag(diag::err_drv_argument_only_allowed_with)
3230 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3231
3232 if (Args.hasArg(options::OPT_fcoverage_mapping))
3233 CmdArgs.push_back("-fcoverage-mapping");
3234
Nick Lewycky480cb992011-05-04 20:46:58 +00003235 if (C.getArgs().hasArg(options::OPT_c) ||
3236 C.getArgs().hasArg(options::OPT_S)) {
3237 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003238 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00003239 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00003240 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003241 SmallString<128> Pwd;
3242 if (!llvm::sys::fs::current_path(Pwd)) {
3243 llvm::sys::path::append(Pwd, CoverageFilename.str());
3244 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003245 }
3246 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003247 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003248 }
3249 }
3250
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003251 // Pass options for controlling the default header search paths.
3252 if (Args.hasArg(options::OPT_nostdinc)) {
3253 CmdArgs.push_back("-nostdsysteminc");
3254 CmdArgs.push_back("-nobuiltininc");
3255 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003256 if (Args.hasArg(options::OPT_nostdlibinc))
3257 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003258 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3259 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3260 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003261
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003262 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003263 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003264 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003265
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003266 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3267
Ted Kremenekf7639e12012-03-06 20:06:33 +00003268 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003269 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003270 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003271 options::OPT_ccc_arcmt_modify,
3272 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003273 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003274 switch (A->getOption().getID()) {
3275 default:
3276 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003277 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003278 CmdArgs.push_back("-arcmt-check");
3279 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003280 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003281 CmdArgs.push_back("-arcmt-modify");
3282 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003283 case options::OPT_ccc_arcmt_migrate:
3284 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003285 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003286 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003287
3288 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3289 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003290 break;
John McCalld70fb982011-06-15 23:25:17 +00003291 }
3292 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003293 } else {
3294 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3295 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3296 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003297 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003298
Ted Kremenekf7639e12012-03-06 20:06:33 +00003299 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3300 if (ARCMTEnabled) {
3301 D.Diag(diag::err_drv_argument_not_allowed_with)
3302 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3303 }
3304 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003305 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003306
3307 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003308 options::OPT_objcmt_migrate_subscripting,
3309 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003310 // None specified, means enable them all.
3311 CmdArgs.push_back("-objcmt-migrate-literals");
3312 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003313 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003314 } else {
3315 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3316 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003317 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003318 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003319 } else {
3320 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3321 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3322 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3323 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3324 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3325 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3326 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3327 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3328 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3329 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3330 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3331 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3332 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003333 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003334 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003335 }
3336
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003337 // Add preprocessing options like -I, -D, etc. if we are using the
3338 // preprocessor.
3339 //
3340 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003341 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003342 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003343
Rafael Espindolaa7431922011-07-21 23:40:37 +00003344 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3345 // that "The compiler can only warn and ignore the option if not recognized".
3346 // When building with ccache, it will pass -D options to clang even on
3347 // preprocessed inputs and configure concludes that -fPIC is not supported.
3348 Args.ClaimAllArgs(options::OPT_D);
3349
Alp Toker7874bdc2013-11-15 20:40:58 +00003350 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003351 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3352 if (A->getOption().matches(options::OPT_O4)) {
3353 CmdArgs.push_back("-O3");
3354 D.Diag(diag::warn_O4_is_O3);
3355 } else {
3356 A->render(Args, CmdArgs);
3357 }
3358 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003359
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003360 // Warn about ignored options to clang.
3361 for (arg_iterator it = Args.filtered_begin(
3362 options::OPT_clang_ignored_gcc_optimization_f_Group),
3363 ie = Args.filtered_end(); it != ie; ++it) {
3364 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3365 }
3366
Chad Rosier86b82082012-12-12 20:06:31 +00003367 // Don't warn about unused -flto. This can happen when we're preprocessing or
3368 // precompiling.
3369 Args.ClaimAllArgs(options::OPT_flto);
3370
Richard Smith3be1cb22014-08-07 00:24:21 +00003371 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003372 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003373 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3374 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003375 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003376 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003377
3378 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003379 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003380 //
3381 // If a std is supplied, only add -trigraphs if it follows the
3382 // option.
3383 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3384 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003385 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003386 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003387 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003388 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003389 else
3390 Std->render(Args, CmdArgs);
3391
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003392 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3393 options::OPT_trigraphs))
3394 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003395 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003396 } else {
3397 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003398 //
3399 // FIXME: Clang doesn't correctly handle -std= when the input language
3400 // doesn't match. For the time being just ignore this for C++ inputs;
3401 // eventually we want to do all the standard defaulting here instead of
3402 // splitting it between the driver and clang -cc1.
3403 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003404 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3405 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003406 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003407 CmdArgs.push_back("-std=c++11");
3408
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003409 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003410 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003411
Richard Smith282b4492013-09-04 22:50:31 +00003412 // GCC's behavior for -Wwrite-strings is a bit strange:
3413 // * In C, this "warning flag" changes the types of string literals from
3414 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3415 // for the discarded qualifier.
3416 // * In C++, this is just a normal warning flag.
3417 //
3418 // Implementing this warning correctly in C is hard, so we follow GCC's
3419 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3420 // a non-const char* in C, rather than using this crude hack.
3421 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003422 // FIXME: This should behave just like a warning flag, and thus should also
3423 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3424 Arg *WriteStrings =
3425 Args.getLastArg(options::OPT_Wwrite_strings,
3426 options::OPT_Wno_write_strings, options::OPT_w);
3427 if (WriteStrings &&
3428 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003429 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003430 }
3431
Chandler Carruth61fbf622011-04-23 09:27:53 +00003432 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003433 // during C++ compilation, which it is by default. GCC keeps this define even
3434 // in the presence of '-w', match this behavior bug-for-bug.
3435 if (types::isCXX(InputType) &&
3436 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3437 true)) {
3438 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003439 }
3440
Chandler Carruthe0391482010-05-22 02:21:53 +00003441 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3442 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3443 if (Asm->getOption().matches(options::OPT_fasm))
3444 CmdArgs.push_back("-fgnu-keywords");
3445 else
3446 CmdArgs.push_back("-fno-gnu-keywords");
3447 }
3448
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003449 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3450 CmdArgs.push_back("-fno-dwarf-directory-asm");
3451
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003452 if (ShouldDisableAutolink(Args, getToolChain()))
3453 CmdArgs.push_back("-fno-autolink");
3454
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003455 // Add in -fdebug-compilation-dir if necessary.
3456 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003457
Richard Smith9a568822011-11-21 19:36:32 +00003458 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3459 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003460 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003461 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003462 }
3463
Richard Smith79c927b2013-11-06 19:31:51 +00003464 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3465 CmdArgs.push_back("-foperator-arrow-depth");
3466 CmdArgs.push_back(A->getValue());
3467 }
3468
Richard Smith9a568822011-11-21 19:36:32 +00003469 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3470 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003471 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003472 }
3473
Richard Smitha3d3bd22013-05-08 02:12:03 +00003474 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3475 CmdArgs.push_back("-fconstexpr-steps");
3476 CmdArgs.push_back(A->getValue());
3477 }
3478
Richard Smithb3a14522013-02-22 01:59:51 +00003479 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3480 CmdArgs.push_back("-fbracket-depth");
3481 CmdArgs.push_back(A->getValue());
3482 }
3483
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003484 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3485 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003486 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003487 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003488 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3489 } else
3490 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003491 }
3492
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003493
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003494 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003495 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003496
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003497 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3498 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003499 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003500 }
David Chisnall5778fce2009-08-31 16:41:57 +00003501
Chris Lattnere23003d2010-01-09 21:54:33 +00003502 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3503 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003504 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003505 }
3506
Chris Lattnerb35583d2010-04-07 20:49:23 +00003507 CmdArgs.push_back("-ferror-limit");
3508 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003509 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003510 else
3511 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003512
Chandler Carrutha77a7272010-05-06 04:55:18 +00003513 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3514 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003515 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003516 }
3517
3518 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3519 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003520 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003521 }
3522
Richard Smithf6f003a2011-12-16 19:06:07 +00003523 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3524 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003525 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003526 }
3527
Daniel Dunbar2c978472009-11-04 06:24:47 +00003528 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003529 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003530 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003531 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003532 } else {
3533 // If -fmessage-length=N was not specified, determine whether this is a
3534 // terminal and, if so, implicitly define -fmessage-length appropriately.
3535 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003536 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003537 }
3538
John McCallb4a99d32013-02-19 01:57:35 +00003539 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3540 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3541 options::OPT_fvisibility_ms_compat)) {
3542 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3543 CmdArgs.push_back("-fvisibility");
3544 CmdArgs.push_back(A->getValue());
3545 } else {
3546 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3547 CmdArgs.push_back("-fvisibility");
3548 CmdArgs.push_back("hidden");
3549 CmdArgs.push_back("-ftype-visibility");
3550 CmdArgs.push_back("default");
3551 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003552 }
3553
Douglas Gregor08329632010-06-15 17:05:35 +00003554 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003555
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003556 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3557
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003558 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003559 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3560 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003561 CmdArgs.push_back("-ffreestanding");
3562
Daniel Dunbare357d562009-12-03 18:42:11 +00003563 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003564 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003565 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003566 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3567 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003568 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003569 // AltiVec language extensions aren't relevant for assembling.
3570 if (!isa<PreprocessJobAction>(JA) ||
3571 Output.getType() != types::TY_PP_Asm)
3572 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003573 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3574 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003575
Peter Collingbourne32701642013-11-01 18:16:25 +00003576 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3577 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003578
Will Dietz3676d562012-12-30 20:53:28 +00003579 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3580 options::OPT_fno_sanitize_recover,
3581 true))
3582 CmdArgs.push_back("-fno-sanitize-recover");
3583
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003584 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003585 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3586 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3587
Eric Christopher459d2712013-02-19 06:16:53 +00003588 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003589 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003590 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003591 getToolChain().getArch() == llvm::Triple::ppc64 ||
3592 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003593 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003594 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003595
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003596 if (getToolChain().SupportsProfiling())
3597 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003598
3599 // -flax-vector-conversions is default.
3600 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3601 options::OPT_fno_lax_vector_conversions))
3602 CmdArgs.push_back("-fno-lax-vector-conversions");
3603
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003604 if (Args.getLastArg(options::OPT_fapple_kext))
3605 CmdArgs.push_back("-fapple-kext");
3606
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003607 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003608 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003609 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003610 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3611 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003612
3613 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3614 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003615 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003616 }
3617
Bob Wilson14adb362012-02-03 06:27:22 +00003618 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003619
Chandler Carruth6e501032011-03-27 00:04:55 +00003620 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3621 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3622 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3623 options::OPT_fno_wrapv)) {
3624 if (A->getOption().matches(options::OPT_fwrapv))
3625 CmdArgs.push_back("-fwrapv");
3626 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3627 options::OPT_fno_strict_overflow)) {
3628 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3629 CmdArgs.push_back("-fwrapv");
3630 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003631
3632 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3633 options::OPT_fno_reroll_loops))
3634 if (A->getOption().matches(options::OPT_freroll_loops))
3635 CmdArgs.push_back("-freroll-loops");
3636
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003637 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003638 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3639 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003640
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003641 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3642
Mahesha S6a682be42012-10-27 07:47:56 +00003643
Daniel Dunbar4930e332009-11-17 08:07:36 +00003644 // -stack-protector=0 is default.
3645 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003646 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3647 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003648 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003649 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003650 if (A->getOption().matches(options::OPT_fstack_protector)) {
3651 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3652 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3653 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003654 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003655 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003656 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003657 } else {
3658 StackProtectorLevel =
3659 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3660 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003661 if (StackProtectorLevel) {
3662 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003663 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003664 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003665
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003666 // --param ssp-buffer-size=
3667 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3668 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003669 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003670 if (Str.startswith("ssp-buffer-size=")) {
3671 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003672 CmdArgs.push_back("-stack-protector-buffer-size");
3673 // FIXME: Verify the argument is a valid integer.
3674 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003675 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003676 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003677 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003678 }
3679
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003680 // Translate -mstackrealign
3681 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3682 false)) {
3683 CmdArgs.push_back("-backend-option");
3684 CmdArgs.push_back("-force-align-stack");
3685 }
3686 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3687 false)) {
3688 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3689 }
3690
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003691 if (Args.hasArg(options::OPT_mstack_alignment)) {
3692 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3693 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003694 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003695
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003696 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3697 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
3698 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3699
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003700 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3701 options::OPT_mno_restrict_it)) {
3702 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3703 CmdArgs.push_back("-backend-option");
3704 CmdArgs.push_back("-arm-restrict-it");
3705 } else {
3706 CmdArgs.push_back("-backend-option");
3707 CmdArgs.push_back("-arm-no-restrict-it");
3708 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003709 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3710 TT.getArch() == llvm::Triple::thumb)) {
3711 // Windows on ARM expects restricted IT blocks
3712 CmdArgs.push_back("-backend-option");
3713 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003714 }
3715
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003716 if (TT.getArch() == llvm::Triple::arm ||
3717 TT.getArch() == llvm::Triple::thumb) {
3718 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3719 options::OPT_mno_long_calls)) {
3720 if (A->getOption().matches(options::OPT_mlong_calls)) {
3721 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003722 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003723 }
3724 }
3725 }
3726
Daniel Dunbard18049a2009-04-07 21:16:11 +00003727 // Forward -f options with positive and negative forms; we translate
3728 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003729 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3730 StringRef fname = A->getValue();
3731 if (!llvm::sys::fs::exists(fname))
3732 D.Diag(diag::err_drv_no_such_file) << fname;
3733 else
3734 A->render(Args, CmdArgs);
3735 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003736
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003737 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003738 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003739 CmdArgs.push_back("-fapple-kext");
3740 if (!Args.hasArg(options::OPT_fbuiltin))
3741 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003742 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003743 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003744 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003745 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003746 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003747
Nuno Lopes13c88c72009-12-16 16:59:22 +00003748 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3749 options::OPT_fno_assume_sane_operator_new))
3750 CmdArgs.push_back("-fno-assume-sane-operator-new");
3751
Daniel Dunbar4930e332009-11-17 08:07:36 +00003752 // -fblocks=0 is default.
3753 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003754 getToolChain().IsBlocksDefault()) ||
3755 (Args.hasArg(options::OPT_fgnu_runtime) &&
3756 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3757 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003758 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003759
3760 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3761 !getToolChain().hasBlocksRuntime())
3762 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003763 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003764
Richard Smithffb65082014-09-30 23:10:19 +00003765 // -fmodules enables modules (off by default).
3766 // Users can pass -fno-cxx-modules to turn off modules support for
3767 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003768 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003769 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3770 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3771 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00003772 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003773 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003774 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003775 HaveModules = true;
3776 }
3777 }
3778
Daniel Jasper07e6c402013-08-05 20:26:17 +00003779 // -fmodule-maps enables module map processing (off by default) for header
3780 // checking. It is implied by -fmodules.
3781 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3782 false)) {
3783 CmdArgs.push_back("-fmodule-maps");
3784 }
3785
Daniel Jasperac42b752013-10-21 06:34:34 +00003786 // -fmodules-decluse checks that modules used are declared so (off by
3787 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003788 if (Args.hasFlag(options::OPT_fmodules_decluse,
3789 options::OPT_fno_modules_decluse,
3790 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003791 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003792 }
3793
Daniel Jasper962b38e2014-04-11 11:47:45 +00003794 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3795 // all #included headers are part of modules.
3796 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3797 options::OPT_fno_modules_strict_decluse,
3798 false)) {
3799 CmdArgs.push_back("-fmodules-strict-decluse");
3800 }
3801
Daniel Jasperac42b752013-10-21 06:34:34 +00003802 // -fmodule-name specifies the module that is currently being built (or
3803 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003804 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003805 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003806
3807 // -fmodule-map-file can be used to specify a file containing module
3808 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003809 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003810 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003811
Justin Bognera88f0122014-06-20 22:59:50 +00003812 // -fmodule-cache-path specifies where our module files should be written.
3813 SmallString<128> ModuleCachePath;
3814 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3815 ModuleCachePath = A->getValue();
3816 if (HaveModules) {
3817 if (C.isForDiagnostics()) {
3818 // When generating crash reports, we want to emit the modules along with
3819 // the reproduction sources, so we ignore any provided module path.
3820 ModuleCachePath = Output.getFilename();
3821 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3822 llvm::sys::path::append(ModuleCachePath, "modules");
3823 } else if (ModuleCachePath.empty()) {
3824 // No module path was provided: use the default.
3825 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3826 ModuleCachePath);
3827 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3828 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3829 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003830 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003831 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3832 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3833 }
3834
3835 // When building modules and generating crashdumps, we need to dump a module
3836 // dependency VFS alongside the output.
3837 if (HaveModules && C.isForDiagnostics()) {
3838 SmallString<128> VFSDir(Output.getFilename());
3839 llvm::sys::path::replace_extension(VFSDir, ".cache");
3840 llvm::sys::path::append(VFSDir, "vfs");
3841 CmdArgs.push_back("-module-dependency-dir");
3842 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003843 }
3844
Justin Bogner5443ad52014-06-20 21:12:53 +00003845 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3846 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003847 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003848
Douglas Gregor35b04d62013-02-07 19:01:24 +00003849 // Pass through all -fmodules-ignore-macro arguments.
3850 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003851 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3852 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003853
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003854 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3855
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003856 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3857 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3858 D.Diag(diag::err_drv_argument_not_allowed_with)
3859 << A->getAsString(Args) << "-fbuild-session-timestamp";
3860
3861 llvm::sys::fs::file_status Status;
3862 if (llvm::sys::fs::status(A->getValue(), Status))
3863 D.Diag(diag::err_drv_no_such_file) << A->getValue();
NAKAMURA Takumi0f9447d2014-08-03 01:11:44 +00003864 char TimeStamp[48];
3865 snprintf(TimeStamp, sizeof(TimeStamp), "-fbuild-session-timestamp=%" PRIu64,
3866 (uint64_t)Status.getLastModificationTime().toEpochTime());
3867 CmdArgs.push_back(Args.MakeArgString(TimeStamp));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003868 }
3869
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003870 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003871 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3872 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003873 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3874
3875 Args.AddLastArg(CmdArgs,
3876 options::OPT_fmodules_validate_once_per_build_session);
3877 }
3878
Ben Langmuirdcf73862014-03-12 00:06:17 +00003879 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3880
John McCalldfea9982010-04-09 19:12:06 +00003881 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003882 if (Args.hasFlag(options::OPT_fno_access_control,
3883 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003884 false))
John McCall3155f572010-04-09 19:03:51 +00003885 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003886
Anders Carlssond470fef2010-11-21 00:09:52 +00003887 // -felide-constructors is the default.
3888 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3889 options::OPT_felide_constructors,
3890 false))
3891 CmdArgs.push_back("-fno-elide-constructors");
3892
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003893 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003894 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003895 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003896 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003897
Richard Smith52be6192012-11-05 22:04:41 +00003898 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003899 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003900 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003901 Args.getLastArg(options::OPT_mkernel,
3902 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003903 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003904 D.Diag(diag::err_drv_argument_not_allowed_with)
3905 << "-fsanitize=vptr" << NoRttiArg;
3906 }
3907 }
3908
Tony Linthicum76329bf2011-12-12 21:14:55 +00003909 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003910 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003911 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003912 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003913 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003914 CmdArgs.push_back("-fshort-enums");
3915
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003916 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003917 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003918 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003919 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003920
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003921 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003922 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003923 options::OPT_fno_threadsafe_statics))
3924 CmdArgs.push_back("-fno-threadsafe-statics");
3925
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003926 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003927 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3928 options::OPT_fno_use_cxa_atexit,
3929 !IsWindowsCygnus && !IsWindowsGNU &&
3930 getToolChain().getArch() != llvm::Triple::hexagon &&
3931 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003932 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003933 CmdArgs.push_back("-fno-use-cxa-atexit");
3934
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003935 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003936 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003937 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003938 CmdArgs.push_back("-fms-extensions");
3939
Francois Pichet1b4f1632011-09-17 04:32:15 +00003940 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003941 if (Args.hasFlag(options::OPT_fms_compatibility,
3942 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003943 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3944 options::OPT_fno_ms_extensions,
3945 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003946 CmdArgs.push_back("-fms-compatibility");
3947
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003948 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003949 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003950 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3951 Args.hasArg(options::OPT_fms_compatibility_version)) {
3952 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3953 const Arg *MSCompatibilityVersion =
3954 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003955
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003956 if (MSCVersion && MSCompatibilityVersion)
3957 D.Diag(diag::err_drv_argument_not_allowed_with)
3958 << MSCVersion->getAsString(Args)
3959 << MSCompatibilityVersion->getAsString(Args);
3960
3961 std::string Ver;
3962 if (MSCompatibilityVersion)
3963 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
3964 else if (MSCVersion)
3965 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
3966
3967 if (Ver.empty())
3968 CmdArgs.push_back("-fms-compatibility-version=17.00");
3969 else
3970 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
3971 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003972
Eric Christopher5ecce122013-02-18 00:38:31 +00003973 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003974 if (Args.hasFlag(options::OPT_fborland_extensions,
3975 options::OPT_fno_borland_extensions, false))
3976 CmdArgs.push_back("-fborland-extensions");
3977
Francois Pichet02744872011-09-01 16:38:08 +00003978 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3979 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003980 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003981 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003982 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003983
Chandler Carruthe03aa552010-04-17 20:17:31 +00003984 // -fgnu-keywords default varies depending on language; only pass if
3985 // specified.
3986 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003987 options::OPT_fno_gnu_keywords))
3988 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003989
Rafael Espindola922a6242011-06-02 17:30:53 +00003990 if (Args.hasFlag(options::OPT_fgnu89_inline,
3991 options::OPT_fno_gnu89_inline,
3992 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003993 CmdArgs.push_back("-fgnu89-inline");
3994
Chad Rosier9c76d242012-03-15 22:31:42 +00003995 if (Args.hasArg(options::OPT_fno_inline))
3996 CmdArgs.push_back("-fno-inline");
3997
Chad Rosier64d6be92012-03-06 21:17:19 +00003998 if (Args.hasArg(options::OPT_fno_inline_functions))
3999 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004000
John McCall5fb5df92012-06-20 06:18:46 +00004001 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004002
John McCall5fb5df92012-06-20 06:18:46 +00004003 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004004 // legacy is the default. Except for deployment taget of 10.5,
4005 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4006 // gets ignored silently.
4007 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004008 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4009 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004010 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004011 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004012 if (getToolChain().UseObjCMixedDispatch())
4013 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4014 else
4015 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4016 }
4017 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004018
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004019 // When ObjectiveC legacy runtime is in effect on MacOSX,
4020 // turn on the option to do Array/Dictionary subscripting
4021 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004022 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
4023 getToolChain().getTriple().isMacOSX() &&
4024 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4025 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004026 objcRuntime.isNeXTFamily())
4027 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4028
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004029 // -fencode-extended-block-signature=1 is default.
4030 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4031 CmdArgs.push_back("-fencode-extended-block-signature");
4032 }
4033
John McCall24fc0de2011-07-06 00:26:06 +00004034 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4035 // NOTE: This logic is duplicated in ToolChains.cpp.
4036 bool ARC = isObjCAutoRefCount(Args);
4037 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004038 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004039
John McCall24fc0de2011-07-06 00:26:06 +00004040 CmdArgs.push_back("-fobjc-arc");
4041
Chandler Carruth491db322011-11-04 07:34:47 +00004042 // FIXME: It seems like this entire block, and several around it should be
4043 // wrapped in isObjC, but for now we just use it here as this is where it
4044 // was being used previously.
4045 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4046 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4047 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4048 else
4049 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4050 }
4051
John McCall24fc0de2011-07-06 00:26:06 +00004052 // Allow the user to enable full exceptions code emission.
4053 // We define off for Objective-CC, on for Objective-C++.
4054 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4055 options::OPT_fno_objc_arc_exceptions,
4056 /*default*/ types::isCXX(InputType)))
4057 CmdArgs.push_back("-fobjc-arc-exceptions");
4058 }
4059
4060 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4061 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004062 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004063 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004064
John McCall24fc0de2011-07-06 00:26:06 +00004065 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4066 // takes precedence.
4067 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4068 if (!GCArg)
4069 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4070 if (GCArg) {
4071 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004072 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004073 << GCArg->getAsString(Args);
4074 } else if (getToolChain().SupportsObjCGC()) {
4075 GCArg->render(Args, CmdArgs);
4076 } else {
4077 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004078 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004079 << GCArg->getAsString(Args);
4080 }
4081 }
4082
Reid Klecknerc542d372014-06-27 17:02:02 +00004083 // Handle GCC-style exception args.
4084 if (!C.getDriver().IsCLMode())
4085 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
4086 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004087
4088 if (getToolChain().UseSjLjExceptions())
4089 CmdArgs.push_back("-fsjlj-exceptions");
Reid Kleckner8f45c9c2014-09-15 17:19:16 +00004090 else if (getToolChain().UseSEHExceptions())
4091 CmdArgs.push_back("-fseh-exceptions");
John McCallb5f652e2011-06-22 00:53:57 +00004092
4093 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004094 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4095 options::OPT_fno_assume_sane_operator_new))
4096 CmdArgs.push_back("-fno-assume-sane-operator-new");
4097
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004098 // -fconstant-cfstrings is default, and may be subject to argument translation
4099 // on Darwin.
4100 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4101 options::OPT_fno_constant_cfstrings) ||
4102 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4103 options::OPT_mno_constant_cfstrings))
4104 CmdArgs.push_back("-fno-constant-cfstrings");
4105
John Thompsoned4e2952009-11-05 20:14:16 +00004106 // -fshort-wchar default varies depending on platform; only
4107 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004108 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4109 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004110 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004111
Hans Wennborg28c96312013-07-31 23:39:13 +00004112 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004113 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004114 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004115 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004116 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004117
Daniel Dunbar096ed292011-10-05 21:04:55 +00004118 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4119 // -fno-pack-struct doesn't apply to -fpack-struct=.
4120 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004121 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004122 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004123 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004124 } else if (Args.hasFlag(options::OPT_fpack_struct,
4125 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004126 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004127 }
4128
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004129 // Handle -fmax-type-align=N and -fno-type-align
4130 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4131 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4132 if (!SkipMaxTypeAlign) {
4133 std::string MaxTypeAlignStr = "-fmax-type-align=";
4134 MaxTypeAlignStr += A->getValue();
4135 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4136 }
4137 } else if (getToolChain().getTriple().isOSDarwin()) {
4138 if (!SkipMaxTypeAlign) {
4139 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4140 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4141 }
4142 }
4143
Robert Lytton0e076492013-08-13 09:43:10 +00004144 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004145 if (!Args.hasArg(options::OPT_fcommon))
4146 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004147 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004148 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004149
Daniel Dunbard18049a2009-04-07 21:16:11 +00004150 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004151 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004152 CmdArgs.push_back("-fno-common");
4153
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004154 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004155 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004156 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004157 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004158 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004159 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4160
Daniel Dunbar6358d682010-10-15 22:30:42 +00004161 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4162 if (!Args.hasFlag(options::OPT_ffor_scope,
4163 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004164 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004165 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4166
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004167 // -finput_charset=UTF-8 is default. Reject others
4168 if (Arg *inputCharset = Args.getLastArg(
4169 options::OPT_finput_charset_EQ)) {
4170 StringRef value = inputCharset->getValue();
4171 if (value != "UTF-8")
4172 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4173 }
4174
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004175 // -fexec_charset=UTF-8 is default. Reject others
4176 if (Arg *execCharset = Args.getLastArg(
4177 options::OPT_fexec_charset_EQ)) {
4178 StringRef value = execCharset->getValue();
4179 if (value != "UTF-8")
4180 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4181 }
4182
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004183 // -fcaret-diagnostics is default.
4184 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4185 options::OPT_fno_caret_diagnostics, true))
4186 CmdArgs.push_back("-fno-caret-diagnostics");
4187
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004188 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004189 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004190 options::OPT_fno_diagnostics_fixit_info))
4191 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004192
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004193 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004194 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004195 options::OPT_fno_diagnostics_show_option))
4196 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004197
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004198 if (const Arg *A =
4199 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4200 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004201 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004202 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004203
Douglas Gregor643c9222011-05-21 17:07:29 +00004204 if (const Arg *A =
4205 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4206 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004207 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004208 }
4209
Chandler Carruthb6766f02011-03-27 01:50:55 +00004210 if (Arg *A = Args.getLastArg(
4211 options::OPT_fdiagnostics_show_note_include_stack,
4212 options::OPT_fno_diagnostics_show_note_include_stack)) {
4213 if (A->getOption().matches(
4214 options::OPT_fdiagnostics_show_note_include_stack))
4215 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4216 else
4217 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4218 }
4219
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004220 // Color diagnostics are the default, unless the terminal doesn't support
4221 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004222 // Support both clang's -f[no-]color-diagnostics and gcc's
4223 // -f[no-]diagnostics-colors[=never|always|auto].
4224 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004225 for (const auto &Arg : Args) {
4226 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004227 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4228 !O.matches(options::OPT_fdiagnostics_color) &&
4229 !O.matches(options::OPT_fno_color_diagnostics) &&
4230 !O.matches(options::OPT_fno_diagnostics_color) &&
4231 !O.matches(options::OPT_fdiagnostics_color_EQ))
4232 continue;
4233
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004234 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004235 if (O.matches(options::OPT_fcolor_diagnostics) ||
4236 O.matches(options::OPT_fdiagnostics_color)) {
4237 ShowColors = Colors_On;
4238 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4239 O.matches(options::OPT_fno_diagnostics_color)) {
4240 ShowColors = Colors_Off;
4241 } else {
4242 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004243 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004244 if (value == "always")
4245 ShowColors = Colors_On;
4246 else if (value == "never")
4247 ShowColors = Colors_Off;
4248 else if (value == "auto")
4249 ShowColors = Colors_Auto;
4250 else
4251 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4252 << ("-fdiagnostics-color=" + value).str();
4253 }
4254 }
4255 if (ShowColors == Colors_On ||
4256 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004257 CmdArgs.push_back("-fcolor-diagnostics");
4258
Nico Rieck7857d462013-09-11 00:38:02 +00004259 if (Args.hasArg(options::OPT_fansi_escape_codes))
4260 CmdArgs.push_back("-fansi-escape-codes");
4261
Daniel Dunbardb097022009-06-08 21:13:54 +00004262 if (!Args.hasFlag(options::OPT_fshow_source_location,
4263 options::OPT_fno_show_source_location))
4264 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004265
Douglas Gregor643c9222011-05-21 17:07:29 +00004266 if (!Args.hasFlag(options::OPT_fshow_column,
4267 options::OPT_fno_show_column,
4268 true))
4269 CmdArgs.push_back("-fno-show-column");
4270
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004271 if (!Args.hasFlag(options::OPT_fspell_checking,
4272 options::OPT_fno_spell_checking))
4273 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004274
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004275
Chad Rosierc8e56e82012-12-05 21:08:21 +00004276 // -fno-asm-blocks is default.
4277 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4278 false))
4279 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004280
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004281 // Enable vectorization per default according to the optimization level
4282 // selected. For optimization levels that want vectorization we use the alias
4283 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004284 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004285 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004286 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004287 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004288 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004289 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004290
Chad Rosier136d67d2014-04-28 19:30:57 +00004291 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004292 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4293 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004294 options::OPT_fslp_vectorize;
4295 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004296 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004297 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004298
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004299 // -fno-slp-vectorize-aggressive is default.
4300 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004301 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004302 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004303
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004304 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4305 A->render(Args, CmdArgs);
4306
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004307 // -fdollars-in-identifiers default varies depending on platform and
4308 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004309 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004310 options::OPT_fno_dollars_in_identifiers)) {
4311 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004312 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004313 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004314 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004315 }
4316
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004317 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4318 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004319 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004320 options::OPT_fno_unit_at_a_time)) {
4321 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004322 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004323 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004324
Eli Friedman055c9702011-11-02 01:53:16 +00004325 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4326 options::OPT_fno_apple_pragma_pack, false))
4327 CmdArgs.push_back("-fapple-pragma-pack");
4328
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004329 // le32-specific flags:
4330 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4331 // by default.
4332 if (getToolChain().getArch() == llvm::Triple::le32) {
4333 CmdArgs.push_back("-fno-math-builtin");
4334 }
4335
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004336 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004337 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004338 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004339#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004340 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004341 (getToolChain().getArch() == llvm::Triple::arm ||
4342 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004343 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4344 CmdArgs.push_back("-fno-builtin-strcat");
4345 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4346 CmdArgs.push_back("-fno-builtin-strcpy");
4347 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004348#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004349
Justin Bognera88f0122014-06-20 22:59:50 +00004350 // Enable rewrite includes if the user's asked for it or if we're generating
4351 // diagnostics.
4352 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4353 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004354 if (Args.hasFlag(options::OPT_frewrite_includes,
4355 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004356 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004357 CmdArgs.push_back("-frewrite-includes");
4358
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004359 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004360 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004361 options::OPT_traditional_cpp)) {
4362 if (isa<PreprocessJobAction>(JA))
4363 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004364 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004365 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004366 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004367
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004368 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004369 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004370
4371 // Handle serialized diagnostics.
4372 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4373 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004374 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004375 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004376
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004377 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4378 CmdArgs.push_back("-fretain-comments-from-system-headers");
4379
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004380 // Forward -fcomment-block-commands to -cc1.
4381 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004382 // Forward -fparse-all-comments to -cc1.
4383 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004384
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004385 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4386 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004387 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004388 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4389 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004390 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004391
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004392 // We translate this by hand to the -cc1 argument, since nightly test uses
4393 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004394 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004395 CmdArgs.push_back("-disable-llvm-optzns");
4396 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004397 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004398 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004399
Daniel Dunbard67a3222009-03-30 06:36:42 +00004400 if (Output.getType() == types::TY_Dependencies) {
4401 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004402 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004403 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004404 CmdArgs.push_back(Output.getFilename());
4405 } else {
4406 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004407 }
4408
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004409 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004410 addDashXForInput(Args, II, CmdArgs);
4411
Daniel Dunbarb440f562010-08-02 02:38:21 +00004412 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004413 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004414 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004415 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004416 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004417
Chris Lattnere9d7d782009-11-03 19:50:27 +00004418 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4419
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004420 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004421
4422 // Optionally embed the -cc1 level arguments into the debug info, for build
4423 // analysis.
4424 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004425 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004426 for (const auto &Arg : Args)
4427 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004428
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004429 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004430 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004431 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004432 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004433 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004434 }
4435 CmdArgs.push_back("-dwarf-debug-flags");
4436 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4437 }
4438
Eric Christopherd3804002013-02-22 20:12:52 +00004439 // Add the split debug info name to the command lines here so we
4440 // can propagate it to the backend.
4441 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004442 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004443 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004444 const char *SplitDwarfOut;
4445 if (SplitDwarf) {
4446 CmdArgs.push_back("-split-dwarf-file");
4447 SplitDwarfOut = SplitDebugName(Args, Inputs);
4448 CmdArgs.push_back(SplitDwarfOut);
4449 }
4450
4451 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004452 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004453 Output.getType() == types::TY_Object &&
4454 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004455 auto CLCommand =
4456 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4457 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4458 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004459 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004460 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004461 }
4462
Daniel Dunbar17731772009-03-23 19:03:36 +00004463
Eric Christopherf1545832013-02-22 23:50:16 +00004464 // Handle the debug info splitting at object creation time if we're
4465 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004466 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004467 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004468 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004469
Roman Divacky178e01602011-02-10 16:52:03 +00004470 if (Arg *A = Args.getLastArg(options::OPT_pg))
4471 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004472 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004473 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004474
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004475 // Claim some arguments which clang supports automatically.
4476
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004477 // -fpch-preprocess is used with gcc to add a special marker in the output to
4478 // include the PCH file. Clang's PTH solution is completely transparent, so we
4479 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004480 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004481
Daniel Dunbar17731772009-03-23 19:03:36 +00004482 // Claim some arguments which clang doesn't support, but we don't
4483 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004484 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4485 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004486
Rafael Espindolab0092d72013-09-04 19:37:35 +00004487 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004488 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004489}
4490
John McCall5fb5df92012-06-20 06:18:46 +00004491/// Add options related to the Objective-C runtime/ABI.
4492///
4493/// Returns true if the runtime is non-fragile.
4494ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4495 ArgStringList &cmdArgs,
4496 RewriteKind rewriteKind) const {
4497 // Look for the controlling runtime option.
4498 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4499 options::OPT_fgnu_runtime,
4500 options::OPT_fobjc_runtime_EQ);
4501
4502 // Just forward -fobjc-runtime= to the frontend. This supercedes
4503 // options about fragility.
4504 if (runtimeArg &&
4505 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4506 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004507 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004508 if (runtime.tryParse(value)) {
4509 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4510 << value;
4511 }
4512
4513 runtimeArg->render(args, cmdArgs);
4514 return runtime;
4515 }
4516
4517 // Otherwise, we'll need the ABI "version". Version numbers are
4518 // slightly confusing for historical reasons:
4519 // 1 - Traditional "fragile" ABI
4520 // 2 - Non-fragile ABI, version 1
4521 // 3 - Non-fragile ABI, version 2
4522 unsigned objcABIVersion = 1;
4523 // If -fobjc-abi-version= is present, use that to set the version.
4524 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004525 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004526 if (value == "1")
4527 objcABIVersion = 1;
4528 else if (value == "2")
4529 objcABIVersion = 2;
4530 else if (value == "3")
4531 objcABIVersion = 3;
4532 else
4533 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4534 << value;
4535 } else {
4536 // Otherwise, determine if we are using the non-fragile ABI.
4537 bool nonFragileABIIsDefault =
4538 (rewriteKind == RK_NonFragile ||
4539 (rewriteKind == RK_None &&
4540 getToolChain().IsObjCNonFragileABIDefault()));
4541 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4542 options::OPT_fno_objc_nonfragile_abi,
4543 nonFragileABIIsDefault)) {
4544 // Determine the non-fragile ABI version to use.
4545#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4546 unsigned nonFragileABIVersion = 1;
4547#else
4548 unsigned nonFragileABIVersion = 2;
4549#endif
4550
4551 if (Arg *abiArg = args.getLastArg(
4552 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004553 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004554 if (value == "1")
4555 nonFragileABIVersion = 1;
4556 else if (value == "2")
4557 nonFragileABIVersion = 2;
4558 else
4559 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4560 << value;
4561 }
4562
4563 objcABIVersion = 1 + nonFragileABIVersion;
4564 } else {
4565 objcABIVersion = 1;
4566 }
4567 }
4568
4569 // We don't actually care about the ABI version other than whether
4570 // it's non-fragile.
4571 bool isNonFragile = objcABIVersion != 1;
4572
4573 // If we have no runtime argument, ask the toolchain for its default runtime.
4574 // However, the rewriter only really supports the Mac runtime, so assume that.
4575 ObjCRuntime runtime;
4576 if (!runtimeArg) {
4577 switch (rewriteKind) {
4578 case RK_None:
4579 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4580 break;
4581 case RK_Fragile:
4582 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4583 break;
4584 case RK_NonFragile:
4585 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4586 break;
4587 }
4588
4589 // -fnext-runtime
4590 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4591 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004592 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004593 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4594
4595 // Otherwise, build for a generic macosx port.
4596 } else {
4597 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4598 }
4599
4600 // -fgnu-runtime
4601 } else {
4602 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004603 // Legacy behaviour is to target the gnustep runtime if we are i
4604 // non-fragile mode or the GCC runtime in fragile mode.
4605 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004606 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004607 else
4608 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004609 }
4610
4611 cmdArgs.push_back(args.MakeArgString(
4612 "-fobjc-runtime=" + runtime.getAsString()));
4613 return runtime;
4614}
4615
Reid Klecknerc542d372014-06-27 17:02:02 +00004616static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4617 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4618 I += HaveDash;
4619 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004620}
Reid Klecknerc542d372014-06-27 17:02:02 +00004621
4622struct EHFlags {
4623 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4624 bool Synch;
4625 bool Asynch;
4626 bool NoExceptC;
4627};
4628
4629/// /EH controls whether to run destructor cleanups when exceptions are
4630/// thrown. There are three modifiers:
4631/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4632/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4633/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4634/// - c: Assume that extern "C" functions are implicitly noexcept. This
4635/// modifier is an optimization, so we ignore it for now.
4636/// The default is /EHs-c-, meaning cleanups are disabled.
4637static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4638 EHFlags EH;
4639 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4640 for (auto EHVal : EHArgs) {
4641 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4642 switch (EHVal[I]) {
4643 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4644 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4645 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4646 default: break;
4647 }
4648 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4649 break;
4650 }
4651 }
4652 return EH;
4653}
4654
Hans Wennborg75958c42013-08-08 00:17:41 +00004655void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4656 unsigned RTOptionID = options::OPT__SLASH_MT;
4657
Hans Wennborgf1a74252013-09-10 20:18:04 +00004658 if (Args.hasArg(options::OPT__SLASH_LDd))
4659 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4660 // but defining _DEBUG is sticky.
4661 RTOptionID = options::OPT__SLASH_MTd;
4662
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004663 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004664 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004665
Hans Wennborg75958c42013-08-08 00:17:41 +00004666 switch(RTOptionID) {
4667 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004668 if (Args.hasArg(options::OPT__SLASH_LDd))
4669 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004670 CmdArgs.push_back("-D_MT");
4671 CmdArgs.push_back("-D_DLL");
4672 CmdArgs.push_back("--dependent-lib=msvcrt");
4673 break;
4674 case options::OPT__SLASH_MDd:
4675 CmdArgs.push_back("-D_DEBUG");
4676 CmdArgs.push_back("-D_MT");
4677 CmdArgs.push_back("-D_DLL");
4678 CmdArgs.push_back("--dependent-lib=msvcrtd");
4679 break;
4680 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004681 if (Args.hasArg(options::OPT__SLASH_LDd))
4682 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004683 CmdArgs.push_back("-D_MT");
4684 CmdArgs.push_back("--dependent-lib=libcmt");
4685 break;
4686 case options::OPT__SLASH_MTd:
4687 CmdArgs.push_back("-D_DEBUG");
4688 CmdArgs.push_back("-D_MT");
4689 CmdArgs.push_back("--dependent-lib=libcmtd");
4690 break;
4691 default:
4692 llvm_unreachable("Unexpected option ID.");
4693 }
4694
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004695 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4696 // users want. The /Za flag to cl.exe turns this off, but it's not
4697 // implemented in clang.
4698 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004699
Hans Wennborg8858a032014-07-21 23:42:07 +00004700 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4701 // would produce interleaved output, so ignore /showIncludes in such cases.
4702 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4703 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4704 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004705
David Majnemerf6072342014-07-01 22:24:56 +00004706 // This controls whether or not we emit RTTI data for polymorphic types.
4707 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4708 /*default=*/false))
4709 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004710
Reid Klecknerc542d372014-06-27 17:02:02 +00004711 const Driver &D = getToolChain().getDriver();
4712 EHFlags EH = parseClangCLEHFlags(D, Args);
4713 // FIXME: Do something with NoExceptC.
4714 if (EH.Synch || EH.Asynch) {
4715 CmdArgs.push_back("-fexceptions");
4716 CmdArgs.push_back("-fcxx-exceptions");
4717 }
4718
Hans Wennborge50cec32014-06-13 20:59:54 +00004719 // /EP should expand to -E -P.
4720 if (Args.hasArg(options::OPT__SLASH_EP)) {
4721 CmdArgs.push_back("-E");
4722 CmdArgs.push_back("-P");
4723 }
4724
David Majnemer86c318f2014-02-11 21:05:00 +00004725 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4726 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4727 if (MostGeneralArg && BestCaseArg)
4728 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4729 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4730
4731 if (MostGeneralArg) {
4732 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4733 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4734 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4735
4736 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4737 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4738 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4739 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4740 << FirstConflict->getAsString(Args)
4741 << SecondConflict->getAsString(Args);
4742
4743 if (SingleArg)
4744 CmdArgs.push_back("-fms-memptr-rep=single");
4745 else if (MultipleArg)
4746 CmdArgs.push_back("-fms-memptr-rep=multiple");
4747 else
4748 CmdArgs.push_back("-fms-memptr-rep=virtual");
4749 }
4750
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004751 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4752 A->render(Args, CmdArgs);
4753
Hans Wennborg81f74482013-09-10 01:07:07 +00004754 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4755 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004756 if (Args.hasArg(options::OPT__SLASH_fallback))
4757 CmdArgs.push_back("msvc-fallback");
4758 else
4759 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004760 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004761}
4762
Hans Wennborg1da044a2014-06-26 19:59:02 +00004763visualstudio::Compile *Clang::getCLFallback() const {
4764 if (!CLFallback)
4765 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4766 return CLFallback.get();
4767}
4768
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004769void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004770 const InputInfo &Output,
4771 const InputInfoList &Inputs,
4772 const ArgList &Args,
4773 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004774 ArgStringList CmdArgs;
4775
4776 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4777 const InputInfo &Input = Inputs[0];
4778
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004779 // Don't warn about "clang -w -c foo.s"
4780 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004781 // and "clang -emit-llvm -c foo.s"
4782 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004783
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004784 // Invoke ourselves in -cc1as mode.
4785 //
4786 // FIXME: Implement custom jobs for internal actions.
4787 CmdArgs.push_back("-cc1as");
4788
4789 // Add the "effective" target triple.
4790 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004791 std::string TripleStr =
4792 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004793 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4794
4795 // Set the output mode, we currently only expect to be used as a real
4796 // assembler.
4797 CmdArgs.push_back("-filetype");
4798 CmdArgs.push_back("obj");
4799
Eric Christopher45f2e712012-12-18 00:31:10 +00004800 // Set the main file name, so that debug info works even with
4801 // -save-temps or preprocessed assembly.
4802 CmdArgs.push_back("-main-file-name");
4803 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4804
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004805 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004806 const llvm::Triple &Triple = getToolChain().getTriple();
4807 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004808 if (!CPU.empty()) {
4809 CmdArgs.push_back("-target-cpu");
4810 CmdArgs.push_back(Args.MakeArgString(CPU));
4811 }
4812
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004813 // Add the target features
4814 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004815 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004816
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004817 // Ignore explicit -force_cpusubtype_ALL option.
4818 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004819
Eric Christopherfc3ee562012-01-10 00:38:01 +00004820 // Determine the original source input.
4821 const Action *SourceAction = &JA;
4822 while (SourceAction->getKind() != Action::InputClass) {
4823 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4824 SourceAction = SourceAction->getInputs()[0];
4825 }
4826
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004827 // Forward -g and handle debug info related flags, assuming we are dealing
4828 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004829 if (SourceAction->getType() == types::TY_Asm ||
4830 SourceAction->getType() == types::TY_PP_Asm) {
4831 Args.ClaimAllArgs(options::OPT_g_Group);
4832 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4833 if (!A->getOption().matches(options::OPT_g0))
4834 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004835
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004836 if (Args.hasArg(options::OPT_gdwarf_2))
4837 CmdArgs.push_back("-gdwarf-2");
4838 if (Args.hasArg(options::OPT_gdwarf_3))
4839 CmdArgs.push_back("-gdwarf-3");
4840 if (Args.hasArg(options::OPT_gdwarf_4))
4841 CmdArgs.push_back("-gdwarf-4");
4842
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004843 // Add the -fdebug-compilation-dir flag if needed.
4844 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004845
4846 // Set the AT_producer to the clang version when using the integrated
4847 // assembler on assembly source files.
4848 CmdArgs.push_back("-dwarf-debug-producer");
4849 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004850 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004851
4852 // Optionally embed the -cc1as level arguments into the debug info, for build
4853 // analysis.
4854 if (getToolChain().UseDwarfDebugFlags()) {
4855 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004856 for (const auto &Arg : Args)
4857 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004858
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004859 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004860 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4861 Flags += Exec;
4862 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4863 Flags += " ";
4864 Flags += OriginalArgs[i];
4865 }
4866 CmdArgs.push_back("-dwarf-debug-flags");
4867 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4868 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004869
4870 // FIXME: Add -static support, once we have it.
4871
David Blaikie372d9502014-01-17 03:17:40 +00004872 // Consume all the warning flags. Usually this would be handled more
4873 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4874 // doesn't handle that so rather than warning about unused flags that are
4875 // actually used, we'll lie by omission instead.
4876 // FIXME: Stop lying and consume only the appropriate driver flags
4877 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4878 ie = Args.filtered_end();
4879 it != ie; ++it)
4880 (*it)->claim();
4881
David Blaikie9260ed62013-07-25 21:19:01 +00004882 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4883 getToolChain().getDriver());
4884
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004885 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004886
4887 assert(Output.isFilename() && "Unexpected lipo output.");
4888 CmdArgs.push_back("-o");
4889 CmdArgs.push_back(Output.getFilename());
4890
Daniel Dunbarb440f562010-08-02 02:38:21 +00004891 assert(Input.isFilename() && "Invalid input.");
4892 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004893
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004894 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00004895 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004896
4897 // Handle the debug info splitting at object creation time if we're
4898 // creating an object.
4899 // TODO: Currently only works on linux with newer objcopy.
4900 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004901 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004902 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4903 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004904}
4905
Reid Kleckner0290c9c2014-09-15 17:45:39 +00004906void GnuTool::anchor() {}
4907
Daniel Dunbara3246a02009-03-18 08:07:30 +00004908void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004909 const InputInfo &Output,
4910 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004911 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004912 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004913 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004914 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004915
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004916 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004917 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004918 // Don't forward any -g arguments to assembly steps.
4919 if (isa<AssembleJobAction>(JA) &&
4920 A->getOption().matches(options::OPT_g_Group))
4921 continue;
4922
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004923 // Don't forward any -W arguments to assembly and link steps.
4924 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4925 A->getOption().matches(options::OPT_W_Group))
4926 continue;
4927
Daniel Dunbar2da02722009-03-19 07:55:12 +00004928 // It is unfortunate that we have to claim here, as this means
4929 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004930 // platforms using a generic gcc, even if we are just using gcc
4931 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004932 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004933 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004934 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004935 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004936
Daniel Dunbar4e295052010-01-25 22:35:08 +00004937 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004938
4939 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004940 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004941 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004942 CmdArgs.push_back(
4943 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004944 }
4945
Daniel Dunbar5716d872009-05-02 21:41:52 +00004946 // Try to force gcc to match the tool chain we want, if we recognize
4947 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004948 //
4949 // FIXME: The triple class should directly provide the information we want
4950 // here.
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004951 llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004952 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004953 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004954 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4955 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004956 CmdArgs.push_back("-m64");
4957
Daniel Dunbarb440f562010-08-02 02:38:21 +00004958 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004959 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004960 CmdArgs.push_back(Output.getFilename());
4961 } else {
4962 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004963 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004964 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004965
Tony Linthicum76329bf2011-12-12 21:14:55 +00004966 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4967 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004968
4969 // Only pass -x if gcc will understand it; otherwise hope gcc
4970 // understands the suffix correctly. The main use case this would go
4971 // wrong in is for linker inputs if they happened to have an odd
4972 // suffix; really the only way to get this to happen is a command
4973 // like '-x foobar a.c' which will treat a.c like a linker input.
4974 //
4975 // FIXME: For the linker case specifically, can we safely convert
4976 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004977 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004978 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004979 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4980 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004981 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004982 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004983 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004984 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004985 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004986 else if (II.getType() == types::TY_ModuleFile)
4987 D.Diag(diag::err_drv_no_module_support)
4988 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004989
Daniel Dunbara3246a02009-03-18 08:07:30 +00004990 if (types::canTypeBeUserSpecified(II.getType())) {
4991 CmdArgs.push_back("-x");
4992 CmdArgs.push_back(types::getTypeName(II.getType()));
4993 }
4994
Daniel Dunbarb440f562010-08-02 02:38:21 +00004995 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004996 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004997 else {
4998 const Arg &A = II.getInputArg();
4999
5000 // Reverse translate some rewritten options.
5001 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5002 CmdArgs.push_back("-lstdc++");
5003 continue;
5004 }
5005
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005006 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005007 A.render(Args, CmdArgs);
5008 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005009 }
5010
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005011 const std::string customGCCName = D.getCCCGenericGCCName();
5012 const char *GCCName;
5013 if (!customGCCName.empty())
5014 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005015 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005016 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005017 } else
5018 GCCName = "gcc";
5019
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005020 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005021 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005022 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005023}
5024
Daniel Dunbar4e295052010-01-25 22:35:08 +00005025void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5026 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005027 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005028}
5029
Daniel Dunbar4e295052010-01-25 22:35:08 +00005030void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5031 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005032 const Driver &D = getToolChain().getDriver();
5033
Daniel Dunbar4e295052010-01-25 22:35:08 +00005034 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005035 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
5036 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00005037 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005038 else {
5039 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005040 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005041 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005042
Daniel Dunbar4e295052010-01-25 22:35:08 +00005043 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005044 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005045}
5046
Daniel Dunbar4e295052010-01-25 22:35:08 +00005047void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5048 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005049 // The types are (hopefully) good enough.
5050}
5051
Tony Linthicum76329bf2011-12-12 21:14:55 +00005052// Hexagon tools start.
5053void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5054 ArgStringList &CmdArgs) const {
5055
5056}
5057void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5058 const InputInfo &Output,
5059 const InputInfoList &Inputs,
5060 const ArgList &Args,
5061 const char *LinkingOutput) const {
5062
5063 const Driver &D = getToolChain().getDriver();
5064 ArgStringList CmdArgs;
5065
5066 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005067 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005068 CmdArgs.push_back(Args.MakeArgString(MarchString));
5069
5070 RenderExtraToolArgs(JA, CmdArgs);
5071
5072 if (Output.isFilename()) {
5073 CmdArgs.push_back("-o");
5074 CmdArgs.push_back(Output.getFilename());
5075 } else {
5076 assert(Output.isNothing() && "Unexpected output");
5077 CmdArgs.push_back("-fsyntax-only");
5078 }
5079
Matthew Curtise8f80a12012-12-06 17:49:03 +00005080 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5081 if (!SmallDataThreshold.empty())
5082 CmdArgs.push_back(
5083 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005084
Matthew Curtise5df3812012-12-07 17:23:04 +00005085 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5086 options::OPT_Xassembler);
5087
Tony Linthicum76329bf2011-12-12 21:14:55 +00005088 // Only pass -x if gcc will understand it; otherwise hope gcc
5089 // understands the suffix correctly. The main use case this would go
5090 // wrong in is for linker inputs if they happened to have an odd
5091 // suffix; really the only way to get this to happen is a command
5092 // like '-x foobar a.c' which will treat a.c like a linker input.
5093 //
5094 // FIXME: For the linker case specifically, can we safely convert
5095 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005096 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005097 // Don't try to pass LLVM or AST inputs to a generic gcc.
5098 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5099 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5100 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5101 << getToolChain().getTripleString();
5102 else if (II.getType() == types::TY_AST)
5103 D.Diag(clang::diag::err_drv_no_ast_support)
5104 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005105 else if (II.getType() == types::TY_ModuleFile)
5106 D.Diag(diag::err_drv_no_module_support)
5107 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005108
5109 if (II.isFilename())
5110 CmdArgs.push_back(II.getFilename());
5111 else
5112 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5113 II.getInputArg().render(Args, CmdArgs);
5114 }
5115
5116 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005117 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005118 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005119}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005120
Tony Linthicum76329bf2011-12-12 21:14:55 +00005121void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5122 ArgStringList &CmdArgs) const {
5123 // The types are (hopefully) good enough.
5124}
5125
5126void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5127 const InputInfo &Output,
5128 const InputInfoList &Inputs,
5129 const ArgList &Args,
5130 const char *LinkingOutput) const {
5131
Matthew Curtise689b052012-12-06 15:46:07 +00005132 const toolchains::Hexagon_TC& ToolChain =
5133 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5134 const Driver &D = ToolChain.getDriver();
5135
Tony Linthicum76329bf2011-12-12 21:14:55 +00005136 ArgStringList CmdArgs;
5137
Matthew Curtise689b052012-12-06 15:46:07 +00005138 //----------------------------------------------------------------------------
5139 //
5140 //----------------------------------------------------------------------------
5141 bool hasStaticArg = Args.hasArg(options::OPT_static);
5142 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005143 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005144 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5145 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5146 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5147 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005148
Matthew Curtise689b052012-12-06 15:46:07 +00005149 //----------------------------------------------------------------------------
5150 // Silence warnings for various options
5151 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005152
Matthew Curtise689b052012-12-06 15:46:07 +00005153 Args.ClaimAllArgs(options::OPT_g_Group);
5154 Args.ClaimAllArgs(options::OPT_emit_llvm);
5155 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5156 // handled somewhere else.
5157 Args.ClaimAllArgs(options::OPT_static_libgcc);
5158
5159 //----------------------------------------------------------------------------
5160 //
5161 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005162 for (const auto &Opt : ToolChain.ExtraOpts)
5163 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005164
Matthew Curtisf10a5952012-12-06 14:16:43 +00005165 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5166 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005167
Matthew Curtise689b052012-12-06 15:46:07 +00005168 if (buildingLib) {
5169 CmdArgs.push_back("-shared");
5170 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5171 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005172 }
5173
Matthew Curtise689b052012-12-06 15:46:07 +00005174 if (hasStaticArg)
5175 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005176
Matthew Curtise8f80a12012-12-06 17:49:03 +00005177 if (buildPIE && !buildingLib)
5178 CmdArgs.push_back("-pie");
5179
5180 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5181 if (!SmallDataThreshold.empty()) {
5182 CmdArgs.push_back(
5183 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5184 }
5185
Matthew Curtise689b052012-12-06 15:46:07 +00005186 //----------------------------------------------------------------------------
5187 //
5188 //----------------------------------------------------------------------------
5189 CmdArgs.push_back("-o");
5190 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005191
Matthew Curtise689b052012-12-06 15:46:07 +00005192 const std::string MarchSuffix = "/" + MarchString;
5193 const std::string G0Suffix = "/G0";
5194 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
5195 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
5196 + "/";
5197 const std::string StartFilesDir = RootDir
5198 + "hexagon/lib"
5199 + (buildingLib
5200 ? MarchG0Suffix : MarchSuffix);
5201
5202 //----------------------------------------------------------------------------
5203 // moslib
5204 //----------------------------------------------------------------------------
5205 std::vector<std::string> oslibs;
5206 bool hasStandalone= false;
5207
5208 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5209 ie = Args.filtered_end(); it != ie; ++it) {
5210 (*it)->claim();
5211 oslibs.push_back((*it)->getValue());
5212 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005213 }
Matthew Curtise689b052012-12-06 15:46:07 +00005214 if (oslibs.empty()) {
5215 oslibs.push_back("standalone");
5216 hasStandalone = true;
5217 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005218
Matthew Curtise689b052012-12-06 15:46:07 +00005219 //----------------------------------------------------------------------------
5220 // Start Files
5221 //----------------------------------------------------------------------------
5222 if (incStdLib && incStartFiles) {
5223
5224 if (!buildingLib) {
5225 if (hasStandalone) {
5226 CmdArgs.push_back(
5227 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5228 }
5229 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5230 }
5231 std::string initObj = useShared ? "/initS.o" : "/init.o";
5232 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5233 }
5234
5235 //----------------------------------------------------------------------------
5236 // Library Search Paths
5237 //----------------------------------------------------------------------------
5238 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005239 for (const auto &LibPath : LibPaths)
5240 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005241
5242 //----------------------------------------------------------------------------
5243 //
5244 //----------------------------------------------------------------------------
5245 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5246 Args.AddAllArgs(CmdArgs, options::OPT_e);
5247 Args.AddAllArgs(CmdArgs, options::OPT_s);
5248 Args.AddAllArgs(CmdArgs, options::OPT_t);
5249 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5250
5251 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5252
5253 //----------------------------------------------------------------------------
5254 // Libraries
5255 //----------------------------------------------------------------------------
5256 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005257 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005258 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5259 CmdArgs.push_back("-lm");
5260 }
5261
5262 CmdArgs.push_back("--start-group");
5263
5264 if (!buildingLib) {
5265 for(std::vector<std::string>::iterator i = oslibs.begin(),
5266 e = oslibs.end(); i != e; ++i)
5267 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5268 CmdArgs.push_back("-lc");
5269 }
5270 CmdArgs.push_back("-lgcc");
5271
5272 CmdArgs.push_back("--end-group");
5273 }
5274
5275 //----------------------------------------------------------------------------
5276 // End files
5277 //----------------------------------------------------------------------------
5278 if (incStdLib && incStartFiles) {
5279 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5280 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5281 }
5282
5283 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005284 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5285 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005286}
5287// Hexagon tools end.
5288
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005289/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005290const char *arm::getARMCPUForMArch(const ArgList &Args,
5291 const llvm::Triple &Triple) {
5292 StringRef MArch;
5293 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5294 // Otherwise, if we have -march= choose the base CPU for that arch.
5295 MArch = A->getValue();
5296 } else {
5297 // Otherwise, use the Arch from the triple.
5298 MArch = Triple.getArchName();
5299 }
5300
5301 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005302 if (MArch == "native") {
5303 std::string CPU = llvm::sys::getHostCPUName();
5304 if (CPU != "generic") {
5305 // Translate the native cpu into the architecture. The switch below will
5306 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005307 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005308 }
5309 }
5310
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005311 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005312}
5313
5314/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005315StringRef arm::getARMTargetCPU(const ArgList &Args,
5316 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005317 // FIXME: Warn on inconsistent use of -mcpu and -march.
5318 // If we have -mcpu=, use that.
5319 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5320 StringRef MCPU = A->getValue();
5321 // Handle -mcpu=native.
5322 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005323 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005324 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005325 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005326 }
5327
5328 return getARMCPUForMArch(Args, Triple);
5329}
5330
5331/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5332/// CPU.
5333//
5334// FIXME: This is redundant with -mcpu, why does LLVM use this.
5335// FIXME: tblgen this, or kill it!
5336const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5337 return llvm::StringSwitch<const char *>(CPU)
5338 .Case("strongarm", "v4")
5339 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5340 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5341 .Cases("arm920", "arm920t", "arm922t", "v4t")
5342 .Cases("arm940t", "ep9312","v4t")
5343 .Cases("arm10tdmi", "arm1020t", "v5")
5344 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5345 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5346 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5347 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5348 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5349 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005350 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005351 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5352 .Cases("cortex-r4", "cortex-r5", "v7r")
5353 .Case("cortex-m0", "v6m")
5354 .Case("cortex-m3", "v7m")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00005355 .Cases("cortex-m4", "cortex-m7", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005356 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005357 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005358 .Cases("cortex-a53", "cortex-a57", "v8")
5359 .Default("");
5360}
5361
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005362bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5363 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5364 return A && (A->getValue() == StringRef(Value));
5365}
5366
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005367bool mips::isUCLibc(const ArgList &Args) {
5368 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005369 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005370}
5371
Daniel Sanders2bf13662014-07-10 14:40:57 +00005372bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005373 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5374 return llvm::StringSwitch<bool>(NaNArg->getValue())
5375 .Case("2008", true)
5376 .Case("legacy", false)
5377 .Default(false);
5378
5379 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005380 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5381 .Cases("mips32r6", "mips64r6", true)
5382 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005383
5384 return false;
5385}
5386
Daniel Sanders379d44b2014-07-16 11:52:23 +00005387bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5388 StringRef ABIName) {
5389 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005390 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005391 return false;
5392
5393 if (ABIName != "32")
5394 return false;
5395
5396 return llvm::StringSwitch<bool>(CPUName)
5397 .Cases("mips2", "mips3", "mips4", "mips5", true)
5398 .Cases("mips32", "mips32r2", true)
5399 .Cases("mips64", "mips64r2", true)
5400 .Default(false);
5401}
5402
Tim Northover157d9112014-01-16 08:48:16 +00005403llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005404 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5405 // archs which Darwin doesn't use.
5406
5407 // The matching this routine does is fairly pointless, since it is neither the
5408 // complete architecture list, nor a reasonable subset. The problem is that
5409 // historically the driver driver accepts this and also ties its -march=
5410 // handling to the architecture name, so we need to be careful before removing
5411 // support for it.
5412
5413 // This code must be kept in sync with Clang's Darwin specific argument
5414 // translation.
5415
5416 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5417 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5418 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5419 .Case("ppc64", llvm::Triple::ppc64)
5420 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5421 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5422 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005423 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005424 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005425 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005426 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005427 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005428 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005429 .Case("r600", llvm::Triple::r600)
5430 .Case("nvptx", llvm::Triple::nvptx)
5431 .Case("nvptx64", llvm::Triple::nvptx64)
5432 .Case("amdil", llvm::Triple::amdil)
5433 .Case("spir", llvm::Triple::spir)
5434 .Default(llvm::Triple::UnknownArch);
5435}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005436
Tim Northover157d9112014-01-16 08:48:16 +00005437void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5438 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5439 T.setArch(Arch);
5440
5441 if (Str == "x86_64h")
5442 T.setArchName(Str);
5443 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5444 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005445 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005446 }
5447}
5448
Bob Wilsondecc03e2012-11-23 06:14:39 +00005449const char *Clang::getBaseInputName(const ArgList &Args,
5450 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005451 return Args.MakeArgString(
5452 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005453}
5454
Bob Wilsondecc03e2012-11-23 06:14:39 +00005455const char *Clang::getBaseInputStem(const ArgList &Args,
5456 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005457 const char *Str = getBaseInputName(Args, Inputs);
5458
Chris Lattner906bb902011-01-16 08:14:11 +00005459 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005460 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005461
5462 return Str;
5463}
5464
Bob Wilsondecc03e2012-11-23 06:14:39 +00005465const char *Clang::getDependencyFileName(const ArgList &Args,
5466 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005467 // FIXME: Think about this more.
5468 std::string Res;
5469
5470 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005471 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005472 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005473 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005474 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005475 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005476 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005477}
5478
Daniel Dunbarbe220842009-03-20 16:06:39 +00005479void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005480 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005481 const InputInfoList &Inputs,
5482 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005483 const char *LinkingOutput) const {
5484 ArgStringList CmdArgs;
5485
5486 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5487 const InputInfo &Input = Inputs[0];
5488
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005489 // Determine the original source input.
5490 const Action *SourceAction = &JA;
5491 while (SourceAction->getKind() != Action::InputClass) {
5492 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5493 SourceAction = SourceAction->getInputs()[0];
5494 }
5495
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005496 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005497 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005498 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5499 // FIXME: at run-time detect assembler capabilities or rely on version
5500 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005501 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005502 const llvm::Triple &T(getToolChain().getTriple());
5503 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005504 CmdArgs.push_back("-Q");
5505 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005506
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005507 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005508 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005509 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005510 if (Args.hasArg(options::OPT_gstabs))
5511 CmdArgs.push_back("--gstabs");
5512 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005513 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005514 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005515
Daniel Dunbarbe220842009-03-20 16:06:39 +00005516 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005517 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005518
Daniel Dunbar6d484762010-07-22 01:47:22 +00005519 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005520 if (getToolChain().getArch() == llvm::Triple::x86 ||
5521 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005522 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5523 CmdArgs.push_back("-force_cpusubtype_ALL");
5524
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005525 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005526 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005527 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005528 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005529 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005530 CmdArgs.push_back("-static");
5531
Daniel Dunbarbe220842009-03-20 16:06:39 +00005532 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5533 options::OPT_Xassembler);
5534
5535 assert(Output.isFilename() && "Unexpected lipo output.");
5536 CmdArgs.push_back("-o");
5537 CmdArgs.push_back(Output.getFilename());
5538
Daniel Dunbarb440f562010-08-02 02:38:21 +00005539 assert(Input.isFilename() && "Invalid input.");
5540 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005541
5542 // asm_final spec is empty.
5543
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005544 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005545 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005546 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005547}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005548
Tim Northover157d9112014-01-16 08:48:16 +00005549void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005550
Tim Northover157d9112014-01-16 08:48:16 +00005551void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5552 ArgStringList &CmdArgs) const {
5553 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005554
Daniel Dunbarc1964212009-03-26 16:23:12 +00005555 // Derived from darwin_arch spec.
5556 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005557 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005558
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005559 // FIXME: Is this needed anymore?
5560 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005561 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005562}
5563
Bill Wendling3b2000f2012-10-02 18:02:50 +00005564bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5565 // We only need to generate a temp path for LTO if we aren't compiling object
5566 // files. When compiling source files, we run 'dsymutil' after linking. We
5567 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005568 for (const auto &Input : Inputs)
5569 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005570 return true;
5571
5572 return false;
5573}
5574
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005575void darwin::Link::AddLinkArgs(Compilation &C,
5576 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005577 ArgStringList &CmdArgs,
5578 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005579 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005580 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005581
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005582 unsigned Version[3] = { 0, 0, 0 };
5583 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5584 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005585 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005586 Version[1], Version[2], HadExtra) ||
5587 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005588 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005589 << A->getAsString(Args);
5590 }
5591
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005592 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005593 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005594 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5595 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005596
Bob Wilson3d27dad2013-08-02 22:25:34 +00005597 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5598 CmdArgs.push_back("-export_dynamic");
5599
Bill Wendling313b6bf2012-11-16 23:03:00 +00005600 // If we are using LTO, then automatically create a temporary file path for
5601 // the linker to use, so that it's lifetime will extend past a possible
5602 // dsymutil step.
5603 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5604 const char *TmpPath = C.getArgs().MakeArgString(
5605 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5606 C.addTempFile(TmpPath);
5607 CmdArgs.push_back("-object_path_lto");
5608 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005609 }
5610
Daniel Dunbarc1964212009-03-26 16:23:12 +00005611 // Derived from the "link" spec.
5612 Args.AddAllArgs(CmdArgs, options::OPT_static);
5613 if (!Args.hasArg(options::OPT_static))
5614 CmdArgs.push_back("-dynamic");
5615 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5616 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5617 // here. How do we wish to handle such things?
5618 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005619
Daniel Dunbarc1964212009-03-26 16:23:12 +00005620 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005621 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005622 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005623 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005624
5625 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5626 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5627 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5628
5629 Arg *A;
5630 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5631 (A = Args.getLastArg(options::OPT_current__version)) ||
5632 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005633 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005634 << A->getAsString(Args) << "-dynamiclib";
5635
5636 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5637 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5638 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5639 } else {
5640 CmdArgs.push_back("-dylib");
5641
5642 Arg *A;
5643 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5644 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5645 (A = Args.getLastArg(options::OPT_client__name)) ||
5646 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5647 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5648 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005649 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005650 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005651
Daniel Dunbarc1964212009-03-26 16:23:12 +00005652 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5653 "-dylib_compatibility_version");
5654 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5655 "-dylib_current_version");
5656
Tim Northover157d9112014-01-16 08:48:16 +00005657 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005658
5659 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5660 "-dylib_install_name");
5661 }
5662
5663 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5664 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5665 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005666 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005667 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005668 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5669 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5670 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5671 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5672 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5673 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005674 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005675 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5676 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5677 Args.AddAllArgs(CmdArgs, options::OPT_init);
5678
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005679 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005680 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005681
Daniel Dunbarc1964212009-03-26 16:23:12 +00005682 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5683 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5684 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5685 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5686 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005687
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005688 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5689 options::OPT_fno_pie,
5690 options::OPT_fno_PIE)) {
5691 if (A->getOption().matches(options::OPT_fpie) ||
5692 A->getOption().matches(options::OPT_fPIE))
5693 CmdArgs.push_back("-pie");
5694 else
5695 CmdArgs.push_back("-no_pie");
5696 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005697
5698 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5699 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5700 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5701 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5702 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5703 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5704 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5705 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5706 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5707 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5708 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5709 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5710 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5711 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5712 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5713 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005714
Daniel Dunbar84384642011-05-02 21:03:47 +00005715 // Give --sysroot= preference, over the Apple specific behavior to also use
5716 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005717 StringRef sysroot = C.getSysRoot();
5718 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005719 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005720 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005721 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5722 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005723 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005724 }
5725
Daniel Dunbarc1964212009-03-26 16:23:12 +00005726 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5727 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5728 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5729 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5730 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005731 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005732 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5733 Args.AddAllArgs(CmdArgs, options::OPT_y);
5734 Args.AddLastArg(CmdArgs, options::OPT_w);
5735 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5736 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5737 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5738 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5739 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5740 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5741 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5742 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5743 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5744 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5745 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5746 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5747}
5748
Alexey Bataev186b28a2014-03-06 05:43:53 +00005749enum LibOpenMP {
5750 LibUnknown,
5751 LibGOMP,
5752 LibIOMP5
5753};
5754
Daniel Dunbarc1964212009-03-26 16:23:12 +00005755void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005756 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005757 const InputInfoList &Inputs,
5758 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005759 const char *LinkingOutput) const {
5760 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005761
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005762 // If the number of arguments surpasses the system limits, we will encode the
5763 // input files in a separate file, shortening the command line. To this end,
5764 // build a list of input file names that can be passed via a file with the
5765 // -filelist linker option.
5766 llvm::opt::ArgStringList InputFileList;
5767
Daniel Dunbarc1964212009-03-26 16:23:12 +00005768 // The logic here is derived from gcc's behavior; most of which
5769 // comes from specs (starting with link_command). Consult gcc for
5770 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005771 ArgStringList CmdArgs;
5772
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005773 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5774 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5775 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005776 for (const auto &Arg : Args)
5777 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005778 const char *Exec =
5779 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5780 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00005781 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005782 return;
5783 }
5784
Daniel Dunbarc1964212009-03-26 16:23:12 +00005785 // I'm not sure why this particular decomposition exists in gcc, but
5786 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005787 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005788
Daniel Dunbarc1964212009-03-26 16:23:12 +00005789 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5790 Args.AddAllArgs(CmdArgs, options::OPT_s);
5791 Args.AddAllArgs(CmdArgs, options::OPT_t);
5792 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5793 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005794 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005795 Args.AddAllArgs(CmdArgs, options::OPT_r);
5796
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005797 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5798 // members of static archive libraries which implement Objective-C classes or
5799 // categories.
5800 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5801 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005802
Daniel Dunbarc1964212009-03-26 16:23:12 +00005803 CmdArgs.push_back("-o");
5804 CmdArgs.push_back(Output.getFilename());
5805
Chad Rosier06fd3c62012-05-16 23:45:12 +00005806 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005807 !Args.hasArg(options::OPT_nostartfiles))
5808 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005809
5810 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005811
Alexey Bataev186b28a2014-03-06 05:43:53 +00005812 LibOpenMP UsedOpenMPLib = LibUnknown;
5813 if (Args.hasArg(options::OPT_fopenmp)) {
5814 UsedOpenMPLib = LibGOMP;
5815 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5816 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5817 .Case("libgomp", LibGOMP)
5818 .Case("libiomp5", LibIOMP5)
5819 .Default(LibUnknown);
5820 if (UsedOpenMPLib == LibUnknown)
5821 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5822 << A->getOption().getName() << A->getValue();
5823 }
5824 switch (UsedOpenMPLib) {
5825 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005826 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005827 break;
5828 case LibIOMP5:
5829 CmdArgs.push_back("-liomp5");
5830 break;
5831 case LibUnknown:
5832 break;
5833 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005834
Douglas Gregor9295df02012-05-15 21:00:27 +00005835 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005836 // Build the input file for -filelist (list of linker input files) in case we
5837 // need it later
5838 for (const auto &II : Inputs) {
5839 if (!II.isFilename()) {
5840 // This is a linker input argument.
5841 // We cannot mix input arguments and file names in a -filelist input, thus
5842 // we prematurely stop our list (remaining files shall be passed as
5843 // arguments).
5844 if (InputFileList.size() > 0)
5845 break;
5846
5847 continue;
5848 }
5849
5850 InputFileList.push_back(II.getFilename());
5851 }
5852
Bob Wilson16d93952012-05-15 18:57:39 +00005853 if (isObjCRuntimeLinked(Args) &&
5854 !Args.hasArg(options::OPT_nostdlib) &&
5855 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005856 // We use arclite library for both ARC and subscripting support.
5857 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5858
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005859 CmdArgs.push_back("-framework");
5860 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005861 // Link libobj.
5862 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005863 }
John McCall31168b02011-06-15 23:02:42 +00005864
Daniel Dunbarc1964212009-03-26 16:23:12 +00005865 if (LinkingOutput) {
5866 CmdArgs.push_back("-arch_multiple");
5867 CmdArgs.push_back("-final_output");
5868 CmdArgs.push_back(LinkingOutput);
5869 }
5870
Daniel Dunbarc1964212009-03-26 16:23:12 +00005871 if (Args.hasArg(options::OPT_fnested_functions))
5872 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005873
Daniel Dunbarc1964212009-03-26 16:23:12 +00005874 if (!Args.hasArg(options::OPT_nostdlib) &&
5875 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005876 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005877 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005878
Daniel Dunbarc1964212009-03-26 16:23:12 +00005879 // link_ssp spec is empty.
5880
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005881 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005882 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005883 }
5884
Chad Rosier06fd3c62012-05-16 23:45:12 +00005885 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005886 !Args.hasArg(options::OPT_nostartfiles)) {
5887 // endfile_spec is empty.
5888 }
5889
5890 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5891 Args.AddAllArgs(CmdArgs, options::OPT_F);
5892
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005893 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005894 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005895 std::unique_ptr<Command> Cmd =
5896 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
5897 Cmd->setInputFileList(std::move(InputFileList));
5898 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005899}
5900
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005901void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005902 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005903 const InputInfoList &Inputs,
5904 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005905 const char *LinkingOutput) const {
5906 ArgStringList CmdArgs;
5907
5908 CmdArgs.push_back("-create");
5909 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005910
5911 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005912 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005913
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005914 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005915 assert(II.isFilename() && "Unexpected lipo input.");
5916 CmdArgs.push_back(II.getFilename());
5917 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005918
5919 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00005920 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005921}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005922
Daniel Dunbar88299622010-06-04 18:28:36 +00005923void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005924 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005925 const InputInfoList &Inputs,
5926 const ArgList &Args,
5927 const char *LinkingOutput) const {
5928 ArgStringList CmdArgs;
5929
Daniel Dunbareb86b042011-05-09 17:23:16 +00005930 CmdArgs.push_back("-o");
5931 CmdArgs.push_back(Output.getFilename());
5932
Daniel Dunbar88299622010-06-04 18:28:36 +00005933 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5934 const InputInfo &Input = Inputs[0];
5935 assert(Input.isFilename() && "Unexpected dsymutil input.");
5936 CmdArgs.push_back(Input.getFilename());
5937
Daniel Dunbar88299622010-06-04 18:28:36 +00005938 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005939 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00005940 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005941}
5942
Eric Christopher551ef452011-08-23 17:56:55 +00005943void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005944 const InputInfo &Output,
5945 const InputInfoList &Inputs,
5946 const ArgList &Args,
5947 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005948 ArgStringList CmdArgs;
5949 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005950 CmdArgs.push_back("--debug-info");
5951 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005952 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005953
5954 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5955 const InputInfo &Input = Inputs[0];
5956 assert(Input.isFilename() && "Unexpected verify input");
5957
5958 // Grabbing the output of the earlier dsymutil run.
5959 CmdArgs.push_back(Input.getFilename());
5960
5961 const char *Exec =
5962 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00005963 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00005964}
5965
David Chisnallf571cde2012-02-15 13:39:01 +00005966void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5967 const InputInfo &Output,
5968 const InputInfoList &Inputs,
5969 const ArgList &Args,
5970 const char *LinkingOutput) const {
5971 ArgStringList CmdArgs;
5972
5973 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5974 options::OPT_Xassembler);
5975
5976 CmdArgs.push_back("-o");
5977 CmdArgs.push_back(Output.getFilename());
5978
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005979 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005980 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005981
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005982 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005983 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00005984}
5985
David Chisnallf571cde2012-02-15 13:39:01 +00005986void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5987 const InputInfo &Output,
5988 const InputInfoList &Inputs,
5989 const ArgList &Args,
5990 const char *LinkingOutput) const {
5991 // FIXME: Find a real GCC, don't hard-code versions here
5992 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5993 const llvm::Triple &T = getToolChain().getTriple();
5994 std::string LibPath = "/usr/lib/";
5995 llvm::Triple::ArchType Arch = T.getArch();
5996 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005997 case llvm::Triple::x86:
5998 GCCLibPath +=
5999 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6000 break;
6001 case llvm::Triple::x86_64:
6002 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6003 GCCLibPath += "/4.5.2/amd64/";
6004 LibPath += "amd64/";
6005 break;
6006 default:
6007 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006008 }
6009
6010 ArgStringList CmdArgs;
6011
David Chisnall272a0712012-02-29 15:06:12 +00006012 // Demangle C++ names in errors
6013 CmdArgs.push_back("-C");
6014
David Chisnallf571cde2012-02-15 13:39:01 +00006015 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6016 (!Args.hasArg(options::OPT_shared))) {
6017 CmdArgs.push_back("-e");
6018 CmdArgs.push_back("_start");
6019 }
6020
6021 if (Args.hasArg(options::OPT_static)) {
6022 CmdArgs.push_back("-Bstatic");
6023 CmdArgs.push_back("-dn");
6024 } else {
6025 CmdArgs.push_back("-Bdynamic");
6026 if (Args.hasArg(options::OPT_shared)) {
6027 CmdArgs.push_back("-shared");
6028 } else {
6029 CmdArgs.push_back("--dynamic-linker");
6030 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6031 }
6032 }
6033
6034 if (Output.isFilename()) {
6035 CmdArgs.push_back("-o");
6036 CmdArgs.push_back(Output.getFilename());
6037 } else {
6038 assert(Output.isNothing() && "Invalid output.");
6039 }
6040
6041 if (!Args.hasArg(options::OPT_nostdlib) &&
6042 !Args.hasArg(options::OPT_nostartfiles)) {
6043 if (!Args.hasArg(options::OPT_shared)) {
6044 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6045 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006046 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006047 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6048 } else {
6049 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006050 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6051 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006052 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006053 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006054 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006055 }
6056
6057 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6058
6059 Args.AddAllArgs(CmdArgs, options::OPT_L);
6060 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6061 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006062 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006063
6064 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6065
6066 if (!Args.hasArg(options::OPT_nostdlib) &&
6067 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006068 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006069 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006070 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006071 if (!Args.hasArg(options::OPT_shared)) {
6072 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006073 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006074 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006075 }
David Chisnallf571cde2012-02-15 13:39:01 +00006076 }
6077
6078 if (!Args.hasArg(options::OPT_nostdlib) &&
6079 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006080 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006081 }
David Chisnall96de9932012-02-16 16:00:47 +00006082 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006083
Alexey Samsonov7811d192014-02-20 13:57:37 +00006084 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006085
6086 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006087 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006088 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006089}
6090
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006091void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006092 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006093 const InputInfoList &Inputs,
6094 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006095 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006096 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006097 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006098
Rafael Espindolacc126272014-02-28 01:55:21 +00006099 switch (getToolChain().getArch()) {
6100 case llvm::Triple::x86:
6101 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6102 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006103 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006104 break;
6105
6106 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006107 CmdArgs.push_back("-mppc");
6108 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006109 break;
6110
6111 case llvm::Triple::sparc:
6112 CmdArgs.push_back("-32");
6113 NeedsKPIC = true;
6114 break;
6115
6116 case llvm::Triple::sparcv9:
6117 CmdArgs.push_back("-64");
6118 CmdArgs.push_back("-Av9a");
6119 NeedsKPIC = true;
6120 break;
6121
6122 case llvm::Triple::mips64:
6123 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006124 StringRef CPUName;
6125 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006126 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006127
6128 CmdArgs.push_back("-mabi");
6129 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6130
6131 if (getToolChain().getArch() == llvm::Triple::mips64)
6132 CmdArgs.push_back("-EB");
6133 else
6134 CmdArgs.push_back("-EL");
6135
Rafael Espindolacc126272014-02-28 01:55:21 +00006136 NeedsKPIC = true;
6137 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006138 }
6139
Rafael Espindolacc126272014-02-28 01:55:21 +00006140 default:
6141 break;
6142 }
6143
6144 if (NeedsKPIC)
6145 addAssemblerKPIC(Args, CmdArgs);
6146
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006147 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6148 options::OPT_Xassembler);
6149
6150 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006151 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006152
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006153 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006154 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006155
6156 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006157 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006158 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006159}
6160
6161void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006162 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006163 const InputInfoList &Inputs,
6164 const ArgList &Args,
6165 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006166 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006167 ArgStringList CmdArgs;
6168
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006169 // Silence warning for "clang -g foo.o -o foo"
6170 Args.ClaimAllArgs(options::OPT_g_Group);
6171 // and "clang -emit-llvm foo.o -o foo"
6172 Args.ClaimAllArgs(options::OPT_emit_llvm);
6173 // and for "clang -w foo.o -o foo". Other warning options are already
6174 // handled somewhere else.
6175 Args.ClaimAllArgs(options::OPT_w);
6176
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006177 if (getToolChain().getArch() == llvm::Triple::mips64)
6178 CmdArgs.push_back("-EB");
6179 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6180 CmdArgs.push_back("-EL");
6181
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006182 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006183 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006184 CmdArgs.push_back("-e");
6185 CmdArgs.push_back("__start");
6186 }
6187
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006188 if (Args.hasArg(options::OPT_static)) {
6189 CmdArgs.push_back("-Bstatic");
6190 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006191 if (Args.hasArg(options::OPT_rdynamic))
6192 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006193 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006194 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006195 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006196 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006197 } else {
6198 CmdArgs.push_back("-dynamic-linker");
6199 CmdArgs.push_back("/usr/libexec/ld.so");
6200 }
6201 }
6202
Rafael Espindola044f7832013-06-05 04:28:55 +00006203 if (Args.hasArg(options::OPT_nopie))
6204 CmdArgs.push_back("-nopie");
6205
Daniel Dunbarb440f562010-08-02 02:38:21 +00006206 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006207 CmdArgs.push_back("-o");
6208 CmdArgs.push_back(Output.getFilename());
6209 } else {
6210 assert(Output.isNothing() && "Invalid output.");
6211 }
6212
6213 if (!Args.hasArg(options::OPT_nostdlib) &&
6214 !Args.hasArg(options::OPT_nostartfiles)) {
6215 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006216 if (Args.hasArg(options::OPT_pg))
6217 CmdArgs.push_back(Args.MakeArgString(
6218 getToolChain().GetFilePath("gcrt0.o")));
6219 else
6220 CmdArgs.push_back(Args.MakeArgString(
6221 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006222 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006223 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006224 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006225 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006226 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006227 }
6228 }
6229
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006230 std::string Triple = getToolChain().getTripleString();
6231 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006232 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006233 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006234 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006235
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006236 Args.AddAllArgs(CmdArgs, options::OPT_L);
6237 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6238 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006239 Args.AddAllArgs(CmdArgs, options::OPT_s);
6240 Args.AddAllArgs(CmdArgs, options::OPT_t);
6241 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6242 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006243
Daniel Dunbar54423b22010-09-17 00:24:54 +00006244 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006245
6246 if (!Args.hasArg(options::OPT_nostdlib) &&
6247 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006248 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006249 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006250 if (Args.hasArg(options::OPT_pg))
6251 CmdArgs.push_back("-lm_p");
6252 else
6253 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006254 }
6255
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006256 // FIXME: For some reason GCC passes -lgcc before adding
6257 // the default system libraries. Just mimic this for now.
6258 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006259
Eric Christopher17674ec2012-09-13 06:32:34 +00006260 if (Args.hasArg(options::OPT_pthread)) {
6261 if (!Args.hasArg(options::OPT_shared) &&
6262 Args.hasArg(options::OPT_pg))
6263 CmdArgs.push_back("-lpthread_p");
6264 else
6265 CmdArgs.push_back("-lpthread");
6266 }
6267
Chandler Carruth45661652011-12-17 22:32:42 +00006268 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006269 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006270 CmdArgs.push_back("-lc_p");
6271 else
6272 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006273 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006274
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006275 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006276 }
6277
6278 if (!Args.hasArg(options::OPT_nostdlib) &&
6279 !Args.hasArg(options::OPT_nostartfiles)) {
6280 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006281 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006282 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006283 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006284 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006285 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006286 }
6287
6288 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006289 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006290 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006291}
Ed Schoutene33194b2009-04-02 19:13:12 +00006292
Eli Friedman9fa28852012-08-08 23:57:20 +00006293void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6294 const InputInfo &Output,
6295 const InputInfoList &Inputs,
6296 const ArgList &Args,
6297 const char *LinkingOutput) const {
6298 ArgStringList CmdArgs;
6299
6300 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6301 options::OPT_Xassembler);
6302
6303 CmdArgs.push_back("-o");
6304 CmdArgs.push_back(Output.getFilename());
6305
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006306 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006307 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006308
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006309 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006310 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006311}
6312
6313void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6314 const InputInfo &Output,
6315 const InputInfoList &Inputs,
6316 const ArgList &Args,
6317 const char *LinkingOutput) const {
6318 const Driver &D = getToolChain().getDriver();
6319 ArgStringList CmdArgs;
6320
6321 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6322 (!Args.hasArg(options::OPT_shared))) {
6323 CmdArgs.push_back("-e");
6324 CmdArgs.push_back("__start");
6325 }
6326
6327 if (Args.hasArg(options::OPT_static)) {
6328 CmdArgs.push_back("-Bstatic");
6329 } else {
6330 if (Args.hasArg(options::OPT_rdynamic))
6331 CmdArgs.push_back("-export-dynamic");
6332 CmdArgs.push_back("--eh-frame-hdr");
6333 CmdArgs.push_back("-Bdynamic");
6334 if (Args.hasArg(options::OPT_shared)) {
6335 CmdArgs.push_back("-shared");
6336 } else {
6337 CmdArgs.push_back("-dynamic-linker");
6338 CmdArgs.push_back("/usr/libexec/ld.so");
6339 }
6340 }
6341
6342 if (Output.isFilename()) {
6343 CmdArgs.push_back("-o");
6344 CmdArgs.push_back(Output.getFilename());
6345 } else {
6346 assert(Output.isNothing() && "Invalid output.");
6347 }
6348
6349 if (!Args.hasArg(options::OPT_nostdlib) &&
6350 !Args.hasArg(options::OPT_nostartfiles)) {
6351 if (!Args.hasArg(options::OPT_shared)) {
6352 if (Args.hasArg(options::OPT_pg))
6353 CmdArgs.push_back(Args.MakeArgString(
6354 getToolChain().GetFilePath("gcrt0.o")));
6355 else
6356 CmdArgs.push_back(Args.MakeArgString(
6357 getToolChain().GetFilePath("crt0.o")));
6358 CmdArgs.push_back(Args.MakeArgString(
6359 getToolChain().GetFilePath("crtbegin.o")));
6360 } else {
6361 CmdArgs.push_back(Args.MakeArgString(
6362 getToolChain().GetFilePath("crtbeginS.o")));
6363 }
6364 }
6365
6366 Args.AddAllArgs(CmdArgs, options::OPT_L);
6367 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6368 Args.AddAllArgs(CmdArgs, options::OPT_e);
6369
6370 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6371
6372 if (!Args.hasArg(options::OPT_nostdlib) &&
6373 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006374 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006375 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6376 if (Args.hasArg(options::OPT_pg))
6377 CmdArgs.push_back("-lm_p");
6378 else
6379 CmdArgs.push_back("-lm");
6380 }
6381
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006382 if (Args.hasArg(options::OPT_pthread)) {
6383 if (!Args.hasArg(options::OPT_shared) &&
6384 Args.hasArg(options::OPT_pg))
6385 CmdArgs.push_back("-lpthread_p");
6386 else
6387 CmdArgs.push_back("-lpthread");
6388 }
6389
Eli Friedman9fa28852012-08-08 23:57:20 +00006390 if (!Args.hasArg(options::OPT_shared)) {
6391 if (Args.hasArg(options::OPT_pg))
6392 CmdArgs.push_back("-lc_p");
6393 else
6394 CmdArgs.push_back("-lc");
6395 }
6396
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006397 StringRef MyArch;
6398 switch (getToolChain().getTriple().getArch()) {
6399 case llvm::Triple::arm:
6400 MyArch = "arm";
6401 break;
6402 case llvm::Triple::x86:
6403 MyArch = "i386";
6404 break;
6405 case llvm::Triple::x86_64:
6406 MyArch = "amd64";
6407 break;
6408 default:
6409 llvm_unreachable("Unsupported architecture");
6410 }
6411 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006412 }
6413
6414 if (!Args.hasArg(options::OPT_nostdlib) &&
6415 !Args.hasArg(options::OPT_nostartfiles)) {
6416 if (!Args.hasArg(options::OPT_shared))
6417 CmdArgs.push_back(Args.MakeArgString(
6418 getToolChain().GetFilePath("crtend.o")));
6419 else
6420 CmdArgs.push_back(Args.MakeArgString(
6421 getToolChain().GetFilePath("crtendS.o")));
6422 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006423
6424 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006425 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006426 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006427}
6428
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006429void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006430 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006431 const InputInfoList &Inputs,
6432 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006433 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006434 ArgStringList CmdArgs;
6435
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006436 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6437 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006438 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006439 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006440 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006441 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006442 else if (getToolChain().getArch() == llvm::Triple::mips ||
6443 getToolChain().getArch() == llvm::Triple::mipsel ||
6444 getToolChain().getArch() == llvm::Triple::mips64 ||
6445 getToolChain().getArch() == llvm::Triple::mips64el) {
6446 StringRef CPUName;
6447 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006448 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006449
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006450 CmdArgs.push_back("-march");
6451 CmdArgs.push_back(CPUName.data());
6452
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006453 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006454 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006455
6456 if (getToolChain().getArch() == llvm::Triple::mips ||
6457 getToolChain().getArch() == llvm::Triple::mips64)
6458 CmdArgs.push_back("-EB");
6459 else
6460 CmdArgs.push_back("-EL");
6461
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006462 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006463 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006464 getToolChain().getArch() == llvm::Triple::armeb ||
6465 getToolChain().getArch() == llvm::Triple::thumb ||
6466 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006467 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006468 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006469 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6470
6471 if (FloatABI == "hard") {
6472 CmdArgs.push_back("-mfpu=vfp");
6473 } else {
6474 CmdArgs.push_back("-mfpu=softvfp");
6475 }
6476
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006477 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006478 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006479 case llvm::Triple::GNUEABI:
6480 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006481 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006482 break;
6483
6484 default:
6485 CmdArgs.push_back("-matpcs");
6486 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006487 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006488 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006489 if (getToolChain().getArch() == llvm::Triple::sparc)
6490 CmdArgs.push_back("-Av8plusa");
6491 else
6492 CmdArgs.push_back("-Av9a");
6493
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006494 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006495 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006496
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006497 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6498 options::OPT_Xassembler);
6499
6500 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006501 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006502
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006503 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006504 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006505
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006506 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006507 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006508}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006509
6510void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006511 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006512 const InputInfoList &Inputs,
6513 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006514 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006515 const toolchains::FreeBSD& ToolChain =
6516 static_cast<const toolchains::FreeBSD&>(getToolChain());
6517 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006518 const bool IsPIE =
6519 !Args.hasArg(options::OPT_shared) &&
6520 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006521 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006522
6523 // Silence warning for "clang -g foo.o -o foo"
6524 Args.ClaimAllArgs(options::OPT_g_Group);
6525 // and "clang -emit-llvm foo.o -o foo"
6526 Args.ClaimAllArgs(options::OPT_emit_llvm);
6527 // and for "clang -w foo.o -o foo". Other warning options are already
6528 // handled somewhere else.
6529 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006530
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006531 if (!D.SysRoot.empty())
6532 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6533
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006534 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006535 CmdArgs.push_back("-pie");
6536
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006537 if (Args.hasArg(options::OPT_static)) {
6538 CmdArgs.push_back("-Bstatic");
6539 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006540 if (Args.hasArg(options::OPT_rdynamic))
6541 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006542 CmdArgs.push_back("--eh-frame-hdr");
6543 if (Args.hasArg(options::OPT_shared)) {
6544 CmdArgs.push_back("-Bshareable");
6545 } else {
6546 CmdArgs.push_back("-dynamic-linker");
6547 CmdArgs.push_back("/libexec/ld-elf.so.1");
6548 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006549 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6550 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006551 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6552 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6553 CmdArgs.push_back("--hash-style=both");
6554 }
6555 }
6556 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006557 }
6558
6559 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6560 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006561 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006562 CmdArgs.push_back("-m");
6563 CmdArgs.push_back("elf_i386_fbsd");
6564 }
6565
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006566 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006567 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006568 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006569 }
6570
Daniel Dunbarb440f562010-08-02 02:38:21 +00006571 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006572 CmdArgs.push_back("-o");
6573 CmdArgs.push_back(Output.getFilename());
6574 } else {
6575 assert(Output.isNothing() && "Invalid output.");
6576 }
6577
6578 if (!Args.hasArg(options::OPT_nostdlib) &&
6579 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006580 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006581 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006582 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006583 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006584 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006585 crt1 = "Scrt1.o";
6586 else
6587 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006588 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006589 if (crt1)
6590 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6591
6592 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6593
Craig Topper92fc2df2014-05-17 16:56:41 +00006594 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006595 if (Args.hasArg(options::OPT_static))
6596 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006597 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006598 crtbegin = "crtbeginS.o";
6599 else
6600 crtbegin = "crtbegin.o";
6601
6602 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006603 }
6604
6605 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00006606 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006607 for (const auto &Path : Paths)
6608 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006609 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6610 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006611 Args.AddAllArgs(CmdArgs, options::OPT_s);
6612 Args.AddAllArgs(CmdArgs, options::OPT_t);
6613 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6614 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006615
Alp Tokerce365ca2013-12-02 12:43:03 +00006616 if (D.IsUsingLTO(Args))
6617 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006618
Alexey Samsonov52550342014-09-15 19:58:40 +00006619 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00006620 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006621
6622 if (!Args.hasArg(options::OPT_nostdlib) &&
6623 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006624 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006625 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006626 if (Args.hasArg(options::OPT_pg))
6627 CmdArgs.push_back("-lm_p");
6628 else
6629 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006630 }
Alexey Samsonov52550342014-09-15 19:58:40 +00006631 if (NeedsSanitizerDeps)
6632 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006633 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6634 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006635 if (Args.hasArg(options::OPT_pg))
6636 CmdArgs.push_back("-lgcc_p");
6637 else
6638 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006639 if (Args.hasArg(options::OPT_static)) {
6640 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006641 } else if (Args.hasArg(options::OPT_pg)) {
6642 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006643 } else {
6644 CmdArgs.push_back("--as-needed");
6645 CmdArgs.push_back("-lgcc_s");
6646 CmdArgs.push_back("--no-as-needed");
6647 }
6648
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006649 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006650 if (Args.hasArg(options::OPT_pg))
6651 CmdArgs.push_back("-lpthread_p");
6652 else
6653 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006654 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006655
Roman Divacky66f22762011-02-10 16:59:40 +00006656 if (Args.hasArg(options::OPT_pg)) {
6657 if (Args.hasArg(options::OPT_shared))
6658 CmdArgs.push_back("-lc");
6659 else
6660 CmdArgs.push_back("-lc_p");
6661 CmdArgs.push_back("-lgcc_p");
6662 } else {
6663 CmdArgs.push_back("-lc");
6664 CmdArgs.push_back("-lgcc");
6665 }
6666
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006667 if (Args.hasArg(options::OPT_static)) {
6668 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006669 } else if (Args.hasArg(options::OPT_pg)) {
6670 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006671 } else {
6672 CmdArgs.push_back("--as-needed");
6673 CmdArgs.push_back("-lgcc_s");
6674 CmdArgs.push_back("--no-as-needed");
6675 }
6676 }
6677
6678 if (!Args.hasArg(options::OPT_nostdlib) &&
6679 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006680 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006681 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006682 else
6683 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006684 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006685 }
6686
Alexey Samsonov7811d192014-02-20 13:57:37 +00006687 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006688
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006689 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006690 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006691 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006692}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006693
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006694void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6695 const InputInfo &Output,
6696 const InputInfoList &Inputs,
6697 const ArgList &Args,
6698 const char *LinkingOutput) const {
6699 ArgStringList CmdArgs;
6700
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006701 // GNU as needs different flags for creating the correct output format
6702 // on architectures with different ABIs or optional feature sets.
6703 switch (getToolChain().getArch()) {
6704 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006705 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006706 break;
6707 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006708 case llvm::Triple::armeb:
6709 case llvm::Triple::thumb:
6710 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006711 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006712 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006713 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006714 }
6715
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006716 case llvm::Triple::mips:
6717 case llvm::Triple::mipsel:
6718 case llvm::Triple::mips64:
6719 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006720 StringRef CPUName;
6721 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006722 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006723
6724 CmdArgs.push_back("-march");
6725 CmdArgs.push_back(CPUName.data());
6726
6727 CmdArgs.push_back("-mabi");
6728 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6729
6730 if (getToolChain().getArch() == llvm::Triple::mips ||
6731 getToolChain().getArch() == llvm::Triple::mips64)
6732 CmdArgs.push_back("-EB");
6733 else
6734 CmdArgs.push_back("-EL");
6735
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006736 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006737 break;
6738 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006739
6740 case llvm::Triple::sparc:
6741 CmdArgs.push_back("-32");
6742 addAssemblerKPIC(Args, CmdArgs);
6743 break;
6744
6745 case llvm::Triple::sparcv9:
6746 CmdArgs.push_back("-64");
6747 CmdArgs.push_back("-Av9");
6748 addAssemblerKPIC(Args, CmdArgs);
6749 break;
6750
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006751 default:
6752 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006753 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006754
6755 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6756 options::OPT_Xassembler);
6757
6758 CmdArgs.push_back("-o");
6759 CmdArgs.push_back(Output.getFilename());
6760
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006761 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006762 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006763
David Chisnallddbd68f2011-09-27 22:03:18 +00006764 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00006765 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006766}
6767
6768void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6769 const InputInfo &Output,
6770 const InputInfoList &Inputs,
6771 const ArgList &Args,
6772 const char *LinkingOutput) const {
6773 const Driver &D = getToolChain().getDriver();
6774 ArgStringList CmdArgs;
6775
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006776 if (!D.SysRoot.empty())
6777 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6778
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006779 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006780 if (Args.hasArg(options::OPT_static)) {
6781 CmdArgs.push_back("-Bstatic");
6782 } else {
6783 if (Args.hasArg(options::OPT_rdynamic))
6784 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006785 if (Args.hasArg(options::OPT_shared)) {
6786 CmdArgs.push_back("-Bshareable");
6787 } else {
6788 CmdArgs.push_back("-dynamic-linker");
6789 CmdArgs.push_back("/libexec/ld.elf_so");
6790 }
6791 }
6792
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006793 // Many NetBSD architectures support more than one ABI.
6794 // Determine the correct emulation for ld.
6795 switch (getToolChain().getArch()) {
6796 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006797 CmdArgs.push_back("-m");
6798 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006799 break;
6800 case llvm::Triple::arm:
6801 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006802 CmdArgs.push_back("-m");
6803 switch (getToolChain().getTriple().getEnvironment()) {
6804 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006805 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006806 CmdArgs.push_back("armelf_nbsd_eabi");
6807 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006808 case llvm::Triple::EABIHF:
6809 case llvm::Triple::GNUEABIHF:
6810 CmdArgs.push_back("armelf_nbsd_eabihf");
6811 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006812 default:
6813 CmdArgs.push_back("armelf_nbsd");
6814 break;
6815 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006816 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00006817 case llvm::Triple::armeb:
6818 case llvm::Triple::thumbeb:
6819 CmdArgs.push_back("-m");
6820 switch (getToolChain().getTriple().getEnvironment()) {
6821 case llvm::Triple::EABI:
6822 case llvm::Triple::GNUEABI:
6823 CmdArgs.push_back("armelfb_nbsd_eabi");
6824 break;
6825 case llvm::Triple::EABIHF:
6826 case llvm::Triple::GNUEABIHF:
6827 CmdArgs.push_back("armelfb_nbsd_eabihf");
6828 break;
6829 default:
6830 CmdArgs.push_back("armelfb_nbsd");
6831 break;
6832 }
6833 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006834 case llvm::Triple::mips64:
6835 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006836 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006837 CmdArgs.push_back("-m");
6838 if (getToolChain().getArch() == llvm::Triple::mips64)
6839 CmdArgs.push_back("elf32btsmip");
6840 else
6841 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006842 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006843 CmdArgs.push_back("-m");
6844 if (getToolChain().getArch() == llvm::Triple::mips64)
6845 CmdArgs.push_back("elf64btsmip");
6846 else
6847 CmdArgs.push_back("elf64ltsmip");
6848 }
6849 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006850 case llvm::Triple::ppc:
6851 CmdArgs.push_back("-m");
6852 CmdArgs.push_back("elf32ppc_nbsd");
6853 break;
6854
6855 case llvm::Triple::ppc64:
6856 case llvm::Triple::ppc64le:
6857 CmdArgs.push_back("-m");
6858 CmdArgs.push_back("elf64ppc");
6859 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006860
6861 case llvm::Triple::sparc:
6862 CmdArgs.push_back("-m");
6863 CmdArgs.push_back("elf32_sparc");
6864 break;
6865
6866 case llvm::Triple::sparcv9:
6867 CmdArgs.push_back("-m");
6868 CmdArgs.push_back("elf64_sparc");
6869 break;
6870
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006871 default:
6872 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006873 }
6874
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006875 if (Output.isFilename()) {
6876 CmdArgs.push_back("-o");
6877 CmdArgs.push_back(Output.getFilename());
6878 } else {
6879 assert(Output.isNothing() && "Invalid output.");
6880 }
6881
6882 if (!Args.hasArg(options::OPT_nostdlib) &&
6883 !Args.hasArg(options::OPT_nostartfiles)) {
6884 if (!Args.hasArg(options::OPT_shared)) {
6885 CmdArgs.push_back(Args.MakeArgString(
6886 getToolChain().GetFilePath("crt0.o")));
6887 CmdArgs.push_back(Args.MakeArgString(
6888 getToolChain().GetFilePath("crti.o")));
6889 CmdArgs.push_back(Args.MakeArgString(
6890 getToolChain().GetFilePath("crtbegin.o")));
6891 } else {
6892 CmdArgs.push_back(Args.MakeArgString(
6893 getToolChain().GetFilePath("crti.o")));
6894 CmdArgs.push_back(Args.MakeArgString(
6895 getToolChain().GetFilePath("crtbeginS.o")));
6896 }
6897 }
6898
6899 Args.AddAllArgs(CmdArgs, options::OPT_L);
6900 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6901 Args.AddAllArgs(CmdArgs, options::OPT_e);
6902 Args.AddAllArgs(CmdArgs, options::OPT_s);
6903 Args.AddAllArgs(CmdArgs, options::OPT_t);
6904 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6905 Args.AddAllArgs(CmdArgs, options::OPT_r);
6906
6907 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6908
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006909 unsigned Major, Minor, Micro;
6910 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6911 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006912 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006913 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00006914 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006915 case llvm::Triple::arm:
6916 case llvm::Triple::armeb:
6917 case llvm::Triple::thumb:
6918 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006919 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006920 case llvm::Triple::ppc64:
6921 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006922 case llvm::Triple::x86:
6923 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006924 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006925 break;
6926 default:
6927 break;
6928 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006929 }
6930
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006931 if (!Args.hasArg(options::OPT_nostdlib) &&
6932 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006933 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006934 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6935 CmdArgs.push_back("-lm");
6936 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006937 if (Args.hasArg(options::OPT_pthread))
6938 CmdArgs.push_back("-lpthread");
6939 CmdArgs.push_back("-lc");
6940
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006941 if (useLibgcc) {
6942 if (Args.hasArg(options::OPT_static)) {
6943 // libgcc_eh depends on libc, so resolve as much as possible,
6944 // pull in any new requirements from libc and then get the rest
6945 // of libgcc.
6946 CmdArgs.push_back("-lgcc_eh");
6947 CmdArgs.push_back("-lc");
6948 CmdArgs.push_back("-lgcc");
6949 } else {
6950 CmdArgs.push_back("-lgcc");
6951 CmdArgs.push_back("--as-needed");
6952 CmdArgs.push_back("-lgcc_s");
6953 CmdArgs.push_back("--no-as-needed");
6954 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006955 }
6956 }
6957
6958 if (!Args.hasArg(options::OPT_nostdlib) &&
6959 !Args.hasArg(options::OPT_nostartfiles)) {
6960 if (!Args.hasArg(options::OPT_shared))
6961 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6962 "crtend.o")));
6963 else
6964 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6965 "crtendS.o")));
6966 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6967 "crtn.o")));
6968 }
6969
Alexey Samsonov7811d192014-02-20 13:57:37 +00006970 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006971
Logan Chieneb9162f2014-06-26 14:23:45 +00006972 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006973 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006974}
6975
Thomas Schwinge4e555262013-03-28 19:04:25 +00006976void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6977 const InputInfo &Output,
6978 const InputInfoList &Inputs,
6979 const ArgList &Args,
6980 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006981 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006982 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006983
6984 // Add --32/--64 to make sure we get the format we want.
6985 // This is incomplete
6986 if (getToolChain().getArch() == llvm::Triple::x86) {
6987 CmdArgs.push_back("--32");
6988 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00006989 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
6990 CmdArgs.push_back("--x32");
6991 else
6992 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006993 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6994 CmdArgs.push_back("-a32");
6995 CmdArgs.push_back("-mppc");
6996 CmdArgs.push_back("-many");
6997 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6998 CmdArgs.push_back("-a64");
6999 CmdArgs.push_back("-mppc64");
7000 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00007001 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
7002 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007003 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007004 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007005 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007006 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
7007 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007008 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007009 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007010 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
7011 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007012 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007013 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007014 } else if (getToolChain().getArch() == llvm::Triple::arm ||
7015 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007016 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00007017 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
7018 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007019 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
7020 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00007021 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007022
Tim Northover9c7e0352013-12-12 11:55:52 +00007023 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7024 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007025 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007026
7027 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007028
7029 // FIXME: remove krait check when GNU tools support krait cpu
7030 // for now replace it with -march=armv7-a to avoid a lower
7031 // march from being picked in the absence of a cpu flag.
7032 Arg *A;
7033 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7034 StringRef(A->getValue()) == "krait")
7035 CmdArgs.push_back("-march=armv7-a");
7036 else
7037 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007038 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007039 } else if (getToolChain().getArch() == llvm::Triple::mips ||
7040 getToolChain().getArch() == llvm::Triple::mipsel ||
7041 getToolChain().getArch() == llvm::Triple::mips64 ||
7042 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007043 StringRef CPUName;
7044 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007045 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007046 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007047
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007048 CmdArgs.push_back("-march");
7049 CmdArgs.push_back(CPUName.data());
7050
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007051 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007052 CmdArgs.push_back(ABIName.data());
7053
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007054 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7055 // or -mshared (not implemented) is in effect.
7056 bool IsPicOrPie = false;
7057 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7058 options::OPT_fpic, options::OPT_fno_pic,
7059 options::OPT_fPIE, options::OPT_fno_PIE,
7060 options::OPT_fpie, options::OPT_fno_pie)) {
7061 if (A->getOption().matches(options::OPT_fPIC) ||
7062 A->getOption().matches(options::OPT_fpic) ||
7063 A->getOption().matches(options::OPT_fPIE) ||
7064 A->getOption().matches(options::OPT_fpie))
7065 IsPicOrPie = true;
7066 }
7067 if (!IsPicOrPie)
7068 CmdArgs.push_back("-mno-shared");
7069
Daniel Sanders379d44b2014-07-16 11:52:23 +00007070 // LLVM doesn't support -mplt yet and acts as if it is always given.
7071 // However, -mplt has no effect with the N64 ABI.
7072 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007073
7074 if (getToolChain().getArch() == llvm::Triple::mips ||
7075 getToolChain().getArch() == llvm::Triple::mips64)
7076 CmdArgs.push_back("-EB");
7077 else
7078 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007079
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007080 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7081 if (StringRef(A->getValue()) == "2008")
7082 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7083 }
7084
Daniel Sanders379d44b2014-07-16 11:52:23 +00007085 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7086 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7087 options::OPT_mfp64)) {
7088 A->claim();
7089 A->render(Args, CmdArgs);
7090 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7091 ABIName))
7092 CmdArgs.push_back("-mfpxx");
7093
7094 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7095 // -mno-mips16 is actually -no-mips16.
7096 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7097 options::OPT_mno_mips16)) {
7098 if (A->getOption().matches(options::OPT_mips16)) {
7099 A->claim();
7100 A->render(Args, CmdArgs);
7101 } else {
7102 A->claim();
7103 CmdArgs.push_back("-no-mips16");
7104 }
7105 }
7106
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007107 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7108 options::OPT_mno_micromips);
7109 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7110 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7111
Simon Atanasyanbd986632013-11-26 11:58:04 +00007112 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7113 // Do not use AddLastArg because not all versions of MIPS assembler
7114 // support -mmsa / -mno-msa options.
7115 if (A->getOption().matches(options::OPT_mmsa))
7116 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7117 }
7118
Daniel Sanders379d44b2014-07-16 11:52:23 +00007119 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7120 options::OPT_msoft_float);
7121
7122 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7123 options::OPT_mno_odd_spreg);
7124
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007125 NeedsKPIC = true;
7126 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7127 // Always pass an -march option, since our default of z10 is later
7128 // than the GNU assembler's default.
7129 StringRef CPUName = getSystemZTargetCPU(Args);
7130 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7131 }
7132
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007133 if (NeedsKPIC)
7134 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007135
7136 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7137 options::OPT_Xassembler);
7138
7139 CmdArgs.push_back("-o");
7140 CmdArgs.push_back(Output.getFilename());
7141
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007142 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007143 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007144
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007145 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007146 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007147
7148 // Handle the debug info splitting at object creation time if we're
7149 // creating an object.
7150 // TODO: Currently only works on linux with newer objcopy.
7151 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007152 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007153 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7154 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007155}
7156
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007157static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007158 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007159 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007160 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7161 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007162 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007163 CmdArgs.push_back("-lgcc");
7164
Logan Chien3d3373c2012-11-19 12:04:11 +00007165 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007166 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007167 CmdArgs.push_back("-lgcc");
7168 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007169 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007170 CmdArgs.push_back("--as-needed");
7171 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007172 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007173 CmdArgs.push_back("--no-as-needed");
7174 }
7175
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007176 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007177 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007178 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007179 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007180
7181 // According to Android ABI, we have to link with libdl if we are
7182 // linking with non-static libgcc.
7183 //
7184 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7185 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7186 if (isAndroid && !StaticLibgcc)
7187 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007188}
7189
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007190static std::string getLinuxDynamicLinker(const ArgList &Args,
7191 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007192 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7193 if (ToolChain.getTriple().isArch64Bit())
7194 return "/system/bin/linker64";
7195 else
7196 return "/system/bin/linker";
7197 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7198 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007199 return "/lib/ld-linux.so.2";
Tim Northover40956e62014-07-23 12:32:58 +00007200 else if (ToolChain.getArch() == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007201 return "/lib/ld-linux-aarch64.so.1";
Tim Northover40956e62014-07-23 12:32:58 +00007202 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007203 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007204 else if (ToolChain.getArch() == llvm::Triple::arm ||
7205 ToolChain.getArch() == llvm::Triple::thumb) {
7206 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7207 return "/lib/ld-linux-armhf.so.3";
7208 else
7209 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007210 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7211 ToolChain.getArch() == llvm::Triple::thumbeb) {
7212 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7213 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7214 else
7215 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007216 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007217 ToolChain.getArch() == llvm::Triple::mipsel ||
7218 ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007219 ToolChain.getArch() == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007220 StringRef CPUName;
7221 StringRef ABIName;
7222 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7223 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7224
7225 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7226 .Case("o32", "/lib")
7227 .Case("n32", "/lib32")
7228 .Case("n64", "/lib64")
7229 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007230 StringRef LibName;
7231 if (mips::isUCLibc(Args))
7232 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7233 else
7234 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007235
7236 return (LibDir + "/" + LibName).str();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007237 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7238 return "/lib/ld.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007239 else if (ToolChain.getArch() == llvm::Triple::ppc64) {
7240 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7241 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007242 return "/lib64/ld64.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007243 } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
7244 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7245 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007246 return "/lib64/ld64.so.2";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007247 } else if (ToolChain.getArch() == llvm::Triple::systemz)
7248 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007249 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7250 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007251 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7252 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7253 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007254 else
7255 return "/lib64/ld-linux-x86-64.so.2";
7256}
7257
Renato Golinc4b49242014-02-13 10:01:16 +00007258static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7259 ArgStringList &CmdArgs, const ArgList &Args) {
7260 // Make use of compiler-rt if --rtlib option is used
7261 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7262
7263 switch(RLT) {
7264 case ToolChain::RLT_CompilerRT:
7265 addClangRTLinux(TC, Args, CmdArgs);
7266 break;
7267 case ToolChain::RLT_Libgcc:
7268 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7269 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007270 }
7271}
7272
Rafael Espindola1e085772014-08-15 17:14:35 +00007273static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7274 switch (T.getArch()) {
7275 case llvm::Triple::x86:
7276 return "elf_i386";
7277 case llvm::Triple::aarch64:
7278 return "aarch64linux";
7279 case llvm::Triple::aarch64_be:
7280 return "aarch64_be_linux";
7281 case llvm::Triple::arm:
7282 case llvm::Triple::thumb:
7283 return "armelf_linux_eabi";
7284 case llvm::Triple::armeb:
7285 case llvm::Triple::thumbeb:
7286 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7287 case llvm::Triple::ppc:
7288 return "elf32ppclinux";
7289 case llvm::Triple::ppc64:
7290 return "elf64ppc";
7291 case llvm::Triple::ppc64le:
7292 return "elf64lppc";
7293 case llvm::Triple::sparc:
7294 return "elf32_sparc";
7295 case llvm::Triple::sparcv9:
7296 return "elf64_sparc";
7297 case llvm::Triple::mips:
7298 return "elf32btsmip";
7299 case llvm::Triple::mipsel:
7300 return "elf32ltsmip";
7301 case llvm::Triple::mips64:
7302 if (mips::hasMipsAbiArg(Args, "n32"))
7303 return "elf32btsmipn32";
7304 return "elf64btsmip";
7305 case llvm::Triple::mips64el:
7306 if (mips::hasMipsAbiArg(Args, "n32"))
7307 return "elf32ltsmipn32";
7308 return "elf64ltsmip";
7309 case llvm::Triple::systemz:
7310 return "elf64_s390";
7311 case llvm::Triple::x86_64:
7312 if (T.getEnvironment() == llvm::Triple::GNUX32)
7313 return "elf32_x86_64";
7314 return "elf_x86_64";
7315 default:
7316 llvm_unreachable("Unexpected arch");
7317 }
7318}
7319
Thomas Schwinge4e555262013-03-28 19:04:25 +00007320void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7321 const InputInfo &Output,
7322 const InputInfoList &Inputs,
7323 const ArgList &Args,
7324 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007325 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007326 static_cast<const toolchains::Linux&>(getToolChain());
7327 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007328 const bool isAndroid =
7329 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007330 const bool IsPIE =
7331 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007332 !Args.hasArg(options::OPT_static) &&
7333 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7334 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007335 // Cannot use isPIEDefault here since otherwise
7336 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007337 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007338
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007339 ArgStringList CmdArgs;
7340
Rafael Espindolad1002f62010-11-15 18:28:16 +00007341 // Silence warning for "clang -g foo.o -o foo"
7342 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007343 // and "clang -emit-llvm foo.o -o foo"
7344 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007345 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007346 // handled somewhere else.
7347 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007348
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007349 if (!D.SysRoot.empty())
7350 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007351
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007352 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007353 CmdArgs.push_back("-pie");
7354
Rafael Espindola1c76c592010-11-07 22:57:16 +00007355 if (Args.hasArg(options::OPT_rdynamic))
7356 CmdArgs.push_back("-export-dynamic");
7357
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007358 if (Args.hasArg(options::OPT_s))
7359 CmdArgs.push_back("-s");
7360
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007361 for (const auto &Opt : ToolChain.ExtraOpts)
7362 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007363
7364 if (!Args.hasArg(options::OPT_static)) {
7365 CmdArgs.push_back("--eh-frame-hdr");
7366 }
7367
7368 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007369 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007370
7371 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007372 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007373 ToolChain.getArch() == llvm::Triple::armeb ||
7374 ToolChain.getArch() == llvm::Triple::thumb ||
7375 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007376 CmdArgs.push_back("-Bstatic");
7377 else
7378 CmdArgs.push_back("-static");
7379 } else if (Args.hasArg(options::OPT_shared)) {
7380 CmdArgs.push_back("-shared");
7381 }
7382
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007383 if (ToolChain.getArch() == llvm::Triple::arm ||
7384 ToolChain.getArch() == llvm::Triple::armeb ||
7385 ToolChain.getArch() == llvm::Triple::thumb ||
7386 ToolChain.getArch() == llvm::Triple::thumbeb ||
7387 (!Args.hasArg(options::OPT_static) &&
7388 !Args.hasArg(options::OPT_shared))) {
7389 CmdArgs.push_back("-dynamic-linker");
7390 CmdArgs.push_back(Args.MakeArgString(
7391 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7392 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007393
7394 CmdArgs.push_back("-o");
7395 CmdArgs.push_back(Output.getFilename());
7396
Rafael Espindola81937ec2010-12-01 01:52:43 +00007397 if (!Args.hasArg(options::OPT_nostdlib) &&
7398 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007399 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007400 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007401 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007402 if (Args.hasArg(options::OPT_pg))
7403 crt1 = "gcrt1.o";
7404 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007405 crt1 = "Scrt1.o";
7406 else
7407 crt1 = "crt1.o";
7408 }
7409 if (crt1)
7410 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007411
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007412 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7413 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007414
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007415 const char *crtbegin;
7416 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007417 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007418 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007419 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007420 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007421 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007422 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007423 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007424 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007425
7426 // Add crtfastmath.o if available and fast math is enabled.
7427 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007428 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007429
7430 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007431 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007432
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007433 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007434
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007435 for (const auto &Path : Paths)
7436 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007437
Alp Tokerce365ca2013-12-02 12:43:03 +00007438 if (D.IsUsingLTO(Args))
7439 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007440
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007441 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7442 CmdArgs.push_back("--no-demangle");
7443
Alexey Samsonov52550342014-09-15 19:58:40 +00007444 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007445 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007446 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007447 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007448
Hans Wennborg70850d82013-07-18 20:29:38 +00007449 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007450 !Args.hasArg(options::OPT_nostdlib) &&
7451 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007452 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7453 !Args.hasArg(options::OPT_static);
7454 if (OnlyLibstdcxxStatic)
7455 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007456 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007457 if (OnlyLibstdcxxStatic)
7458 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007459 CmdArgs.push_back("-lm");
7460 }
7461
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007462 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007463 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7464 if (Args.hasArg(options::OPT_static))
7465 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007466
Alexey Samsonov52550342014-09-15 19:58:40 +00007467 if (NeedsSanitizerDeps)
7468 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7469
Alexey Bataev186b28a2014-03-06 05:43:53 +00007470 LibOpenMP UsedOpenMPLib = LibUnknown;
7471 if (Args.hasArg(options::OPT_fopenmp)) {
7472 UsedOpenMPLib = LibGOMP;
7473 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7474 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7475 .Case("libgomp", LibGOMP)
7476 .Case("libiomp5", LibIOMP5)
7477 .Default(LibUnknown);
7478 if (UsedOpenMPLib == LibUnknown)
7479 D.Diag(diag::err_drv_unsupported_option_argument)
7480 << A->getOption().getName() << A->getValue();
7481 }
7482 switch (UsedOpenMPLib) {
7483 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007484 CmdArgs.push_back("-lgomp");
7485
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007486 // FIXME: Exclude this for platforms with libgomp that don't require
7487 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007488 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007489 break;
7490 case LibIOMP5:
7491 CmdArgs.push_back("-liomp5");
7492 break;
7493 case LibUnknown:
7494 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007495 }
Renato Golinc4b49242014-02-13 10:01:16 +00007496 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007497
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007498 if ((Args.hasArg(options::OPT_pthread) ||
7499 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7500 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007501 CmdArgs.push_back("-lpthread");
7502
7503 CmdArgs.push_back("-lc");
7504
7505 if (Args.hasArg(options::OPT_static))
7506 CmdArgs.push_back("--end-group");
7507 else
Renato Golinc4b49242014-02-13 10:01:16 +00007508 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007509 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007510
Rafael Espindola81937ec2010-12-01 01:52:43 +00007511 if (!Args.hasArg(options::OPT_nostartfiles)) {
7512 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007513 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007514 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007515 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007516 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007517 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007518 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007519
Rafael Espindola81937ec2010-12-01 01:52:43 +00007520 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007521 if (!isAndroid)
7522 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007523 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007524 }
7525
David Blaikiec11bf802014-09-04 16:04:28 +00007526 C.addCommand(
7527 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007528}
7529
Chris Lattner3e2ee142010-07-07 16:01:42 +00007530void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007531 const InputInfo &Output,
7532 const InputInfoList &Inputs,
7533 const ArgList &Args,
7534 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007535 ArgStringList CmdArgs;
7536
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007537 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007538
7539 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007540 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007541
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007542 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007543 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007544
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007545 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007546 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007547}
7548
7549void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007550 const InputInfo &Output,
7551 const InputInfoList &Inputs,
7552 const ArgList &Args,
7553 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007554 const Driver &D = getToolChain().getDriver();
7555 ArgStringList CmdArgs;
7556
Daniel Dunbarb440f562010-08-02 02:38:21 +00007557 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007558 CmdArgs.push_back("-o");
7559 CmdArgs.push_back(Output.getFilename());
7560 } else {
7561 assert(Output.isNothing() && "Invalid output.");
7562 }
7563
7564 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007565 !Args.hasArg(options::OPT_nostartfiles)) {
7566 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7567 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7568 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7569 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7570 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007571
7572 Args.AddAllArgs(CmdArgs, options::OPT_L);
7573 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7574 Args.AddAllArgs(CmdArgs, options::OPT_e);
7575
Daniel Dunbar54423b22010-09-17 00:24:54 +00007576 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007577
Alexey Samsonov7811d192014-02-20 13:57:37 +00007578 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007579
Chris Lattner3e2ee142010-07-07 16:01:42 +00007580 if (!Args.hasArg(options::OPT_nostdlib) &&
7581 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007582 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007583 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007584 CmdArgs.push_back("-lm");
7585 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007586 }
7587
7588 if (!Args.hasArg(options::OPT_nostdlib) &&
7589 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007590 if (Args.hasArg(options::OPT_pthread))
7591 CmdArgs.push_back("-lpthread");
7592 CmdArgs.push_back("-lc");
7593 CmdArgs.push_back("-lCompilerRT-Generic");
7594 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7595 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007596 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007597 }
7598
Logan Chieneb9162f2014-06-26 14:23:45 +00007599 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007600 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007601}
7602
Daniel Dunbarcc912342009-05-02 18:28:39 +00007603/// DragonFly Tools
7604
7605// For now, DragonFly Assemble does just about the same as for
7606// FreeBSD, but this may change soon.
7607void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007608 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007609 const InputInfoList &Inputs,
7610 const ArgList &Args,
7611 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007612 ArgStringList CmdArgs;
7613
7614 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7615 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007616 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007617 CmdArgs.push_back("--32");
7618
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007619 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007620
7621 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007622 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007623
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007624 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007625 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007626
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007627 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007628 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007629}
7630
7631void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007632 const InputInfo &Output,
7633 const InputInfoList &Inputs,
7634 const ArgList &Args,
7635 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007636 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007637 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00007638 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00007639
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007640 if (!D.SysRoot.empty())
7641 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7642
John McCall65b8da02013-04-11 22:55:55 +00007643 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007644 if (Args.hasArg(options::OPT_static)) {
7645 CmdArgs.push_back("-Bstatic");
7646 } else {
John McCall65b8da02013-04-11 22:55:55 +00007647 if (Args.hasArg(options::OPT_rdynamic))
7648 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007649 if (Args.hasArg(options::OPT_shared))
7650 CmdArgs.push_back("-Bshareable");
7651 else {
7652 CmdArgs.push_back("-dynamic-linker");
7653 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7654 }
John McCall65b8da02013-04-11 22:55:55 +00007655 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007656 }
7657
7658 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7659 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007660 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007661 CmdArgs.push_back("-m");
7662 CmdArgs.push_back("elf_i386");
7663 }
7664
Daniel Dunbarb440f562010-08-02 02:38:21 +00007665 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007666 CmdArgs.push_back("-o");
7667 CmdArgs.push_back(Output.getFilename());
7668 } else {
7669 assert(Output.isNothing() && "Invalid output.");
7670 }
7671
7672 if (!Args.hasArg(options::OPT_nostdlib) &&
7673 !Args.hasArg(options::OPT_nostartfiles)) {
7674 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007675 if (Args.hasArg(options::OPT_pg))
7676 CmdArgs.push_back(Args.MakeArgString(
7677 getToolChain().GetFilePath("gcrt1.o")));
7678 else {
7679 if (Args.hasArg(options::OPT_pie))
7680 CmdArgs.push_back(Args.MakeArgString(
7681 getToolChain().GetFilePath("Scrt1.o")));
7682 else
7683 CmdArgs.push_back(Args.MakeArgString(
7684 getToolChain().GetFilePath("crt1.o")));
7685 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007686 }
John McCall65b8da02013-04-11 22:55:55 +00007687 CmdArgs.push_back(Args.MakeArgString(
7688 getToolChain().GetFilePath("crti.o")));
7689 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7690 CmdArgs.push_back(Args.MakeArgString(
7691 getToolChain().GetFilePath("crtbeginS.o")));
7692 else
7693 CmdArgs.push_back(Args.MakeArgString(
7694 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007695 }
7696
7697 Args.AddAllArgs(CmdArgs, options::OPT_L);
7698 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7699 Args.AddAllArgs(CmdArgs, options::OPT_e);
7700
Daniel Dunbar54423b22010-09-17 00:24:54 +00007701 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007702
7703 if (!Args.hasArg(options::OPT_nostdlib) &&
7704 !Args.hasArg(options::OPT_nodefaultlibs)) {
7705 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7706 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007707 if (UseGCC47)
7708 CmdArgs.push_back("-L/usr/lib/gcc47");
7709 else
7710 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007711
7712 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007713 if (UseGCC47) {
7714 CmdArgs.push_back("-rpath");
7715 CmdArgs.push_back("/usr/lib/gcc47");
7716 } else {
7717 CmdArgs.push_back("-rpath");
7718 CmdArgs.push_back("/usr/lib/gcc44");
7719 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007720 }
7721
Hans Wennborg70850d82013-07-18 20:29:38 +00007722 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007723 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007724 CmdArgs.push_back("-lm");
7725 }
7726
Daniel Dunbarcc912342009-05-02 18:28:39 +00007727 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007728 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007729
7730 if (!Args.hasArg(options::OPT_nolibc)) {
7731 CmdArgs.push_back("-lc");
7732 }
7733
John McCall65b8da02013-04-11 22:55:55 +00007734 if (UseGCC47) {
7735 if (Args.hasArg(options::OPT_static) ||
7736 Args.hasArg(options::OPT_static_libgcc)) {
7737 CmdArgs.push_back("-lgcc");
7738 CmdArgs.push_back("-lgcc_eh");
7739 } else {
7740 if (Args.hasArg(options::OPT_shared_libgcc)) {
7741 CmdArgs.push_back("-lgcc_pic");
7742 if (!Args.hasArg(options::OPT_shared))
7743 CmdArgs.push_back("-lgcc");
7744 } else {
7745 CmdArgs.push_back("-lgcc");
7746 CmdArgs.push_back("--as-needed");
7747 CmdArgs.push_back("-lgcc_pic");
7748 CmdArgs.push_back("--no-as-needed");
7749 }
7750 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007751 } else {
John McCall65b8da02013-04-11 22:55:55 +00007752 if (Args.hasArg(options::OPT_shared)) {
7753 CmdArgs.push_back("-lgcc_pic");
7754 } else {
7755 CmdArgs.push_back("-lgcc");
7756 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007757 }
7758 }
7759
7760 if (!Args.hasArg(options::OPT_nostdlib) &&
7761 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007762 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007763 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007764 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007765 else
7766 CmdArgs.push_back(Args.MakeArgString(
7767 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007768 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007769 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007770 }
7771
Alexey Samsonov7811d192014-02-20 13:57:37 +00007772 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007773
Logan Chieneb9162f2014-06-26 14:23:45 +00007774 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007775 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007776}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007777
Alexey Samsonov6424e022014-05-12 20:20:20 +00007778static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7779 ArgStringList &CmdArgs,
Craig Topperbf3e3272014-08-30 16:55:52 +00007780 StringRef RTName) {
Alexey Samsonov6424e022014-05-12 20:20:20 +00007781 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7782 llvm::sys::path::append(LibSanitizer,
7783 Twine("clang_rt.") + RTName + ".lib");
7784 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7785}
7786
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007787void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7788 const InputInfo &Output,
7789 const InputInfoList &Inputs,
7790 const ArgList &Args,
7791 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007792 ArgStringList CmdArgs;
7793
7794 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007795 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7796 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007797 } else {
7798 assert(Output.isNothing() && "Invalid output.");
7799 }
7800
7801 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007802 !Args.hasArg(options::OPT_nostartfiles) &&
7803 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007804 CmdArgs.push_back("-defaultlib:libcmt");
7805 }
7806
7807 CmdArgs.push_back("-nologo");
7808
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007809 if (Args.hasArg(options::OPT_g_Group)) {
7810 CmdArgs.push_back("-debug");
7811 }
7812
Hans Wennborgf1a74252013-09-10 20:18:04 +00007813 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7814
7815 if (DLL) {
7816 CmdArgs.push_back(Args.MakeArgString("-dll"));
7817
7818 SmallString<128> ImplibName(Output.getFilename());
7819 llvm::sys::path::replace_extension(ImplibName, "lib");
7820 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7821 ImplibName.str()));
7822 }
7823
Peter Collingbourne32701642013-11-01 18:16:25 +00007824 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007825 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007826 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007827 // FIXME: Handle 64-bit.
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007828 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
7829 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_dynamic-i386");
Timur Iskhodzhanov92c06012014-09-12 13:21:02 +00007830 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7831 "asan_dynamic_runtime_thunk-i386");
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00007832 // Make sure the dynamic runtime thunk is not optimized out at link time
7833 // to ensure proper SEH handling.
7834 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007835 } else if (DLL) {
Alexey Samsonov6424e022014-05-12 20:20:20 +00007836 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7837 "asan_dll_thunk-i386");
7838 } else {
7839 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7840 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7841 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007842 }
7843
Hans Wennborg2e274592013-08-13 23:38:57 +00007844 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007845
Reid Kleckner337188f2014-09-16 19:22:00 +00007846 // Add filenames, libraries, and other linker inputs.
7847 for (const auto &Input : Inputs) {
7848 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007849 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00007850 continue;
7851 }
7852
7853 const Arg &A = Input.getInputArg();
7854
7855 // Render -l options differently for the MSVC linker.
7856 if (A.getOption().matches(options::OPT_l)) {
7857 StringRef Lib = A.getValue();
7858 const char *LinkLibArg;
7859 if (Lib.endswith(".lib"))
7860 LinkLibArg = Args.MakeArgString(Lib);
7861 else
7862 LinkLibArg = Args.MakeArgString(Lib + ".lib");
7863 CmdArgs.push_back(LinkLibArg);
7864 continue;
7865 }
7866
7867 // Otherwise, this is some other kind of linker input option like -Wl, -z,
7868 // or -L. Render it, even if MSVC doesn't understand it.
7869 A.renderAsInput(Args, CmdArgs);
7870 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007871
7872 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007873 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
David Blaikiec11bf802014-09-04 16:04:28 +00007874 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007875}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007876
7877void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7878 const InputInfo &Output,
7879 const InputInfoList &Inputs,
7880 const ArgList &Args,
7881 const char *LinkingOutput) const {
7882 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7883}
7884
Hans Wennborg188382e2013-09-20 18:16:35 +00007885// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7886// If one cannot be found, return FallbackName.
7887// We do this special search to prevent clang-cl from falling back onto itself
7888// if it's available as cl.exe on the path.
7889static std::string FindFallback(const char *FallbackName,
7890 const char *ClangProgramPath) {
7891 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7892 if (!OptPath.hasValue())
7893 return FallbackName;
7894
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007895 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Hans Wennborg188382e2013-09-20 18:16:35 +00007896 SmallVector<StringRef, 8> PathSegments;
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007897 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
Hans Wennborg188382e2013-09-20 18:16:35 +00007898
7899 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
Craig Topperbf3e3272014-08-30 16:55:52 +00007900 StringRef PathSegment = PathSegments[i];
Hans Wennborg188382e2013-09-20 18:16:35 +00007901 if (PathSegment.empty())
7902 continue;
7903
7904 SmallString<128> FilePath(PathSegment);
7905 llvm::sys::path::append(FilePath, FallbackName);
7906 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7907 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7908 return FilePath.str();
7909 }
7910
7911 return FallbackName;
7912}
7913
David Blaikiec11bf802014-09-04 16:04:28 +00007914std::unique_ptr<Command> visualstudio::Compile::GetCommand(
7915 Compilation &C, const JobAction &JA, const InputInfo &Output,
7916 const InputInfoList &Inputs, const ArgList &Args,
7917 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00007918 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007919 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007920 CmdArgs.push_back("/c"); // Compile only.
7921 CmdArgs.push_back("/W0"); // No warnings.
7922
7923 // The goal is to be able to invoke this tool correctly based on
7924 // any flag accepted by clang-cl.
7925
7926 // These are spelled the same way in clang and cl.exe,.
7927 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7928 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007929
7930 // Optimization level.
7931 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7932 if (A->getOption().getID() == options::OPT_O0) {
7933 CmdArgs.push_back("/Od");
7934 } else {
7935 StringRef OptLevel = A->getValue();
7936 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7937 A->render(Args, CmdArgs);
7938 else if (OptLevel == "3")
7939 CmdArgs.push_back("/Ox");
7940 }
7941 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007942
7943 // Flags for which clang-cl have an alias.
7944 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7945
David Majnemerf6072342014-07-01 22:24:56 +00007946 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
7947 /*default=*/false))
7948 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007949 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7950 options::OPT_fno_function_sections))
7951 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7952 ? "/Gy"
7953 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007954 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7955 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007956 CmdArgs.push_back(
7957 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007958 if (Args.hasArg(options::OPT_fsyntax_only))
7959 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007960 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7961 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007962
Hans Wennborg260ff402013-09-27 17:54:18 +00007963 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007964 for (const auto &Include : Includes)
7965 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007966
Hans Wennborg87cfa712013-09-19 20:32:16 +00007967 // Flags that can simply be passed through.
7968 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7969 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00007970 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007971
7972 // The order of these flags is relevant, so pick the last one.
7973 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7974 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7975 A->render(Args, CmdArgs);
7976
7977
7978 // Input filename.
7979 assert(Inputs.size() == 1);
7980 const InputInfo &II = Inputs[0];
7981 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7982 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7983 if (II.isFilename())
7984 CmdArgs.push_back(II.getFilename());
7985 else
7986 II.getInputArg().renderAsInput(Args, CmdArgs);
7987
7988 // Output filename.
7989 assert(Output.getType() == types::TY_Object);
7990 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7991 Output.getFilename());
7992 CmdArgs.push_back(Fo);
7993
Hans Wennborg188382e2013-09-20 18:16:35 +00007994 const Driver &D = getToolChain().getDriver();
7995 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007996 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
7997 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007998}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007999
8000
8001/// XCore Tools
8002// We pass assemble and link construction to the xcc tool.
8003
8004void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8005 const InputInfo &Output,
8006 const InputInfoList &Inputs,
8007 const ArgList &Args,
8008 const char *LinkingOutput) const {
8009 ArgStringList CmdArgs;
8010
8011 CmdArgs.push_back("-o");
8012 CmdArgs.push_back(Output.getFilename());
8013
8014 CmdArgs.push_back("-c");
8015
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008016 if (Args.hasArg(options::OPT_v))
8017 CmdArgs.push_back("-v");
8018
Robert Lytton894d25c2014-05-02 09:33:25 +00008019 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8020 if (!A->getOption().matches(options::OPT_g0))
8021 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008022
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008023 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8024 false))
8025 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008026
8027 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8028 options::OPT_Xassembler);
8029
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008030 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008031 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008032
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008033 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008034 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008035}
8036
8037void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8038 const InputInfo &Output,
8039 const InputInfoList &Inputs,
8040 const ArgList &Args,
8041 const char *LinkingOutput) const {
8042 ArgStringList CmdArgs;
8043
8044 if (Output.isFilename()) {
8045 CmdArgs.push_back("-o");
8046 CmdArgs.push_back(Output.getFilename());
8047 } else {
8048 assert(Output.isNothing() && "Invalid output.");
8049 }
8050
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008051 if (Args.hasArg(options::OPT_v))
8052 CmdArgs.push_back("-v");
8053
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008054 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
8055 if (EH.ShouldUseExceptionTables)
8056 CmdArgs.push_back("-fexceptions");
8057
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008058 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8059
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008060 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008061 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008062}