blob: 0a123a67bfb049e26ff67451cc02d82dac9cd73d [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:
Tim Northovera2ee4332014-03-29 15:09:45 +0000460 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +0000461 case llvm::Triple::arm64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000462 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000463 case llvm::Triple::armeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000464 if (Triple.isOSDarwin() || Triple.isOSWindows())
465 return true;
466 return false;
467
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000468 case llvm::Triple::ppc:
469 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000470 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000471 return true;
472 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000473
Bill Schmidt778d3872013-07-26 01:36:11 +0000474 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000475 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000476 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000477 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000478 }
479}
480
Robert Lytton0e076492013-08-13 09:43:10 +0000481static bool isNoCommonDefault(const llvm::Triple &Triple) {
482 switch (Triple.getArch()) {
483 default:
484 return false;
485
486 case llvm::Triple::xcore:
487 return true;
488 }
489}
490
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000491// Handle -mhwdiv=.
492static void getARMHWDivFeatures(const Driver &D, const Arg *A,
493 const ArgList &Args,
494 std::vector<const char *> &Features) {
495 StringRef HWDiv = A->getValue();
496 if (HWDiv == "arm") {
497 Features.push_back("+hwdiv-arm");
498 Features.push_back("-hwdiv");
499 } else if (HWDiv == "thumb") {
500 Features.push_back("-hwdiv-arm");
501 Features.push_back("+hwdiv");
502 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
503 Features.push_back("+hwdiv-arm");
504 Features.push_back("+hwdiv");
505 } else if (HWDiv == "none") {
506 Features.push_back("-hwdiv-arm");
507 Features.push_back("-hwdiv");
508 } else
509 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
510}
511
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000512// Handle -mfpu=.
513//
514// FIXME: Centralize feature selection, defaulting shouldn't be also in the
515// frontend target.
516static void getARMFPUFeatures(const Driver &D, const Arg *A,
517 const ArgList &Args,
518 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000519 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000520
521 // Set the target features based on the FPU.
522 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
523 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000524 Features.push_back("-vfp2");
525 Features.push_back("-vfp3");
526 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000527 } else if (FPU == "vfp") {
528 Features.push_back("+vfp2");
529 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000530 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000531 Features.push_back("+vfp3");
532 Features.push_back("+d16");
533 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000534 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000535 Features.push_back("+vfp3");
536 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000537 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
538 Features.push_back("+vfp4");
539 Features.push_back("+d16");
540 Features.push_back("-neon");
541 } else if (FPU == "vfp4" || FPU == "vfpv4") {
542 Features.push_back("+vfp4");
543 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000544 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
545 Features.push_back("+vfp4");
546 Features.push_back("+d16");
547 Features.push_back("+fp-only-sp");
548 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000549 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000550 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000551 Features.push_back("-neon");
552 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000553 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000554 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000555 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000556 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000557 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000558 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000559 Features.push_back("+neon");
560 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000561 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000562 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000563 } else if (FPU == "none") {
564 Features.push_back("-vfp2");
565 Features.push_back("-vfp3");
566 Features.push_back("-vfp4");
567 Features.push_back("-fp-armv8");
568 Features.push_back("-crypto");
569 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000570 } else
571 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
572}
573
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000574// Select the float ABI as determined by -msoft-float, -mhard-float, and
575// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000576StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
577 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000578 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000579 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
580 options::OPT_mhard_float,
581 options::OPT_mfloat_abi_EQ)) {
582 if (A->getOption().matches(options::OPT_msoft_float))
583 FloatABI = "soft";
584 else if (A->getOption().matches(options::OPT_mhard_float))
585 FloatABI = "hard";
586 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000587 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000588 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000589 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000590 << A->getAsString(Args);
591 FloatABI = "soft";
592 }
593 }
594 }
595
596 // If unspecified, choose the default based on the platform.
597 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000598 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000599 case llvm::Triple::Darwin:
600 case llvm::Triple::MacOSX:
601 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000602 // Darwin defaults to "softfp" for v6 and v7.
603 //
604 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000605 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000606 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000607 if (StringRef(ArchName).startswith("v6") ||
608 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000609 FloatABI = "softfp";
610 else
611 FloatABI = "soft";
612 break;
613 }
614
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000615 // FIXME: this is invalid for WindowsCE
616 case llvm::Triple::Win32:
617 FloatABI = "hard";
618 break;
619
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000620 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000621 switch(Triple.getEnvironment()) {
622 case llvm::Triple::GNUEABIHF:
623 FloatABI = "hard";
624 break;
625 default:
626 // FreeBSD defaults to soft float
627 FloatABI = "soft";
628 break;
629 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000630 break;
631
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000633 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000634 case llvm::Triple::GNUEABIHF:
635 FloatABI = "hard";
636 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000637 case llvm::Triple::GNUEABI:
638 FloatABI = "softfp";
639 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000640 case llvm::Triple::EABIHF:
641 FloatABI = "hard";
642 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000643 case llvm::Triple::EABI:
644 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
645 FloatABI = "softfp";
646 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000647 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000648 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000649 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000650 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000651 FloatABI = "softfp";
652 else
653 FloatABI = "soft";
654 break;
655 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000656 default:
657 // Assume "soft", but warn the user we are guessing.
658 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000659 if (Triple.getOS() != llvm::Triple::UnknownOS ||
660 !Triple.isOSBinFormatMachO())
661 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000662 break;
663 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000664 }
665 }
666
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000667 return FloatABI;
668}
669
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000670static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
671 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000672 std::vector<const char *> &Features,
673 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000674 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000675 if (!ForAS) {
676 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
677 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
678 // stripped out by the ARM target. We should probably pass this a new
679 // -target-option, which is handled by the -cc1/-cc1as invocation.
680 //
681 // FIXME2: For consistency, it would be ideal if we set up the target
682 // machine state the same when using the frontend or the assembler. We don't
683 // currently do that for the assembler, we pass the options directly to the
684 // backend and never even instantiate the frontend TargetInfo. If we did,
685 // and used its handleTargetFeatures hook, then we could ensure the
686 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000687
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000688 // Use software floating point operations?
689 if (FloatABI == "soft")
690 Features.push_back("+soft-float");
691
692 // Use software floating point argument passing?
693 if (FloatABI != "hard")
694 Features.push_back("+soft-float-abi");
695 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000696
697 // Honor -mfpu=.
698 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000699 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000700 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
701 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000702
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000703 // Setting -msoft-float effectively disables NEON because of the GCC
704 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000705 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000706 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000707 // Also need to explicitly disable features which imply NEON.
708 Features.push_back("-crypto");
709 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000710
711 // En/disable crc
712 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
713 options::OPT_mnocrc)) {
714 if (A->getOption().matches(options::OPT_mcrc))
715 Features.push_back("+crc");
716 else
717 Features.push_back("-crc");
718 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000719}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000720
721void Clang::AddARMTargetArgs(const ArgList &Args,
722 ArgStringList &CmdArgs,
723 bool KernelOrKext) const {
724 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000725 // Get the effective triple, which takes into account the deployment target.
726 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
727 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000728 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000729
730 // Select the ABI to use.
731 //
732 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000733 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000734 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000735 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000736 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000737 // The backend is hardwired to assume AAPCS for M-class processors, ensure
738 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000739 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000740 (Triple.getOS() == llvm::Triple::UnknownOS &&
741 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000742 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000743 ABIName = "aapcs";
744 } else {
745 ABIName = "apcs-gnu";
746 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000747 } else if (Triple.isOSWindows()) {
748 // FIXME: this is invalid for WindowsCE
749 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000750 } else {
751 // Select the default based on the platform.
752 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000753 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000754 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000755 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000756 ABIName = "aapcs-linux";
757 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000758 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000759 case llvm::Triple::EABI:
760 ABIName = "aapcs";
761 break;
762 default:
763 ABIName = "apcs-gnu";
764 }
765 }
766 CmdArgs.push_back("-target-abi");
767 CmdArgs.push_back(ABIName);
768
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000769 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000770 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000771 if (FloatABI == "soft") {
772 // Floating point operations and argument passing are soft.
773 //
774 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000775 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000776 CmdArgs.push_back("-mfloat-abi");
777 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000778 } else if (FloatABI == "softfp") {
779 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000780 CmdArgs.push_back("-mfloat-abi");
781 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000782 } else {
783 // Floating point operations and argument passing are hard.
784 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000785 CmdArgs.push_back("-mfloat-abi");
786 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000787 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000788
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000789 // Kernel code has more strict alignment requirements.
790 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000791 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000792 CmdArgs.push_back("-backend-option");
793 CmdArgs.push_back("-arm-long-calls");
794 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000795
Daniel Dunbar12100e22011-03-22 16:48:17 +0000796 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000797 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000798
799 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000800 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000801 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000802 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000803
804 // Setting -mno-global-merge disables the codegen global merge pass. Setting
805 // -mglobal-merge has no effect as the pass is enabled by default.
806 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
807 options::OPT_mno_global_merge)) {
808 if (A->getOption().matches(options::OPT_mno_global_merge))
809 CmdArgs.push_back("-mno-global-merge");
810 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000811
Bob Wilson9c8af452013-04-11 18:53:25 +0000812 if (!Args.hasFlag(options::OPT_mimplicit_float,
813 options::OPT_mno_implicit_float,
814 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000815 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000816
Logan Chien749763e2014-04-03 13:12:44 +0000817 // llvm does not support reserving registers in general. There is support
818 // for reserving r9 on ARM though (defined as a platform-specific register
819 // in ARM EABI).
820 if (Args.hasArg(options::OPT_ffixed_r9)) {
821 CmdArgs.push_back("-backend-option");
822 CmdArgs.push_back("-arm-reserve-r9");
823 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000824}
825
Tim Northover573cbee2014-05-24 12:52:07 +0000826/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
827/// targeting.
828static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000829 Arg *A;
830 std::string CPU;
831 // If we have -mtune or -mcpu, use that.
832 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
833 CPU = A->getValue();
834 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
835 StringRef Mcpu = A->getValue();
836 CPU = Mcpu.split("+").first;
Tim Northovera2ee4332014-03-29 15:09:45 +0000837 }
838
Kevin Qin110db6f2014-07-18 07:03:22 +0000839 // Handle CPU name is 'native'.
840 if (CPU == "native")
841 return llvm::sys::getHostCPUName();
842 else if (CPU.size())
843 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000844
James Molloy9b1586b2014-04-17 12:51:17 +0000845 // Make sure we pick "cyclone" if -arch is used.
846 // FIXME: Should this be picked by checking the target triple instead?
847 if (Args.getLastArg(options::OPT_arch))
848 return "cyclone";
849
850 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000851}
852
Tim Northover573cbee2014-05-24 12:52:07 +0000853void Clang::AddAArch64TargetArgs(const ArgList &Args,
854 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000855 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
856 llvm::Triple Triple(TripleStr);
857
858 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
859 Args.hasArg(options::OPT_mkernel) ||
860 Args.hasArg(options::OPT_fapple_kext))
861 CmdArgs.push_back("-disable-red-zone");
862
863 if (!Args.hasFlag(options::OPT_mimplicit_float,
864 options::OPT_mno_implicit_float, true))
865 CmdArgs.push_back("-no-implicit-float");
866
Craig Topper92fc2df2014-05-17 16:56:41 +0000867 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000868 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
869 ABIName = A->getValue();
870 else if (Triple.isOSDarwin())
871 ABIName = "darwinpcs";
872 else
873 ABIName = "aapcs";
874
875 CmdArgs.push_back("-target-abi");
876 CmdArgs.push_back(ABIName);
877
Tim Northovera2ee4332014-03-29 15:09:45 +0000878 if (Args.hasArg(options::OPT_mstrict_align)) {
879 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +0000880 CmdArgs.push_back("-aarch64-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000881 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000882
883 // Setting -mno-global-merge disables the codegen global merge pass. Setting
884 // -mglobal-merge has no effect as the pass is enabled by default.
885 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
886 options::OPT_mno_global_merge)) {
887 if (A->getOption().matches(options::OPT_mno_global_merge))
888 CmdArgs.push_back("-mno-global-merge");
889 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000890}
891
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000892// Get CPU and ABI names. They are not independent
893// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000894void mips::getMipsCPUAndABI(const ArgList &Args,
895 const llvm::Triple &Triple,
896 StringRef &CPUName,
897 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000898 const char *DefMips32CPU = "mips32r2";
899 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000900
Daniel Sanders2bf13662014-07-10 14:40:57 +0000901 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
902 // default for mips64(el)?-img-linux-gnu.
903 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
904 Triple.getEnvironment() == llvm::Triple::GNU) {
905 DefMips32CPU = "mips32r6";
906 DefMips64CPU = "mips64r6";
907 }
908
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000909 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000910 options::OPT_mcpu_EQ))
911 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000912
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000913 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000914 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000915 // Convert a GNU style Mips ABI name to the name
916 // accepted by LLVM Mips backend.
917 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
918 .Case("32", "o32")
919 .Case("64", "n64")
920 .Default(ABIName);
921 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000922
923 // Setup default CPU and ABI names.
924 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000925 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000926 default:
927 llvm_unreachable("Unexpected triple arch name");
928 case llvm::Triple::mips:
929 case llvm::Triple::mipsel:
930 CPUName = DefMips32CPU;
931 break;
932 case llvm::Triple::mips64:
933 case llvm::Triple::mips64el:
934 CPUName = DefMips64CPU;
935 break;
936 }
937 }
938
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000939 if (ABIName.empty()) {
940 // Deduce ABI name from the target triple.
941 if (Triple.getArch() == llvm::Triple::mips ||
942 Triple.getArch() == llvm::Triple::mipsel)
943 ABIName = "o32";
944 else
945 ABIName = "n64";
946 }
947
948 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000949 // Deduce CPU name from ABI name.
950 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000951 .Cases("o32", "eabi", DefMips32CPU)
952 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000953 .Default("");
954 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +0000955
956 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000957}
958
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000959// Convert ABI name to the GNU tools acceptable variant.
960static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
961 return llvm::StringSwitch<llvm::StringRef>(ABI)
962 .Case("o32", "32")
963 .Case("n64", "64")
964 .Default(ABI);
965}
966
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000967// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
968// and -mfloat-abi=.
969static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000970 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000971 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000972 options::OPT_mhard_float,
973 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000974 if (A->getOption().matches(options::OPT_msoft_float))
975 FloatABI = "soft";
976 else if (A->getOption().matches(options::OPT_mhard_float))
977 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000978 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000979 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000980 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000981 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000982 FloatABI = "hard";
983 }
984 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000985 }
986
987 // If unspecified, choose the default based on the platform.
988 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000989 // Assume "hard", because it's a default value used by gcc.
990 // When we start to recognize specific target MIPS processors,
991 // we will be able to select the default more correctly.
992 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +0000993 }
994
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000995 return FloatABI;
996}
997
Simon Atanasyan9b1932d2012-07-05 18:51:43 +0000998static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000999 std::vector<const char *> &Features,
1000 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001001 StringRef FeatureName) {
1002 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001003 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001004 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001005 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001006 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001007 }
1008}
1009
Daniel Sanders379d44b2014-07-16 11:52:23 +00001010static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1011 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001012 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001013 StringRef CPUName;
1014 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001015 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001016 ABIName = getGnuCompatibleMipsABIName(ABIName);
1017
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001018 // Always override the backend's default ABI.
Aaron Ballman9eef74232014-07-17 13:28:50 +00001019 std::string ABIFeature = llvm::StringSwitch<StringRef>(ABIName)
1020 .Case("32", "+o32")
1021 .Case("n32", "+n32")
1022 .Case("64", "+n64")
1023 .Case("eabi", "+eabi")
1024 .Default(("+" + ABIName).str());
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001025 Features.push_back("-o32");
1026 Features.push_back("-n64");
1027 Features.push_back(Args.MakeArgString(ABIFeature));
1028
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001029 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001030 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001031 // FIXME: Note, this is a hack. We need to pass the selected float
1032 // mode to the MipsTargetInfoBase to define appropriate macros there.
1033 // Now it is the only method.
1034 Features.push_back("+soft-float");
1035 }
1036
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001037 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001038 StringRef Val = StringRef(A->getValue());
1039 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001040 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001041 else if (Val == "legacy")
1042 Features.push_back("-nan2008");
1043 else
1044 D.Diag(diag::err_drv_unsupported_option_argument)
1045 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001046 }
1047
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001048 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1049 options::OPT_mdouble_float, "single-float");
1050 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1051 "mips16");
1052 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1053 options::OPT_mno_micromips, "micromips");
1054 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1055 "dsp");
1056 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1057 "dspr2");
1058 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1059 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001060
1061 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1062 // pass -mfpxx
1063 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1064 options::OPT_mfp64)) {
1065 if (A->getOption().matches(options::OPT_mfp32))
1066 Features.push_back(Args.MakeArgString("-fp64"));
1067 else if (A->getOption().matches(options::OPT_mfpxx)) {
1068 Features.push_back(Args.MakeArgString("+fpxx"));
1069 Features.push_back(Args.MakeArgString("+nooddspreg"));
1070 } else
1071 Features.push_back(Args.MakeArgString("+fp64"));
1072 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001073 Features.push_back(Args.MakeArgString("+fpxx"));
1074 Features.push_back(Args.MakeArgString("+nooddspreg"));
1075 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001076
Daniel Sanders28e5d392014-07-10 10:39:51 +00001077 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1078 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001079}
1080
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001081void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001082 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001083 const Driver &D = getToolChain().getDriver();
1084 StringRef CPUName;
1085 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001086 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001087 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001088
1089 CmdArgs.push_back("-target-abi");
1090 CmdArgs.push_back(ABIName.data());
1091
1092 StringRef FloatABI = getMipsFloatABI(D, Args);
1093
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001094 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001095 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001096 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001097 CmdArgs.push_back("-mfloat-abi");
1098 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001099 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001100 else {
1101 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001102 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001103 CmdArgs.push_back("-mfloat-abi");
1104 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001105 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001106
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001107 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1108 if (A->getOption().matches(options::OPT_mxgot)) {
1109 CmdArgs.push_back("-mllvm");
1110 CmdArgs.push_back("-mxgot");
1111 }
1112 }
1113
Simon Atanasyanc580b322013-05-11 06:33:44 +00001114 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1115 options::OPT_mno_ldc1_sdc1)) {
1116 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1117 CmdArgs.push_back("-mllvm");
1118 CmdArgs.push_back("-mno-ldc1-sdc1");
1119 }
1120 }
1121
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001122 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1123 options::OPT_mno_check_zero_division)) {
1124 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1125 CmdArgs.push_back("-mllvm");
1126 CmdArgs.push_back("-mno-check-zero-division");
1127 }
1128 }
1129
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001130 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001131 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001132 CmdArgs.push_back("-mllvm");
1133 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1134 A->claim();
1135 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001136}
1137
Hal Finkel8eb59282012-06-11 22:35:19 +00001138/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1139static std::string getPPCTargetCPU(const ArgList &Args) {
1140 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001141 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001142
1143 if (CPUName == "native") {
1144 std::string CPU = llvm::sys::getHostCPUName();
1145 if (!CPU.empty() && CPU != "generic")
1146 return CPU;
1147 else
1148 return "";
1149 }
1150
1151 return llvm::StringSwitch<const char *>(CPUName)
1152 .Case("common", "generic")
1153 .Case("440", "440")
1154 .Case("440fp", "440")
1155 .Case("450", "450")
1156 .Case("601", "601")
1157 .Case("602", "602")
1158 .Case("603", "603")
1159 .Case("603e", "603e")
1160 .Case("603ev", "603ev")
1161 .Case("604", "604")
1162 .Case("604e", "604e")
1163 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001164 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001165 .Case("G3", "g3")
1166 .Case("7400", "7400")
1167 .Case("G4", "g4")
1168 .Case("7450", "7450")
1169 .Case("G4+", "g4+")
1170 .Case("750", "750")
1171 .Case("970", "970")
1172 .Case("G5", "g5")
1173 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001174 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001175 .Case("e500mc", "e500mc")
1176 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001177 .Case("power3", "pwr3")
1178 .Case("power4", "pwr4")
1179 .Case("power5", "pwr5")
1180 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001181 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001182 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001183 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001184 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001185 .Case("pwr3", "pwr3")
1186 .Case("pwr4", "pwr4")
1187 .Case("pwr5", "pwr5")
1188 .Case("pwr5x", "pwr5x")
1189 .Case("pwr6", "pwr6")
1190 .Case("pwr6x", "pwr6x")
1191 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001192 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001193 .Case("powerpc", "ppc")
1194 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001195 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001196 .Default("");
1197 }
1198
1199 return "";
1200}
1201
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001202static void getPPCTargetFeatures(const ArgList &Args,
1203 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001204 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1205 ie = Args.filtered_end();
1206 it != ie; ++it) {
1207 StringRef Name = (*it)->getOption().getName();
1208 (*it)->claim();
1209
1210 // Skip over "-m".
1211 assert(Name.startswith("m") && "Invalid feature name.");
1212 Name = Name.substr(1);
1213
1214 bool IsNegative = Name.startswith("no-");
1215 if (IsNegative)
1216 Name = Name.substr(3);
1217
1218 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1219 // pass the correct option to the backend while calling the frontend
1220 // option the same.
1221 // TODO: Change the LLVM backend option maybe?
1222 if (Name == "mfcrf")
1223 Name = "mfocrf";
1224
1225 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1226 }
1227
1228 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001229 AddTargetFeature(Args, Features, options::OPT_faltivec,
1230 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001231}
1232
Tom Stellard6674c702013-04-01 20:56:53 +00001233/// Get the (LLVM) name of the R600 gpu we are targeting.
1234static std::string getR600TargetGPU(const ArgList &Args) {
1235 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001236 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001237 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001238 .Cases("rv630", "rv635", "r600")
1239 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001240 .Case("rv740", "rv770")
1241 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001242 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001243 .Case("hemlock", "cypress")
1244 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001245 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001246 }
1247 return "";
1248}
1249
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001250static void getSparcTargetFeatures(const ArgList &Args,
1251 std::vector<const char *> Features) {
1252 bool SoftFloatABI = true;
1253 if (Arg *A =
1254 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1255 if (A->getOption().matches(options::OPT_mhard_float))
1256 SoftFloatABI = false;
1257 }
1258 if (SoftFloatABI)
1259 Features.push_back("+soft-float");
1260}
1261
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001262void Clang::AddSparcTargetArgs(const ArgList &Args,
1263 ArgStringList &CmdArgs) const {
1264 const Driver &D = getToolChain().getDriver();
1265
Brad Smith10cd0f42014-07-11 20:12:08 +00001266 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001267 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001268 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1269 options::OPT_mhard_float)) {
1270 if (A->getOption().matches(options::OPT_msoft_float))
1271 FloatABI = "soft";
1272 else if (A->getOption().matches(options::OPT_mhard_float))
1273 FloatABI = "hard";
1274 }
1275
1276 // If unspecified, choose the default based on the platform.
1277 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001278 // Assume "soft", but warn the user we are guessing.
1279 FloatABI = "soft";
1280 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001281 }
1282
1283 if (FloatABI == "soft") {
1284 // Floating point operations and argument passing are soft.
1285 //
1286 // FIXME: This changes CPP defines, we need -target-soft-float.
1287 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001288 } else {
1289 assert(FloatABI == "hard" && "Invalid float abi!");
1290 CmdArgs.push_back("-mhard-float");
1291 }
1292}
1293
Richard Sandiford4652d892013-07-19 16:51:51 +00001294static const char *getSystemZTargetCPU(const ArgList &Args) {
1295 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1296 return A->getValue();
1297 return "z10";
1298}
1299
Chandler Carruth953fb082013-01-13 11:46:33 +00001300static const char *getX86TargetCPU(const ArgList &Args,
1301 const llvm::Triple &Triple) {
1302 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001303 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001304 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001305 return "core-avx2";
1306
Chandler Carruth953fb082013-01-13 11:46:33 +00001307 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001308 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001309
1310 // FIXME: Reject attempts to use -march=native unless the target matches
1311 // the host.
1312 //
1313 // FIXME: We should also incorporate the detected target features for use
1314 // with -native.
1315 std::string CPU = llvm::sys::getHostCPUName();
1316 if (!CPU.empty() && CPU != "generic")
1317 return Args.MakeArgString(CPU);
1318 }
1319
1320 // Select the default CPU if none was given (or detection failed).
1321
1322 if (Triple.getArch() != llvm::Triple::x86_64 &&
1323 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001324 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001325
1326 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1327
1328 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001329 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001330 if (Triple.getArchName() == "x86_64h")
1331 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001332 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001333 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001334
Alexey Bataev286d1b92014-01-31 04:07:13 +00001335 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001336 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001337 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001338
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001339 // Everything else goes to x86-64 in 64-bit mode.
1340 if (Is64Bit)
1341 return "x86-64";
1342
1343 switch (Triple.getOS()) {
1344 case llvm::Triple::FreeBSD:
1345 case llvm::Triple::NetBSD:
1346 case llvm::Triple::OpenBSD:
1347 return "i486";
1348 case llvm::Triple::Haiku:
1349 return "i586";
1350 case llvm::Triple::Bitrig:
1351 return "i686";
1352 default:
1353 // Fallback to p4.
1354 return "pentium4";
1355 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001356}
1357
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001358static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1359 switch(T.getArch()) {
1360 default:
1361 return "";
1362
Amara Emerson703da2e2013-10-31 09:32:33 +00001363 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001364 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001365 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001366 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001367 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001368
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001369 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001370 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001371 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001372 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001373 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001374
1375 case llvm::Triple::mips:
1376 case llvm::Triple::mipsel:
1377 case llvm::Triple::mips64:
1378 case llvm::Triple::mips64el: {
1379 StringRef CPUName;
1380 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001381 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001382 return CPUName;
1383 }
1384
1385 case llvm::Triple::ppc:
1386 case llvm::Triple::ppc64:
1387 case llvm::Triple::ppc64le: {
1388 std::string TargetCPUName = getPPCTargetCPU(Args);
1389 // LLVM may default to generating code for the native CPU,
1390 // but, like gcc, we default to a more generic option for
1391 // each architecture. (except on Darwin)
1392 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1393 if (T.getArch() == llvm::Triple::ppc64)
1394 TargetCPUName = "ppc64";
1395 else if (T.getArch() == llvm::Triple::ppc64le)
1396 TargetCPUName = "ppc64le";
1397 else
1398 TargetCPUName = "ppc";
1399 }
1400 return TargetCPUName;
1401 }
1402
1403 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001404 case llvm::Triple::sparcv9:
1405 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001406 return A->getValue();
1407 return "";
1408
1409 case llvm::Triple::x86:
1410 case llvm::Triple::x86_64:
1411 return getX86TargetCPU(Args, T);
1412
1413 case llvm::Triple::hexagon:
1414 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1415
1416 case llvm::Triple::systemz:
1417 return getSystemZTargetCPU(Args);
1418
1419 case llvm::Triple::r600:
1420 return getR600TargetGPU(Args);
1421 }
1422}
1423
Alp Tokerce365ca2013-12-02 12:43:03 +00001424static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1425 ArgStringList &CmdArgs) {
1426 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1427 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1428 // forward.
1429 CmdArgs.push_back("-plugin");
1430 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1431 CmdArgs.push_back(Args.MakeArgString(Plugin));
1432
1433 // Try to pass driver level flags relevant to LTO code generation down to
1434 // the plugin.
1435
1436 // Handle flags for selecting CPU variants.
1437 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1438 if (!CPU.empty())
1439 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1440}
1441
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001442static void getX86TargetFeatures(const Driver & D,
1443 const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001444 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001445 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001446 if (Triple.getArchName() == "x86_64h") {
1447 // x86_64h implies quite a few of the more modern subtarget features
1448 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1449 Features.push_back("-rdrnd");
1450 Features.push_back("-aes");
1451 Features.push_back("-pclmul");
1452 Features.push_back("-rtm");
1453 Features.push_back("-hle");
1454 Features.push_back("-fsgsbase");
1455 }
1456
Alexey Volkov54ff0802014-06-25 12:15:36 +00001457 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001458 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001459 if (Triple.getArch() == llvm::Triple::x86_64) {
1460 Features.push_back("+sse4.2");
1461 Features.push_back("+popcnt");
1462 } else
1463 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001464 }
1465
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001466 // Set features according to the -arch flag on MSVC
1467 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1468 StringRef Arch = A->getValue();
1469 bool ArchUsed = false;
1470 // First, look for flags that are shared in x86 and x86-64.
1471 if (Triple.getArch() == llvm::Triple::x86_64 ||
1472 Triple.getArch() == llvm::Triple::x86) {
1473 if (Arch == "AVX" || Arch == "AVX2") {
1474 ArchUsed = true;
1475 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1476 }
1477 }
1478 // Then, look for x86-specific flags.
1479 if (Triple.getArch() == llvm::Triple::x86) {
1480 if (Arch == "IA32") {
1481 ArchUsed = true;
1482 } else if (Arch == "SSE" || Arch == "SSE2") {
1483 ArchUsed = true;
1484 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1485 }
1486 }
1487 if (!ArchUsed)
1488 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1489 }
1490
Jim Grosbach82eee262013-11-16 00:53:35 +00001491 // Now add any that the user explicitly requested on the command line,
1492 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001493 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1494 ie = Args.filtered_end();
1495 it != ie; ++it) {
1496 StringRef Name = (*it)->getOption().getName();
1497 (*it)->claim();
1498
1499 // Skip over "-m".
1500 assert(Name.startswith("m") && "Invalid feature name.");
1501 Name = Name.substr(1);
1502
1503 bool IsNegative = Name.startswith("no-");
1504 if (IsNegative)
1505 Name = Name.substr(3);
1506
1507 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1508 }
1509}
1510
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001511void Clang::AddX86TargetArgs(const ArgList &Args,
1512 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001513 if (!Args.hasFlag(options::OPT_mred_zone,
1514 options::OPT_mno_red_zone,
1515 true) ||
1516 Args.hasArg(options::OPT_mkernel) ||
1517 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001518 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001519
Bob Wilson2616e2e2013-02-10 16:01:41 +00001520 // Default to avoid implicit floating-point for kernel/kext code, but allow
1521 // that to be overridden with -mno-soft-float.
1522 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1523 Args.hasArg(options::OPT_fapple_kext));
1524 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1525 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001526 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001527 options::OPT_mno_implicit_float)) {
1528 const Option &O = A->getOption();
1529 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1530 O.matches(options::OPT_msoft_float));
1531 }
1532 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001533 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001534
1535 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1536 StringRef Value = A->getValue();
1537 if (Value == "intel" || Value == "att") {
1538 CmdArgs.push_back("-mllvm");
1539 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1540 } else {
1541 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1542 << A->getOption().getName() << Value;
1543 }
1544 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001545}
1546
Matthew Curtise8f80a12012-12-06 17:49:03 +00001547static inline bool HasPICArg(const ArgList &Args) {
1548 return Args.hasArg(options::OPT_fPIC)
1549 || Args.hasArg(options::OPT_fpic);
1550}
1551
1552static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1553 return Args.getLastArg(options::OPT_G,
1554 options::OPT_G_EQ,
1555 options::OPT_msmall_data_threshold_EQ);
1556}
1557
1558static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1559 std::string value;
1560 if (HasPICArg(Args))
1561 value = "0";
1562 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1563 value = A->getValue();
1564 A->claim();
1565 }
1566 return value;
1567}
1568
Tony Linthicum76329bf2011-12-12 21:14:55 +00001569void Clang::AddHexagonTargetArgs(const ArgList &Args,
1570 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001571 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001572 CmdArgs.push_back("-mqdsp6-compat");
1573 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001574
Matthew Curtise8f80a12012-12-06 17:49:03 +00001575 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1576 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001577 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001578 CmdArgs.push_back(Args.MakeArgString(
1579 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001580 }
1581
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001582 if (!Args.hasArg(options::OPT_fno_short_enums))
1583 CmdArgs.push_back("-fshort-enums");
1584 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1585 CmdArgs.push_back ("-mllvm");
1586 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1587 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001588 CmdArgs.push_back ("-mllvm");
1589 CmdArgs.push_back ("-machine-sink-split=0");
1590}
1591
Kevin Qin110db6f2014-07-18 07:03:22 +00001592// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
1593static bool DecodeAArch64Features(const Driver &D, const StringRef &text,
1594 std::vector<const char *> &Features) {
1595 SmallVector<StringRef, 8> Split;
1596 text.split(Split, StringRef("+"), -1, false);
1597
1598 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1599 const char *result = llvm::StringSwitch<const char *>(Split[I])
1600 .Case("fp", "+fp-armv8")
1601 .Case("simd", "+neon")
1602 .Case("crc", "+crc")
1603 .Case("crypto", "+crypto")
1604 .Case("nofp", "-fp-armv8")
1605 .Case("nosimd", "-neon")
1606 .Case("nocrc", "-crc")
1607 .Case("nocrypto", "-crypto")
1608 .Default(nullptr);
1609 if (result)
1610 Features.push_back(result);
1611 else if (Split[I] == "neon" || Split[I] == "noneon")
1612 D.Diag(diag::err_drv_no_neon_modifier);
1613 else
1614 return false;
1615 }
1616 return true;
1617}
1618
1619// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1620// decode CPU and feature.
1621static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1622 std::vector<const char *> &Features) {
1623 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1624 CPU = Split.first;
1625 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57") {
1626 Features.push_back("+neon");
1627 Features.push_back("+crc");
1628 Features.push_back("+crypto");
1629 } else if (CPU == "generic") {
1630 Features.push_back("+neon");
1631 } else {
1632 return false;
1633 }
1634
1635 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1636 return false;
1637
1638 return true;
1639}
1640
1641static bool
1642getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1643 const ArgList &Args,
1644 std::vector<const char *> &Features) {
1645 std::pair<StringRef, StringRef> Split = March.split("+");
1646 if (Split.first != "armv8-a")
1647 return false;
1648
1649 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1650 return false;
1651
1652 return true;
1653}
1654
1655static bool
1656getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1657 const ArgList &Args,
1658 std::vector<const char *> &Features) {
1659 StringRef CPU;
1660 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1661 return false;
1662
1663 return true;
1664}
1665
1666static bool
1667getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1668 const ArgList &Args,
1669 std::vector<const char *> &Features) {
1670 // Handle CPU name is 'native'.
1671 if (Mtune == "native")
1672 Mtune = llvm::sys::getHostCPUName();
1673 if (Mtune == "cyclone") {
1674 Features.push_back("+zcm");
1675 Features.push_back("+zcz");
1676 }
1677 return true;
1678}
1679
1680static bool
1681getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1682 const ArgList &Args,
1683 std::vector<const char *> &Features) {
1684 StringRef CPU;
1685 std::vector<const char *> DecodedFeature;
1686 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1687 return false;
1688
1689 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1690}
1691
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001692static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1693 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001694 Arg *A;
1695 bool success = true;
1696 // Enable NEON by default.
1697 Features.push_back("+neon");
1698 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1699 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1700 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1701 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1702
1703 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1704 success =
1705 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1706 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1707 success =
1708 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1709
1710 if (!success)
1711 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001712
1713 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1714 Features.push_back("-fp-armv8");
1715 Features.push_back("-crypto");
1716 Features.push_back("-neon");
1717 }
Bradley Smith418c5932014-05-02 15:17:51 +00001718
1719 // En/disable crc
1720 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1721 options::OPT_mnocrc)) {
1722 if (A->getOption().matches(options::OPT_mcrc))
1723 Features.push_back("+crc");
1724 else
1725 Features.push_back("-crc");
1726 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001727}
1728
1729static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001730 const ArgList &Args, ArgStringList &CmdArgs,
1731 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001732 std::vector<const char *> Features;
1733 switch (Triple.getArch()) {
1734 default:
1735 break;
1736 case llvm::Triple::mips:
1737 case llvm::Triple::mipsel:
1738 case llvm::Triple::mips64:
1739 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001740 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001741 break;
1742
1743 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001744 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001745 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001746 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001747 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001748 break;
1749
1750 case llvm::Triple::ppc:
1751 case llvm::Triple::ppc64:
1752 case llvm::Triple::ppc64le:
1753 getPPCTargetFeatures(Args, Features);
1754 break;
1755 case llvm::Triple::sparc:
1756 getSparcTargetFeatures(Args, Features);
1757 break;
1758 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001759 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001760 case llvm::Triple::arm64:
1761 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001762 getAArch64TargetFeatures(D, Args, Features);
1763 break;
1764 case llvm::Triple::x86:
1765 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001766 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001767 break;
1768 }
Rafael Espindola43964802013-08-21 17:34:32 +00001769
1770 // Find the last of each feature.
1771 llvm::StringMap<unsigned> LastOpt;
1772 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1773 const char *Name = Features[I];
1774 assert(Name[0] == '-' || Name[0] == '+');
1775 LastOpt[Name + 1] = I;
1776 }
1777
1778 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1779 // If this feature was overridden, ignore it.
1780 const char *Name = Features[I];
1781 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1782 assert(LastI != LastOpt.end());
1783 unsigned Last = LastI->second;
1784 if (Last != I)
1785 continue;
1786
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001787 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001788 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001789 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001790}
1791
Eric Christopher84fbdb42011-08-19 00:30:14 +00001792static bool
John McCall5fb5df92012-06-20 06:18:46 +00001793shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001794 const llvm::Triple &Triple) {
1795 // We use the zero-cost exception tables for Objective-C if the non-fragile
1796 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1797 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001798 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001799 return true;
1800
Bob Wilson83e723a2013-12-05 19:38:42 +00001801 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001802 return false;
1803
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001804 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001805 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001806 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001807}
1808
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001809namespace {
1810 struct ExceptionSettings {
1811 bool ExceptionsEnabled;
1812 bool ShouldUseExceptionTables;
1813 ExceptionSettings() : ExceptionsEnabled(false),
1814 ShouldUseExceptionTables(false) {}
1815 };
1816} // end anonymous namespace.
1817
Nico Webere8e53112014-05-11 01:04:02 +00001818// exceptionSettings() exists to share the logic between -cc1 and linker
1819// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001820static ExceptionSettings exceptionSettings(const ArgList &Args,
1821 const llvm::Triple &Triple) {
1822 ExceptionSettings ES;
1823
1824 // Are exceptions enabled by default?
1825 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1826
1827 // This keeps track of whether exceptions were explicitly turned on or off.
1828 bool DidHaveExplicitExceptionFlag = false;
1829
1830 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1831 options::OPT_fno_exceptions)) {
1832 if (A->getOption().matches(options::OPT_fexceptions))
1833 ES.ExceptionsEnabled = true;
1834 else
1835 ES.ExceptionsEnabled = false;
1836
1837 DidHaveExplicitExceptionFlag = true;
1838 }
1839
1840 // Exception tables and cleanups can be enabled with -fexceptions even if the
1841 // language itself doesn't support exceptions.
1842 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1843 ES.ShouldUseExceptionTables = true;
1844
1845 return ES;
1846}
1847
Anders Carlssone96ab552011-02-28 02:27:16 +00001848/// addExceptionArgs - Adds exception related arguments to the driver command
1849/// arguments. There's a master flag, -fexceptions and also language specific
1850/// flags to enable/disable C++ and Objective-C exceptions.
1851/// This makes it possible to for example disable C++ exceptions but enable
1852/// Objective-C exceptions.
1853static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1854 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001855 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001856 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001857 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001858 if (KernelOrKext) {
1859 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1860 // arguments now to avoid warnings about unused arguments.
1861 Args.ClaimAllArgs(options::OPT_fexceptions);
1862 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1863 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1864 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1865 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1866 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001867 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001868 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001869
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001870 // Gather the exception settings from the command line arguments.
1871 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001872
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001873 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1874 // is not necessarily sensible, but follows GCC.
1875 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001876 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001877 options::OPT_fno_objc_exceptions,
1878 true)) {
1879 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001880
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001881 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001882 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001883 }
1884
1885 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001886 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001887
Eric Christopher84fbdb42011-08-19 00:30:14 +00001888 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1889 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001890 options::OPT_fexceptions,
1891 options::OPT_fno_exceptions)) {
1892 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1893 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001894 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001895 CXXExceptionsEnabled = false;
1896 }
1897
1898 if (CXXExceptionsEnabled) {
1899 CmdArgs.push_back("-fcxx-exceptions");
1900
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001901 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001902 }
1903 }
1904
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001905 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001906 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001907}
1908
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001909static bool ShouldDisableAutolink(const ArgList &Args,
1910 const ToolChain &TC) {
1911 bool Default = true;
1912 if (TC.getTriple().isOSDarwin()) {
1913 // The native darwin assembler doesn't support the linker_option directives,
1914 // so we disable them if we think the .s file will be passed to it.
1915 Default = TC.useIntegratedAs();
1916 }
1917 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1918 Default);
1919}
1920
Ted Kremenek62093662013-03-12 17:02:12 +00001921static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1922 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001923 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1924 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001925 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001926 return !UseDwarfDirectory;
1927}
1928
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001929/// \brief Check whether the given input tree contains any compilation actions.
1930static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001931 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001932 return true;
1933
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001934 for (const auto &Act : *A)
1935 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001936 return true;
1937
1938 return false;
1939}
1940
1941/// \brief Check if -relax-all should be passed to the internal assembler.
1942/// This is done by default when compiling non-assembler source with -O0.
1943static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1944 bool RelaxDefault = true;
1945
1946 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1947 RelaxDefault = A->getOption().matches(options::OPT_O0);
1948
1949 if (RelaxDefault) {
1950 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001951 for (const auto &Act : C.getActions()) {
1952 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001953 RelaxDefault = true;
1954 break;
1955 }
1956 }
1957 }
1958
1959 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1960 RelaxDefault);
1961}
1962
David Blaikie9260ed62013-07-25 21:19:01 +00001963static void CollectArgsForIntegratedAssembler(Compilation &C,
1964 const ArgList &Args,
1965 ArgStringList &CmdArgs,
1966 const Driver &D) {
1967 if (UseRelaxAll(C, Args))
1968 CmdArgs.push_back("-mrelax-all");
1969
David Peixottodfb66142013-11-14 22:52:58 +00001970 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001971 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001972 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1973 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1974 // arg after parsing the '-I' arg.
1975 bool TakeNextArg = false;
1976
David Blaikie9260ed62013-07-25 21:19:01 +00001977 // When using an integrated assembler, translate -Wa, and -Xassembler
1978 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001979 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001980 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1981 options::OPT_Xassembler),
1982 ie = Args.filtered_end(); it != ie; ++it) {
1983 const Arg *A = *it;
1984 A->claim();
1985
1986 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1987 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001988 if (TakeNextArg) {
1989 CmdArgs.push_back(Value.data());
1990 TakeNextArg = false;
1991 continue;
1992 }
David Blaikie9260ed62013-07-25 21:19:01 +00001993
1994 if (Value == "-force_cpusubtype_ALL") {
1995 // Do nothing, this is the default and we don't support anything else.
1996 } else if (Value == "-L") {
1997 CmdArgs.push_back("-msave-temp-labels");
1998 } else if (Value == "--fatal-warnings") {
1999 CmdArgs.push_back("-mllvm");
2000 CmdArgs.push_back("-fatal-assembler-warnings");
2001 } else if (Value == "--noexecstack") {
2002 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002003 } else if (Value == "-compress-debug-sections" ||
2004 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002005 CompressDebugSections = true;
2006 } else if (Value == "-nocompress-debug-sections" ||
2007 Value == "--nocompress-debug-sections") {
2008 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002009 } else if (Value.startswith("-I")) {
2010 CmdArgs.push_back(Value.data());
2011 // We need to consume the next argument if the current arg is a plain
2012 // -I. The next arg will be the include directory.
2013 if (Value == "-I")
2014 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002015 } else if (Value.startswith("-gdwarf-")) {
2016 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002017 } else {
2018 D.Diag(diag::err_drv_unsupported_option_argument)
2019 << A->getOption().getName() << Value;
2020 }
2021 }
2022 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002023 if (CompressDebugSections) {
2024 if (llvm::zlib::isAvailable())
2025 CmdArgs.push_back("-compress-debug-sections");
2026 else
2027 D.Diag(diag::warn_debug_compression_unavailable);
2028 }
David Blaikie9260ed62013-07-25 21:19:01 +00002029}
2030
Renato Goline807c122014-01-31 11:47:28 +00002031// Until ARM libraries are build separately, we have them all in one library
2032static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002033 if (TC.getArch() == llvm::Triple::arm ||
2034 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002035 return "arm";
2036 else
2037 return TC.getArchName();
2038}
2039
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002040static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2041 // The runtimes are located in the OS-specific resource directory.
2042 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002043 const llvm::Triple &Triple = TC.getTriple();
2044 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
2045 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
2046 "freebsd" : TC.getOS();
2047 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002048 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002049}
2050
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002051// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002052// FIXME: Make sure we can also emit shared objects if they're requested
2053// and available, check for possible errors, etc.
2054static void addClangRTLinux(
2055 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002056 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002057 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
2058 getArchNameForCompilerRTLib(TC) +
2059 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00002060
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002061 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00002062 CmdArgs.push_back("-lgcc_s");
2063 if (TC.getDriver().CCCIsCXX())
2064 CmdArgs.push_back("-lgcc_eh");
2065}
2066
Alexey Samsonov7811d192014-02-20 13:57:37 +00002067static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00002068 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
2069 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
2070 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002071 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002072 Args.hasArg(options::OPT_fcreate_profile) ||
2073 Args.hasArg(options::OPT_coverage)))
2074 return;
2075
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00002076 // -fprofile-instr-generate requires position-independent code to build with
2077 // shared objects. Link against the right archive.
2078 const char *Lib = "libclang_rt.profile-";
2079 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2080 Args.hasArg(options::OPT_shared))
2081 Lib = "libclang_rt.profile-pic-";
2082
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002083 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
2084 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00002085 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00002086
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00002087 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00002088}
2089
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002090static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
2091 const StringRef Sanitizer,
2092 bool Shared) {
2093 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
2094 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
2095 const char *EnvSuffix =
2096 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002097 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
2098 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002099 Twine("libclang_rt.") + Sanitizer + "-" +
2100 getArchNameForCompilerRTLib(TC) + EnvSuffix +
2101 (Shared ? ".so" : ".a"));
2102 return LibSanitizer;
2103}
2104
2105static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
2106 ArgStringList &CmdArgs,
2107 const StringRef Sanitizer,
2108 bool BeforeLibStdCXX,
2109 bool ExportSymbols = true,
2110 bool LinkDeps = true) {
2111 SmallString<128> LibSanitizer =
2112 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00002113
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002114 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
2115 // etc.) so that the linker picks custom versions of the global 'operator
2116 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002117 // strategy of inserting it at the front of the link command. It also
2118 // needs to be forced to end up in the executable, so wrap it in
2119 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00002120 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002121 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00002122 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002123 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00002124
2125 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
2126 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
2127
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002128 if (LinkDeps) {
2129 // Link sanitizer dependencies explicitly
2130 CmdArgs.push_back("-lpthread");
2131 CmdArgs.push_back("-lrt");
2132 CmdArgs.push_back("-lm");
2133 // There's no libdl on FreeBSD.
2134 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2135 CmdArgs.push_back("-ldl");
2136 }
Richard Smithf3e624c2013-03-23 00:30:08 +00002137
2138 // If possible, use a dynamic symbols file to export the symbols from the
2139 // runtime library. If we can't do so, use -export-dynamic instead to export
2140 // all symbols from the binary.
2141 if (ExportSymbols) {
2142 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
2143 CmdArgs.push_back(
2144 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
2145 else
2146 CmdArgs.push_back("-export-dynamic");
2147 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002148}
2149
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002150/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
2151/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002152static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002153 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002154 if (Shared) {
2155 // Link dynamic runtime if necessary.
2156 SmallString<128> LibSanitizer =
2157 getSanitizerRTLibName(TC, "asan", Shared);
2158 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002159 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002160
2161 // Do not link static runtime to DSOs or if compiling for Android.
2162 if (Args.hasArg(options::OPT_shared) ||
2163 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
2164 return;
2165
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002166 if (Shared) {
2167 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
2168 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
2169 /*LinkDeps*/ false);
2170 } else {
2171 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2172 if (IsCXX)
2173 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2174 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002175}
2176
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002177/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2178/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002179static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2180 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002181 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002182 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002183}
2184
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002185/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2186/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002187static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2188 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002189 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002190 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002191}
2192
2193/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2194/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002195static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2196 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002197 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002198 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002199}
2200
Richard Smithe30752c2012-10-09 19:52:38 +00002201/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2202/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002203static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2204 ArgStringList &CmdArgs, bool IsCXX,
2205 bool HasOtherSanitizerRt) {
Alexey Samsonovc6496812014-06-30 20:27:16 +00002206 // Do not link runtime into shared libraries.
2207 if (Args.hasArg(options::OPT_shared))
2208 return;
Richard Smith4244ea92014-06-04 23:28:46 +00002209
Nick Lewycky24921692013-10-19 00:27:23 +00002210 // Need a copy of sanitizer_common. This could come from another sanitizer
2211 // runtime; if we're not including one, include our own copy.
2212 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002213 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002214
Alexey Samsonovc6496812014-06-30 20:27:16 +00002215 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, true);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002216
2217 // Only include the bits of the runtime which need a C++ ABI library if
2218 // we're linking in C++ mode.
2219 if (IsCXX)
Alexey Samsonovc6496812014-06-30 20:27:16 +00002220 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false, true);
Richard Smithe30752c2012-10-09 19:52:38 +00002221}
2222
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002223static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2224 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002225 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002226 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2227}
2228
2229// Should be called before we add C++ ABI library.
2230static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2231 ArgStringList &CmdArgs) {
2232 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2233 const Driver &D = TC.getDriver();
2234 if (Sanitize.needsUbsanRt())
2235 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2236 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2237 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2238 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002239 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002240 if (Sanitize.needsTsanRt())
2241 addTsanRT(TC, Args, CmdArgs);
2242 if (Sanitize.needsMsanRt())
2243 addMsanRT(TC, Args, CmdArgs);
2244 if (Sanitize.needsLsanRt())
2245 addLsanRT(TC, Args, CmdArgs);
2246 if (Sanitize.needsDfsanRt())
2247 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002248}
2249
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002250static bool shouldUseFramePointerForTarget(const ArgList &Args,
2251 const llvm::Triple &Triple) {
2252 switch (Triple.getArch()) {
2253 // Don't use a frame pointer on linux if optimizing for certain targets.
2254 case llvm::Triple::mips64:
2255 case llvm::Triple::mips64el:
2256 case llvm::Triple::mips:
2257 case llvm::Triple::mipsel:
2258 case llvm::Triple::systemz:
2259 case llvm::Triple::x86:
2260 case llvm::Triple::x86_64:
2261 if (Triple.isOSLinux())
2262 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2263 if (!A->getOption().matches(options::OPT_O0))
2264 return false;
2265 return true;
2266 case llvm::Triple::xcore:
2267 return false;
2268 default:
2269 return true;
2270 }
2271}
2272
Rafael Espindola224dd632011-12-14 21:02:23 +00002273static bool shouldUseFramePointer(const ArgList &Args,
2274 const llvm::Triple &Triple) {
2275 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2276 options::OPT_fomit_frame_pointer))
2277 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2278
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002279 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002280}
2281
Eric Christopherb7d97e92013-04-03 01:58:53 +00002282static bool shouldUseLeafFramePointer(const ArgList &Args,
2283 const llvm::Triple &Triple) {
2284 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2285 options::OPT_momit_leaf_frame_pointer))
2286 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2287
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002288 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002289}
2290
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002291/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002292static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002293 SmallString<128> cwd;
2294 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002295 CmdArgs.push_back("-fdebug-compilation-dir");
2296 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002297 }
2298}
2299
Eric Christopherd3804002013-02-22 20:12:52 +00002300static const char *SplitDebugName(const ArgList &Args,
2301 const InputInfoList &Inputs) {
2302 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2303 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2304 SmallString<128> T(FinalOutput->getValue());
2305 llvm::sys::path::replace_extension(T, "dwo");
2306 return Args.MakeArgString(T);
2307 } else {
2308 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002309 SmallString<128> T(
2310 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002311 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2312 llvm::sys::path::replace_extension(F, "dwo");
2313 T += F;
2314 return Args.MakeArgString(F);
2315 }
2316}
2317
2318static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2319 const Tool &T, const JobAction &JA,
2320 const ArgList &Args, const InputInfo &Output,
2321 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002322 ArgStringList ExtractArgs;
2323 ExtractArgs.push_back("--extract-dwo");
2324
2325 ArgStringList StripArgs;
2326 StripArgs.push_back("--strip-dwo");
2327
2328 // Grabbing the output of the earlier compile step.
2329 StripArgs.push_back(Output.getFilename());
2330 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002331 ExtractArgs.push_back(OutFile);
2332
2333 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002334 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002335
2336 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002337 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002338
2339 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002340 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002341}
2342
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002343/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002344/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2345static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002346 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002347 if (A->getOption().matches(options::OPT_O4) ||
2348 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002349 return true;
2350
2351 if (A->getOption().matches(options::OPT_O0))
2352 return false;
2353
2354 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2355
Rafael Espindola91780de2013-08-26 14:05:41 +00002356 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002357 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002358 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002359 return true;
2360
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002361 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002362 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002363 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002364
2365 unsigned OptLevel = 0;
2366 if (S.getAsInteger(10, OptLevel))
2367 return false;
2368
2369 return OptLevel > 1;
2370 }
2371
2372 return false;
2373}
2374
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002375/// Add -x lang to \p CmdArgs for \p Input.
2376static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2377 ArgStringList &CmdArgs) {
2378 // When using -verify-pch, we don't want to provide the type
2379 // 'precompiled-header' if it was inferred from the file extension
2380 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2381 return;
2382
2383 CmdArgs.push_back("-x");
2384 if (Args.hasArg(options::OPT_rewrite_objc))
2385 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2386 else
2387 CmdArgs.push_back(types::getTypeName(Input.getType()));
2388}
2389
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002390static std::string getMSCompatibilityVersion(const char *VersionStr) {
2391 unsigned Version;
2392 if (StringRef(VersionStr).getAsInteger(10, Version))
2393 return "0";
2394
2395 if (Version < 100)
2396 return llvm::utostr_32(Version) + ".0";
2397
2398 if (Version < 10000)
2399 return llvm::utostr_32(Version / 100) + "." +
2400 llvm::utostr_32(Version % 100);
2401
2402 unsigned Build = 0, Factor = 1;
2403 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2404 Build = Build + (Version % 10) * Factor;
2405 return llvm::utostr_32(Version / 100) + "." +
2406 llvm::utostr_32(Version % 100) + "." +
2407 llvm::utostr_32(Build);
2408}
2409
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002410void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002411 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002412 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002413 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002414 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002415 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2416 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002417 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002418 ArgStringList CmdArgs;
2419
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002420 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002421 bool IsWindowsCygnus =
2422 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002423 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2424
Daniel Dunbare521a892009-03-31 20:53:55 +00002425 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2426
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002427 // Invoke ourselves in -cc1 mode.
2428 //
2429 // FIXME: Implement custom jobs for internal actions.
2430 CmdArgs.push_back("-cc1");
2431
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002432 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002433 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002434 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002435 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002436
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002437 const llvm::Triple TT(TripleStr);
2438 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2439 TT.getArch() == llvm::Triple::thumb)) {
2440 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2441 unsigned Version;
2442 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2443 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002444 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2445 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002446 }
2447
Tim Northover336f1892014-03-29 13:16:12 +00002448 // Push all default warning arguments that are specific to
2449 // the given target. These come before user provided warning options
2450 // are provided.
2451 getToolChain().addClangWarningOptions(CmdArgs);
2452
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002453 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002454 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002455
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002456 if (isa<AnalyzeJobAction>(JA)) {
2457 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2458 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002459 } else if (isa<MigrateJobAction>(JA)) {
2460 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002461 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002462 if (Output.getType() == types::TY_Dependencies)
2463 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002464 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002465 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002466 if (Args.hasArg(options::OPT_rewrite_objc) &&
2467 !Args.hasArg(options::OPT_g_Group))
2468 CmdArgs.push_back("-P");
2469 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002470 } else if (isa<AssembleJobAction>(JA)) {
2471 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002472
David Blaikie9260ed62013-07-25 21:19:01 +00002473 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002474
2475 // Also ignore explicit -force_cpusubtype_ALL option.
2476 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002477 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002478 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002479 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002480
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002481 if (JA.getType() == types::TY_Nothing)
2482 CmdArgs.push_back("-fsyntax-only");
2483 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002484 CmdArgs.push_back("-emit-pch");
2485 else
2486 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002487 } else if (isa<VerifyPCHJobAction>(JA)) {
2488 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002489 } else {
2490 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002491
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002492 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002493 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002494 } else if (JA.getType() == types::TY_LLVM_IR ||
2495 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002496 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002497 } else if (JA.getType() == types::TY_LLVM_BC ||
2498 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002499 CmdArgs.push_back("-emit-llvm-bc");
2500 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002501 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002502 } else if (JA.getType() == types::TY_AST) {
2503 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002504 } else if (JA.getType() == types::TY_ModuleFile) {
2505 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002506 } else if (JA.getType() == types::TY_RewrittenObjC) {
2507 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002508 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002509 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2510 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002511 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002512 } else {
2513 assert(JA.getType() == types::TY_PP_Asm &&
2514 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002515 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002516 }
2517
Justin Bognera88f0122014-06-20 22:59:50 +00002518 // We normally speed up the clang process a bit by skipping destructors at
2519 // exit, but when we're generating diagnostics we can rely on some of the
2520 // cleanup.
2521 if (!C.isForDiagnostics())
2522 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002523
John McCallbb79b5f2010-02-13 03:50:24 +00002524 // Disable the verification pass in -asserts builds.
2525#ifdef NDEBUG
2526 CmdArgs.push_back("-disable-llvm-verifier");
2527#endif
2528
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002529 // Set the main file name, so that debug info works even with
2530 // -save-temps.
2531 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002532 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002533
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002534 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002535 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002536 if (Args.hasArg(options::OPT_static))
2537 CmdArgs.push_back("-static-define");
2538
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002539 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002540 // Enable region store model by default.
2541 CmdArgs.push_back("-analyzer-store=region");
2542
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002543 // Treat blocks as analysis entry points.
2544 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2545
Ted Kremenek49c79792011-03-24 00:28:47 +00002546 CmdArgs.push_back("-analyzer-eagerly-assume");
2547
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002548 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002549 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002550 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002551
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002552 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002553 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002554
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002555 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002556 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002557
2558 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002559
Jordan Rose10ad0812013-04-05 17:55:07 +00002560 if (types::isCXX(Inputs[0].getType()))
2561 CmdArgs.push_back("-analyzer-checker=cplusplus");
2562
Nico Webere8e53112014-05-11 01:04:02 +00002563 // Enable the following experimental checkers for testing.
2564 CmdArgs.push_back(
2565 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002566 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2567 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2568 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2569 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2570 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002571 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002572
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002573 // Set the output format. The default is plist, for (lame) historical
2574 // reasons.
2575 CmdArgs.push_back("-analyzer-output");
2576 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002577 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002578 else
2579 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002580
Ted Kremenekfe449a22010-03-22 22:32:05 +00002581 // Disable the presentation of standard compiler warnings when
2582 // using --analyze. We only want to show static analyzer diagnostics
2583 // or frontend errors.
2584 CmdArgs.push_back("-w");
2585
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002586 // Add -Xanalyzer arguments when running as analyzer.
2587 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002588 }
2589
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002590 CheckCodeGenerationOptions(D, Args);
2591
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002592 bool PIE = getToolChain().isPIEDefault();
2593 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002594 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002595
Alexey Bataev40e75222014-01-28 06:30:35 +00002596 // Android-specific defaults for PIC/PIE
2597 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2598 switch (getToolChain().getTriple().getArch()) {
2599 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002600 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002601 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002602 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002603 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002604 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002605 case llvm::Triple::mips:
2606 case llvm::Triple::mipsel:
2607 case llvm::Triple::mips64:
2608 case llvm::Triple::mips64el:
2609 PIC = true; // "-fpic"
2610 break;
2611
2612 case llvm::Triple::x86:
2613 case llvm::Triple::x86_64:
2614 PIC = true; // "-fPIC"
2615 IsPICLevelTwo = true;
2616 break;
2617
2618 default:
2619 break;
2620 }
2621 }
2622
Brad Smith5b05db82014-06-24 19:51:29 +00002623 // OpenBSD-specific defaults for PIE
2624 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2625 switch (getToolChain().getTriple().getArch()) {
2626 case llvm::Triple::mips64:
2627 case llvm::Triple::mips64el:
2628 case llvm::Triple::sparc:
2629 case llvm::Triple::x86:
2630 case llvm::Triple::x86_64:
2631 IsPICLevelTwo = false; // "-fpie"
2632 break;
2633
2634 case llvm::Triple::ppc:
2635 case llvm::Triple::sparcv9:
2636 IsPICLevelTwo = true; // "-fPIE"
2637 break;
2638
2639 default:
2640 break;
2641 }
2642 }
2643
Alexey Samsonov090301e2013-04-09 12:28:19 +00002644 // For the PIC and PIE flag options, this logic is different from the
2645 // legacy logic in very old versions of GCC, as that logic was just
2646 // a bug no one had ever fixed. This logic is both more rational and
2647 // consistent with GCC's new logic now that the bugs are fixed. The last
2648 // argument relating to either PIC or PIE wins, and no other argument is
2649 // used. If the last argument is any flavor of the '-fno-...' arguments,
2650 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2651 // at the same level.
2652 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2653 options::OPT_fpic, options::OPT_fno_pic,
2654 options::OPT_fPIE, options::OPT_fno_PIE,
2655 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002656 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2657 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002658 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002659 if (LastPICArg) {
2660 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002661 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2662 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2663 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2664 PIC = PIE || O.matches(options::OPT_fPIC) ||
2665 O.matches(options::OPT_fpic);
2666 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2667 O.matches(options::OPT_fPIC);
2668 } else {
2669 PIE = PIC = false;
2670 }
2671 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002672 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002673
Nick Lewycky609dd662013-10-11 03:33:53 +00002674 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002675 // specified while enabling PIC enabled level 1 PIC, just force it back to
2676 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2677 // informal testing).
2678 if (PIC && getToolChain().getTriple().isOSDarwin())
2679 IsPICLevelTwo |= getToolChain().isPICDefault();
2680
Chandler Carruthc0c04552012-04-08 16:40:35 +00002681 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2682 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002683 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002684 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002685 Triple.getArch() == llvm::Triple::arm64 ||
2686 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002687 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002688 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002689 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002690
Chandler Carruth76a943b2012-11-19 03:52:03 +00002691 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2692 // This is a very special mode. It trumps the other modes, almost no one
2693 // uses it, and it isn't even valid on any OS but Darwin.
2694 if (!getToolChain().getTriple().isOSDarwin())
2695 D.Diag(diag::err_drv_unsupported_opt_for_target)
2696 << A->getSpelling() << getToolChain().getTriple().str();
2697
2698 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2699
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002700 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002701 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002702
Chandler Carruth76a943b2012-11-19 03:52:03 +00002703 // Only a forced PIC mode can cause the actual compile to have PIC defines
2704 // etc., no flags are sufficient. This behavior was selected to closely
2705 // match that of llvm-gcc and Apple GCC before that.
2706 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2707 CmdArgs.push_back("-pic-level");
2708 CmdArgs.push_back("2");
2709 }
2710 } else {
2711 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2712 // handled in Clang's IRGen by the -pie-level flag.
2713 CmdArgs.push_back("-mrelocation-model");
2714 CmdArgs.push_back(PIC ? "pic" : "static");
2715
2716 if (PIC) {
2717 CmdArgs.push_back("-pic-level");
2718 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2719 if (PIE) {
2720 CmdArgs.push_back("-pie-level");
2721 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2722 }
2723 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002724 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002725
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002726 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2727 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002728 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002729
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002730 // LLVM Code Generator Options.
2731
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002732 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2733 StringRef v = A->getValue();
2734 CmdArgs.push_back("-mllvm");
2735 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2736 A->claim();
2737 }
2738
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002739 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2740 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002741 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002742 }
2743
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002744 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2745 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002746 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002747 D.Diag(diag::err_drv_unsupported_opt_for_target)
2748 << A->getSpelling() << getToolChain().getTriple().str();
2749 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2750 CmdArgs.push_back("-fpcc-struct-return");
2751 } else {
2752 assert(A->getOption().matches(options::OPT_freg_struct_return));
2753 CmdArgs.push_back("-freg-struct-return");
2754 }
2755 }
2756
Roman Divacky65b88cd2011-03-01 17:40:53 +00002757 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2758 CmdArgs.push_back("-mrtd");
2759
Rafael Espindola224dd632011-12-14 21:02:23 +00002760 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002761 CmdArgs.push_back("-mdisable-fp-elim");
2762 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2763 options::OPT_fno_zero_initialized_in_bss))
2764 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002765
2766 bool OFastEnabled = isOptimizationLevelFast(Args);
2767 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2768 // enabled. This alias option is being used to simplify the hasFlag logic.
2769 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2770 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002771 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2772 // doesn't do any TBAA.
2773 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002774 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002775 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002776 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002777 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2778 options::OPT_fno_struct_path_tbaa))
2779 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002780 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2781 false))
2782 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002783 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2784 options::OPT_fno_optimize_sibling_calls))
2785 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002786
Eric Christopher006208c2013-04-04 06:29:47 +00002787 // Handle segmented stacks.
2788 if (Args.hasArg(options::OPT_fsplit_stack))
2789 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002790
2791 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2792 // This alias option is being used to simplify the getLastArg logic.
2793 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2794 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002795
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002796 // Handle various floating point optimization flags, mapping them to the
2797 // appropriate LLVM code generation flags. The pattern for all of these is to
2798 // default off the codegen optimizations, and if any flag enables them and no
2799 // flag disables them after the flag enabling them, enable the codegen
2800 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002801 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002802 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002803 options::OPT_ffinite_math_only,
2804 options::OPT_fno_finite_math_only,
2805 options::OPT_fhonor_infinities,
2806 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002807 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2808 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002809 A->getOption().getID() != options::OPT_fhonor_infinities)
2810 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002811 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002812 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002813 options::OPT_ffinite_math_only,
2814 options::OPT_fno_finite_math_only,
2815 options::OPT_fhonor_nans,
2816 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002817 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2818 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002819 A->getOption().getID() != options::OPT_fhonor_nans)
2820 CmdArgs.push_back("-menable-no-nans");
2821
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002822 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2823 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002824 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002825 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002826 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002827 options::OPT_fno_math_errno)) {
2828 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2829 // However, turning *off* -ffast_math merely restores the toolchain default
2830 // (which may be false).
2831 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2832 A->getOption().getID() == options::OPT_ffast_math ||
2833 A->getOption().getID() == options::OPT_Ofast)
2834 MathErrno = false;
2835 else if (A->getOption().getID() == options::OPT_fmath_errno)
2836 MathErrno = true;
2837 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002838 if (MathErrno)
2839 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002840
2841 // There are several flags which require disabling very specific
2842 // optimizations. Any of these being disabled forces us to turn off the
2843 // entire set of LLVM optimizations, so collect them through all the flag
2844 // madness.
2845 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002846 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002847 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002848 options::OPT_funsafe_math_optimizations,
2849 options::OPT_fno_unsafe_math_optimizations,
2850 options::OPT_fassociative_math,
2851 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002852 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2853 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002854 A->getOption().getID() != options::OPT_fno_associative_math)
2855 AssociativeMath = true;
2856 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002857 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002858 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002859 options::OPT_funsafe_math_optimizations,
2860 options::OPT_fno_unsafe_math_optimizations,
2861 options::OPT_freciprocal_math,
2862 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002863 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2864 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002865 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2866 ReciprocalMath = true;
2867 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002868 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002869 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002870 options::OPT_funsafe_math_optimizations,
2871 options::OPT_fno_unsafe_math_optimizations,
2872 options::OPT_fsigned_zeros,
2873 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002874 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2875 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002876 A->getOption().getID() != options::OPT_fsigned_zeros)
2877 SignedZeros = false;
2878 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002879 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002880 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002881 options::OPT_funsafe_math_optimizations,
2882 options::OPT_fno_unsafe_math_optimizations,
2883 options::OPT_ftrapping_math,
2884 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002885 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2886 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002887 A->getOption().getID() != options::OPT_ftrapping_math)
2888 TrappingMath = false;
2889 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2890 !TrappingMath)
2891 CmdArgs.push_back("-menable-unsafe-fp-math");
2892
Lang Hamesaa53b932012-07-06 00:59:19 +00002893
2894 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002895 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002896 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002897 options::OPT_ffp_contract)) {
2898 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002899 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002900 if (Val == "fast" || Val == "on" || Val == "off") {
2901 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2902 } else {
2903 D.Diag(diag::err_drv_unsupported_option_argument)
2904 << A->getOption().getName() << Val;
2905 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002906 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2907 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002908 // If fast-math is set then set the fp-contract mode to fast.
2909 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2910 }
2911 }
2912
Bob Wilson6a039162012-07-19 03:52:53 +00002913 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2914 // and if we find them, tell the frontend to provide the appropriate
2915 // preprocessor macros. This is distinct from enabling any optimizations as
2916 // these options induce language changes which must survive serialization
2917 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002918 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2919 options::OPT_fno_fast_math))
2920 if (!A->getOption().matches(options::OPT_fno_fast_math))
2921 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002922 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2923 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002924 if (A->getOption().matches(options::OPT_ffinite_math_only))
2925 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002926
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002927 // Decide whether to use verbose asm. Verbose assembly is the default on
2928 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002929 bool IsIntegratedAssemblerDefault =
2930 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002931 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002932 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002933 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002934 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002935
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002936 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002937 IsIntegratedAssemblerDefault))
2938 CmdArgs.push_back("-no-integrated-as");
2939
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002940 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2941 CmdArgs.push_back("-mdebug-pass");
2942 CmdArgs.push_back("Structure");
2943 }
2944 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2945 CmdArgs.push_back("-mdebug-pass");
2946 CmdArgs.push_back("Arguments");
2947 }
2948
John McCall8517abc2010-02-19 02:45:38 +00002949 // Enable -mconstructor-aliases except on darwin, where we have to
2950 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002951 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002952 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002953
John McCall7ef5cb32011-03-18 02:56:14 +00002954 // Darwin's kernel doesn't support guard variables; just die if we
2955 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002956 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002957 CmdArgs.push_back("-fforbid-guard-variables");
2958
Douglas Gregordbe39272011-02-01 15:15:22 +00002959 if (Args.hasArg(options::OPT_mms_bitfields)) {
2960 CmdArgs.push_back("-mms-bitfields");
2961 }
John McCall8517abc2010-02-19 02:45:38 +00002962
Daniel Dunbar306945d2009-09-16 06:17:29 +00002963 // This is a coarse approximation of what llvm-gcc actually does, both
2964 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2965 // complicated ways.
2966 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002967 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2968 options::OPT_fno_asynchronous_unwind_tables,
2969 (getToolChain().IsUnwindTablesDefault() ||
2970 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2971 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002972 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2973 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002974 CmdArgs.push_back("-munwind-tables");
2975
Chandler Carruth05fb5852012-11-21 23:40:23 +00002976 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002977
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002978 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2979 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002980 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002981 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002982
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002983 // FIXME: Handle -mtune=.
2984 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002985
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002986 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002987 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002988 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002989 }
2990
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002991 // Add the target cpu
2992 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2993 llvm::Triple ETriple(ETripleStr);
2994 std::string CPU = getCPUName(Args, ETriple);
2995 if (!CPU.empty()) {
2996 CmdArgs.push_back("-target-cpu");
2997 CmdArgs.push_back(Args.MakeArgString(CPU));
2998 }
2999
Rafael Espindolaeb265472013-08-21 21:59:03 +00003000 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3001 CmdArgs.push_back("-mfpmath");
3002 CmdArgs.push_back(A->getValue());
3003 }
3004
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003005 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003006 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003007
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003008 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003009 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003010 default:
3011 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003012
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003013 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003014 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003015 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003016 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003017 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003018 break;
3019
Tim Northover573cbee2014-05-24 12:52:07 +00003020 case llvm::Triple::aarch64:
3021 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00003022 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00003023 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003024 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003025 break;
3026
Eric Christopher0b26a612010-03-02 02:41:08 +00003027 case llvm::Triple::mips:
3028 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003029 case llvm::Triple::mips64:
3030 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003031 AddMIPSTargetArgs(Args, CmdArgs);
3032 break;
3033
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003034 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003035 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003036 AddSparcTargetArgs(Args, CmdArgs);
3037 break;
3038
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003039 case llvm::Triple::x86:
3040 case llvm::Triple::x86_64:
3041 AddX86TargetArgs(Args, CmdArgs);
3042 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003043
3044 case llvm::Triple::hexagon:
3045 AddHexagonTargetArgs(Args, CmdArgs);
3046 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003047 }
3048
Hans Wennborg75958c42013-08-08 00:17:41 +00003049 // Add clang-cl arguments.
3050 if (getToolChain().getDriver().IsCLMode())
3051 AddClangCLArgs(Args, CmdArgs);
3052
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003053 // Pass the linker version in use.
3054 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3055 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003056 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003057 }
3058
Eric Christopherb7d97e92013-04-03 01:58:53 +00003059 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003060 CmdArgs.push_back("-momit-leaf-frame-pointer");
3061
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003062 // Explicitly error on some things we know we don't support and can't just
3063 // ignore.
3064 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003065 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3066 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003067 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003068 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003069 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003070 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3071 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003072 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003073 << Unsupported->getOption().getName();
3074 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003075 }
3076
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003077 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003078 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003079 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003080 CmdArgs.push_back("-header-include-file");
3081 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3082 D.CCPrintHeadersFilename : "-");
3083 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003084 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003085 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003086
Chad Rosierbe10f982011-08-02 17:58:04 +00003087 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003088 CmdArgs.push_back("-diagnostic-log-file");
3089 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3090 D.CCLogDiagnosticsFilename : "-");
3091 }
3092
Manman Ren17bdb0f2013-11-20 20:22:14 +00003093 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3094 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003095 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003096 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00003097 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003098 // FIXME: we should support specifying dwarf version with
3099 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003100 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00003101 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
3102 const llvm::Triple &Triple = getToolChain().getTriple();
3103 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3104 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003105 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003106 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003107 CmdArgs.push_back("-gdwarf-2");
3108 else if (A->getOption().matches(options::OPT_gdwarf_3))
3109 CmdArgs.push_back("-gdwarf-3");
3110 else if (A->getOption().matches(options::OPT_gdwarf_4))
3111 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003112 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003113 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00003114 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
3115 const llvm::Triple &Triple = getToolChain().getTriple();
3116 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3117 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003118 CmdArgs.push_back("-gdwarf-2");
3119 else
3120 CmdArgs.push_back("-g");
3121 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003122 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003123
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003124 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3125 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003126 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3127 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003128 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003129
Eric Christopher138c32b2013-09-13 22:37:55 +00003130 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003131 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3132 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003133 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003134 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003135 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003136 CmdArgs.push_back("-g");
3137 CmdArgs.push_back("-backend-option");
3138 CmdArgs.push_back("-split-dwarf=Enable");
3139 }
3140
Eric Christopher138c32b2013-09-13 22:37:55 +00003141 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3142 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3143 CmdArgs.push_back("-backend-option");
3144 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3145 }
Eric Christophereec89c22013-06-18 00:03:50 +00003146
Eric Christopher0d403d22014-02-14 01:27:03 +00003147 // -gdwarf-aranges turns on the emission of the aranges section in the
3148 // backend.
3149 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3150 CmdArgs.push_back("-backend-option");
3151 CmdArgs.push_back("-generate-arange-section");
3152 }
3153
David Blaikief36d9ba2014-01-27 18:52:43 +00003154 if (Args.hasFlag(options::OPT_fdebug_types_section,
3155 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003156 CmdArgs.push_back("-backend-option");
3157 CmdArgs.push_back("-generate-type-units");
3158 }
Eric Christophereec89c22013-06-18 00:03:50 +00003159
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003160 if (Args.hasFlag(options::OPT_ffunction_sections,
3161 options::OPT_fno_function_sections, false)) {
3162 CmdArgs.push_back("-ffunction-sections");
3163 }
3164
3165 if (Args.hasFlag(options::OPT_fdata_sections,
3166 options::OPT_fno_data_sections, false)) {
3167 CmdArgs.push_back("-fdata-sections");
3168 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003169
Chris Lattner3c77a352010-06-22 00:03:40 +00003170 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3171
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003172 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3173 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3174 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3175 D.Diag(diag::err_drv_argument_not_allowed_with)
3176 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3177
3178 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3179
3180 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3181 A->render(Args, CmdArgs);
3182 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3183 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3184
Nick Lewycky207bce32011-04-21 23:44:07 +00003185 if (Args.hasArg(options::OPT_ftest_coverage) ||
3186 Args.hasArg(options::OPT_coverage))
3187 CmdArgs.push_back("-femit-coverage-notes");
3188 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3189 Args.hasArg(options::OPT_coverage))
3190 CmdArgs.push_back("-femit-coverage-data");
3191
Nick Lewycky480cb992011-05-04 20:46:58 +00003192 if (C.getArgs().hasArg(options::OPT_c) ||
3193 C.getArgs().hasArg(options::OPT_S)) {
3194 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003195 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00003196 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00003197 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003198 SmallString<128> Pwd;
3199 if (!llvm::sys::fs::current_path(Pwd)) {
3200 llvm::sys::path::append(Pwd, CoverageFilename.str());
3201 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003202 }
3203 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003204 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003205 }
3206 }
3207
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003208 // Pass options for controlling the default header search paths.
3209 if (Args.hasArg(options::OPT_nostdinc)) {
3210 CmdArgs.push_back("-nostdsysteminc");
3211 CmdArgs.push_back("-nobuiltininc");
3212 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003213 if (Args.hasArg(options::OPT_nostdlibinc))
3214 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003215 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3216 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3217 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003218
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003219 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003220 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003221 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003222
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003223 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3224
Ted Kremenekf7639e12012-03-06 20:06:33 +00003225 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003226 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003227 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003228 options::OPT_ccc_arcmt_modify,
3229 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003230 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003231 switch (A->getOption().getID()) {
3232 default:
3233 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003234 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003235 CmdArgs.push_back("-arcmt-check");
3236 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003237 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003238 CmdArgs.push_back("-arcmt-modify");
3239 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003240 case options::OPT_ccc_arcmt_migrate:
3241 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003242 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003243 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003244
3245 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3246 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003247 break;
John McCalld70fb982011-06-15 23:25:17 +00003248 }
3249 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003250 } else {
3251 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3252 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3253 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003254 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003255
Ted Kremenekf7639e12012-03-06 20:06:33 +00003256 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3257 if (ARCMTEnabled) {
3258 D.Diag(diag::err_drv_argument_not_allowed_with)
3259 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3260 }
3261 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003262 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003263
3264 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003265 options::OPT_objcmt_migrate_subscripting,
3266 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003267 // None specified, means enable them all.
3268 CmdArgs.push_back("-objcmt-migrate-literals");
3269 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003270 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003271 } else {
3272 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3273 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003274 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003275 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003276 } else {
3277 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3278 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3279 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3280 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3281 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3282 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3283 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3284 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3285 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3286 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3287 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3288 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3289 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003290 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003291 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003292 }
3293
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003294 // Add preprocessing options like -I, -D, etc. if we are using the
3295 // preprocessor.
3296 //
3297 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003298 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003299 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003300
Rafael Espindolaa7431922011-07-21 23:40:37 +00003301 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3302 // that "The compiler can only warn and ignore the option if not recognized".
3303 // When building with ccache, it will pass -D options to clang even on
3304 // preprocessed inputs and configure concludes that -fPIC is not supported.
3305 Args.ClaimAllArgs(options::OPT_D);
3306
Alp Toker7874bdc2013-11-15 20:40:58 +00003307 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003308 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3309 if (A->getOption().matches(options::OPT_O4)) {
3310 CmdArgs.push_back("-O3");
3311 D.Diag(diag::warn_O4_is_O3);
3312 } else {
3313 A->render(Args, CmdArgs);
3314 }
3315 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003316
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003317 // Warn about ignored options to clang.
3318 for (arg_iterator it = Args.filtered_begin(
3319 options::OPT_clang_ignored_gcc_optimization_f_Group),
3320 ie = Args.filtered_end(); it != ie; ++it) {
3321 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3322 }
3323
Chad Rosier86b82082012-12-12 20:06:31 +00003324 // Don't warn about unused -flto. This can happen when we're preprocessing or
3325 // precompiling.
3326 Args.ClaimAllArgs(options::OPT_flto);
3327
Daniel Dunbar945577c2009-10-29 02:24:45 +00003328 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003329 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3330 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003331 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003332 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003333
3334 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003335 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003336 //
3337 // If a std is supplied, only add -trigraphs if it follows the
3338 // option.
3339 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3340 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003341 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003342 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003343 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003344 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003345 else
3346 Std->render(Args, CmdArgs);
3347
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003348 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3349 options::OPT_trigraphs))
3350 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003351 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003352 } else {
3353 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003354 //
3355 // FIXME: Clang doesn't correctly handle -std= when the input language
3356 // doesn't match. For the time being just ignore this for C++ inputs;
3357 // eventually we want to do all the standard defaulting here instead of
3358 // splitting it between the driver and clang -cc1.
3359 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003360 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3361 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003362 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003363 CmdArgs.push_back("-std=c++11");
3364
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003365 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003366 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003367
Richard Smith282b4492013-09-04 22:50:31 +00003368 // GCC's behavior for -Wwrite-strings is a bit strange:
3369 // * In C, this "warning flag" changes the types of string literals from
3370 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3371 // for the discarded qualifier.
3372 // * In C++, this is just a normal warning flag.
3373 //
3374 // Implementing this warning correctly in C is hard, so we follow GCC's
3375 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3376 // a non-const char* in C, rather than using this crude hack.
3377 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003378 // FIXME: This should behave just like a warning flag, and thus should also
3379 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3380 Arg *WriteStrings =
3381 Args.getLastArg(options::OPT_Wwrite_strings,
3382 options::OPT_Wno_write_strings, options::OPT_w);
3383 if (WriteStrings &&
3384 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003385 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003386 }
3387
Chandler Carruth61fbf622011-04-23 09:27:53 +00003388 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003389 // during C++ compilation, which it is by default. GCC keeps this define even
3390 // in the presence of '-w', match this behavior bug-for-bug.
3391 if (types::isCXX(InputType) &&
3392 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3393 true)) {
3394 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003395 }
3396
Chandler Carruthe0391482010-05-22 02:21:53 +00003397 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3398 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3399 if (Asm->getOption().matches(options::OPT_fasm))
3400 CmdArgs.push_back("-fgnu-keywords");
3401 else
3402 CmdArgs.push_back("-fno-gnu-keywords");
3403 }
3404
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003405 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3406 CmdArgs.push_back("-fno-dwarf-directory-asm");
3407
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003408 if (ShouldDisableAutolink(Args, getToolChain()))
3409 CmdArgs.push_back("-fno-autolink");
3410
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003411 // Add in -fdebug-compilation-dir if necessary.
3412 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003413
Richard Smith9a568822011-11-21 19:36:32 +00003414 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3415 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003416 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003417 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003418 }
3419
Richard Smith79c927b2013-11-06 19:31:51 +00003420 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3421 CmdArgs.push_back("-foperator-arrow-depth");
3422 CmdArgs.push_back(A->getValue());
3423 }
3424
Richard Smith9a568822011-11-21 19:36:32 +00003425 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3426 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003427 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003428 }
3429
Richard Smitha3d3bd22013-05-08 02:12:03 +00003430 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3431 CmdArgs.push_back("-fconstexpr-steps");
3432 CmdArgs.push_back(A->getValue());
3433 }
3434
Richard Smithb3a14522013-02-22 01:59:51 +00003435 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3436 CmdArgs.push_back("-fbracket-depth");
3437 CmdArgs.push_back(A->getValue());
3438 }
3439
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003440 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3441 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003442 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003443 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003444 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3445 } else
3446 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003447 }
3448
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003449
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003450 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003451 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003452
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003453 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3454 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003455 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003456 }
David Chisnall5778fce2009-08-31 16:41:57 +00003457
Chris Lattnere23003d2010-01-09 21:54:33 +00003458 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3459 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003460 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003461 }
3462
Chris Lattnerb35583d2010-04-07 20:49:23 +00003463 CmdArgs.push_back("-ferror-limit");
3464 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003465 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003466 else
3467 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003468
Chandler Carrutha77a7272010-05-06 04:55:18 +00003469 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3470 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003471 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003472 }
3473
3474 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3475 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003476 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003477 }
3478
Richard Smithf6f003a2011-12-16 19:06:07 +00003479 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3480 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003481 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003482 }
3483
Daniel Dunbar2c978472009-11-04 06:24:47 +00003484 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003485 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003486 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003487 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003488 } else {
3489 // If -fmessage-length=N was not specified, determine whether this is a
3490 // terminal and, if so, implicitly define -fmessage-length appropriately.
3491 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003492 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003493 }
3494
John McCallb4a99d32013-02-19 01:57:35 +00003495 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3496 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3497 options::OPT_fvisibility_ms_compat)) {
3498 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3499 CmdArgs.push_back("-fvisibility");
3500 CmdArgs.push_back(A->getValue());
3501 } else {
3502 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3503 CmdArgs.push_back("-fvisibility");
3504 CmdArgs.push_back("hidden");
3505 CmdArgs.push_back("-ftype-visibility");
3506 CmdArgs.push_back("default");
3507 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003508 }
3509
Douglas Gregor08329632010-06-15 17:05:35 +00003510 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003511
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003512 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3513
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003514 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003515 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3516 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003517 CmdArgs.push_back("-ffreestanding");
3518
Daniel Dunbare357d562009-12-03 18:42:11 +00003519 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003520 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003521 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003522 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3523 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003524 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003525 // AltiVec language extensions aren't relevant for assembling.
3526 if (!isa<PreprocessJobAction>(JA) ||
3527 Output.getType() != types::TY_PP_Asm)
3528 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003529 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3530 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003531
Peter Collingbourne32701642013-11-01 18:16:25 +00003532 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3533 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003534
Will Dietz3676d562012-12-30 20:53:28 +00003535 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3536 options::OPT_fno_sanitize_recover,
3537 true))
3538 CmdArgs.push_back("-fno-sanitize-recover");
3539
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003540 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003541 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3542 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3543
Eric Christopher459d2712013-02-19 06:16:53 +00003544 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003545 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003546 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003547 getToolChain().getArch() == llvm::Triple::ppc64 ||
3548 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003549 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003550 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003551
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003552 if (getToolChain().SupportsProfiling())
3553 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003554
3555 // -flax-vector-conversions is default.
3556 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3557 options::OPT_fno_lax_vector_conversions))
3558 CmdArgs.push_back("-fno-lax-vector-conversions");
3559
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003560 if (Args.getLastArg(options::OPT_fapple_kext))
3561 CmdArgs.push_back("-fapple-kext");
3562
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003563 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003564 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003565 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003566 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3567 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003568
3569 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3570 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003571 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003572 }
3573
Bob Wilson14adb362012-02-03 06:27:22 +00003574 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003575
Chandler Carruth6e501032011-03-27 00:04:55 +00003576 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3577 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3578 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3579 options::OPT_fno_wrapv)) {
3580 if (A->getOption().matches(options::OPT_fwrapv))
3581 CmdArgs.push_back("-fwrapv");
3582 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3583 options::OPT_fno_strict_overflow)) {
3584 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3585 CmdArgs.push_back("-fwrapv");
3586 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003587
3588 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3589 options::OPT_fno_reroll_loops))
3590 if (A->getOption().matches(options::OPT_freroll_loops))
3591 CmdArgs.push_back("-freroll-loops");
3592
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003593 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003594 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3595 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003596
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003597 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3598
Mahesha S6a682be42012-10-27 07:47:56 +00003599
Daniel Dunbar4930e332009-11-17 08:07:36 +00003600 // -stack-protector=0 is default.
3601 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003602 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3603 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003604 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003605 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003606 if (A->getOption().matches(options::OPT_fstack_protector)) {
3607 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3608 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3609 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003610 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003611 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003612 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003613 } else {
3614 StackProtectorLevel =
3615 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3616 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003617 if (StackProtectorLevel) {
3618 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003619 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003620 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003621
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003622 // --param ssp-buffer-size=
3623 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3624 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003625 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003626 if (Str.startswith("ssp-buffer-size=")) {
3627 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003628 CmdArgs.push_back("-stack-protector-buffer-size");
3629 // FIXME: Verify the argument is a valid integer.
3630 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003631 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003632 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003633 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003634 }
3635
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003636 // Translate -mstackrealign
3637 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3638 false)) {
3639 CmdArgs.push_back("-backend-option");
3640 CmdArgs.push_back("-force-align-stack");
3641 }
3642 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3643 false)) {
3644 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3645 }
3646
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003647 if (Args.hasArg(options::OPT_mstack_alignment)) {
3648 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3649 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003650 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003651 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003652 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003653 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3654 options::OPT_munaligned_access)) {
3655 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3656 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003657 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3658 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3659 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003660 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003661 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003662 else
3663 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003664 } else {
3665 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003666 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3667 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3668 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003669 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003670 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003671 else
3672 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003673 }
Renato Golina146a482013-08-24 14:44:41 +00003674 }
Chad Rosier60027022012-11-09 17:29:19 +00003675 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003676
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003677 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3678 options::OPT_mno_restrict_it)) {
3679 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3680 CmdArgs.push_back("-backend-option");
3681 CmdArgs.push_back("-arm-restrict-it");
3682 } else {
3683 CmdArgs.push_back("-backend-option");
3684 CmdArgs.push_back("-arm-no-restrict-it");
3685 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003686 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3687 TT.getArch() == llvm::Triple::thumb)) {
3688 // Windows on ARM expects restricted IT blocks
3689 CmdArgs.push_back("-backend-option");
3690 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003691 }
3692
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003693 if (TT.getArch() == llvm::Triple::arm ||
3694 TT.getArch() == llvm::Triple::thumb) {
3695 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3696 options::OPT_mno_long_calls)) {
3697 if (A->getOption().matches(options::OPT_mlong_calls)) {
3698 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003699 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003700 }
3701 }
3702 }
3703
Daniel Dunbard18049a2009-04-07 21:16:11 +00003704 // Forward -f options with positive and negative forms; we translate
3705 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003706 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3707 StringRef fname = A->getValue();
3708 if (!llvm::sys::fs::exists(fname))
3709 D.Diag(diag::err_drv_no_such_file) << fname;
3710 else
3711 A->render(Args, CmdArgs);
3712 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003713
Diego Novillo829b1702014-04-16 16:54:24 +00003714 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3715 A->render(Args, CmdArgs);
3716
Diego Novillod23ec942014-05-29 19:55:06 +00003717 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3718 A->render(Args, CmdArgs);
3719
3720 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3721 A->render(Args, CmdArgs);
3722
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003723 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003724 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003725 CmdArgs.push_back("-fapple-kext");
3726 if (!Args.hasArg(options::OPT_fbuiltin))
3727 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003728 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003729 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003730 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003731 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003732 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003733
Nuno Lopes13c88c72009-12-16 16:59:22 +00003734 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3735 options::OPT_fno_assume_sane_operator_new))
3736 CmdArgs.push_back("-fno-assume-sane-operator-new");
3737
Daniel Dunbar4930e332009-11-17 08:07:36 +00003738 // -fblocks=0 is default.
3739 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003740 getToolChain().IsBlocksDefault()) ||
3741 (Args.hasArg(options::OPT_fgnu_runtime) &&
3742 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3743 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003744 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003745
3746 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3747 !getToolChain().hasBlocksRuntime())
3748 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003749 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003750
Douglas Gregor226173a2012-01-18 15:19:58 +00003751 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3752 // users must also pass -fcxx-modules. The latter flag will disappear once the
3753 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003754 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003755 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3756 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3757 options::OPT_fno_cxx_modules,
3758 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003759 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003760 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003761 HaveModules = true;
3762 }
3763 }
3764
Daniel Jasper07e6c402013-08-05 20:26:17 +00003765 // -fmodule-maps enables module map processing (off by default) for header
3766 // checking. It is implied by -fmodules.
3767 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3768 false)) {
3769 CmdArgs.push_back("-fmodule-maps");
3770 }
3771
Daniel Jasperac42b752013-10-21 06:34:34 +00003772 // -fmodules-decluse checks that modules used are declared so (off by
3773 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003774 if (Args.hasFlag(options::OPT_fmodules_decluse,
3775 options::OPT_fno_modules_decluse,
3776 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003777 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003778 }
3779
Daniel Jasper962b38e2014-04-11 11:47:45 +00003780 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3781 // all #included headers are part of modules.
3782 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3783 options::OPT_fno_modules_strict_decluse,
3784 false)) {
3785 CmdArgs.push_back("-fmodules-strict-decluse");
3786 }
3787
Daniel Jasperac42b752013-10-21 06:34:34 +00003788 // -fmodule-name specifies the module that is currently being built (or
3789 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003790 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003791 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003792
3793 // -fmodule-map-file can be used to specify a file containing module
3794 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003795 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003796 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003797
Justin Bognera88f0122014-06-20 22:59:50 +00003798 // -fmodule-cache-path specifies where our module files should be written.
3799 SmallString<128> ModuleCachePath;
3800 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3801 ModuleCachePath = A->getValue();
3802 if (HaveModules) {
3803 if (C.isForDiagnostics()) {
3804 // When generating crash reports, we want to emit the modules along with
3805 // the reproduction sources, so we ignore any provided module path.
3806 ModuleCachePath = Output.getFilename();
3807 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3808 llvm::sys::path::append(ModuleCachePath, "modules");
3809 } else if (ModuleCachePath.empty()) {
3810 // No module path was provided: use the default.
3811 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3812 ModuleCachePath);
3813 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3814 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3815 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003816 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003817 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3818 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3819 }
3820
3821 // When building modules and generating crashdumps, we need to dump a module
3822 // dependency VFS alongside the output.
3823 if (HaveModules && C.isForDiagnostics()) {
3824 SmallString<128> VFSDir(Output.getFilename());
3825 llvm::sys::path::replace_extension(VFSDir, ".cache");
3826 llvm::sys::path::append(VFSDir, "vfs");
3827 CmdArgs.push_back("-module-dependency-dir");
3828 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003829 }
3830
Justin Bogner5443ad52014-06-20 21:12:53 +00003831 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3832 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003833 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003834
Douglas Gregor35b04d62013-02-07 19:01:24 +00003835 // Pass through all -fmodules-ignore-macro arguments.
3836 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003837 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3838 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003839
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003840 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3841
3842 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3843 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3844 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3845
3846 Args.AddLastArg(CmdArgs,
3847 options::OPT_fmodules_validate_once_per_build_session);
3848 }
3849
Ben Langmuirdcf73862014-03-12 00:06:17 +00003850 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3851
John McCalldfea9982010-04-09 19:12:06 +00003852 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003853 if (Args.hasFlag(options::OPT_fno_access_control,
3854 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003855 false))
John McCall3155f572010-04-09 19:03:51 +00003856 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003857
Anders Carlssond470fef2010-11-21 00:09:52 +00003858 // -felide-constructors is the default.
3859 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3860 options::OPT_felide_constructors,
3861 false))
3862 CmdArgs.push_back("-fno-elide-constructors");
3863
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003864 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003865 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003866 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003867 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003868
Richard Smith52be6192012-11-05 22:04:41 +00003869 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003870 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003871 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003872 Args.getLastArg(options::OPT_mkernel,
3873 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003874 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003875 D.Diag(diag::err_drv_argument_not_allowed_with)
3876 << "-fsanitize=vptr" << NoRttiArg;
3877 }
3878 }
3879
Tony Linthicum76329bf2011-12-12 21:14:55 +00003880 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003881 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003882 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003883 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003884 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003885 CmdArgs.push_back("-fshort-enums");
3886
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003887 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003888 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003889 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003890 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003891
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003892 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003893 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003894 options::OPT_fno_threadsafe_statics))
3895 CmdArgs.push_back("-fno-threadsafe-statics");
3896
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003897 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003898 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3899 options::OPT_fno_use_cxa_atexit,
3900 !IsWindowsCygnus && !IsWindowsGNU &&
3901 getToolChain().getArch() != llvm::Triple::hexagon &&
3902 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003903 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003904 CmdArgs.push_back("-fno-use-cxa-atexit");
3905
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003906 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003907 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003908 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003909 CmdArgs.push_back("-fms-extensions");
3910
Francois Pichet1b4f1632011-09-17 04:32:15 +00003911 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003912 if (Args.hasFlag(options::OPT_fms_compatibility,
3913 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003914 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3915 options::OPT_fno_ms_extensions,
3916 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003917 CmdArgs.push_back("-fms-compatibility");
3918
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003919 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003920 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003921 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3922 Args.hasArg(options::OPT_fms_compatibility_version)) {
3923 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3924 const Arg *MSCompatibilityVersion =
3925 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003926
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003927 if (MSCVersion && MSCompatibilityVersion)
3928 D.Diag(diag::err_drv_argument_not_allowed_with)
3929 << MSCVersion->getAsString(Args)
3930 << MSCompatibilityVersion->getAsString(Args);
3931
3932 std::string Ver;
3933 if (MSCompatibilityVersion)
3934 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
3935 else if (MSCVersion)
3936 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
3937
3938 if (Ver.empty())
3939 CmdArgs.push_back("-fms-compatibility-version=17.00");
3940 else
3941 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
3942 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003943
Eric Christopher5ecce122013-02-18 00:38:31 +00003944 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003945 if (Args.hasFlag(options::OPT_fborland_extensions,
3946 options::OPT_fno_borland_extensions, false))
3947 CmdArgs.push_back("-fborland-extensions");
3948
Francois Pichet02744872011-09-01 16:38:08 +00003949 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3950 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003951 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003952 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003953 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003954
Chandler Carruthe03aa552010-04-17 20:17:31 +00003955 // -fgnu-keywords default varies depending on language; only pass if
3956 // specified.
3957 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003958 options::OPT_fno_gnu_keywords))
3959 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003960
Rafael Espindola922a6242011-06-02 17:30:53 +00003961 if (Args.hasFlag(options::OPT_fgnu89_inline,
3962 options::OPT_fno_gnu89_inline,
3963 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003964 CmdArgs.push_back("-fgnu89-inline");
3965
Chad Rosier9c76d242012-03-15 22:31:42 +00003966 if (Args.hasArg(options::OPT_fno_inline))
3967 CmdArgs.push_back("-fno-inline");
3968
Chad Rosier64d6be92012-03-06 21:17:19 +00003969 if (Args.hasArg(options::OPT_fno_inline_functions))
3970 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003971
John McCall5fb5df92012-06-20 06:18:46 +00003972 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003973
John McCall5fb5df92012-06-20 06:18:46 +00003974 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003975 // legacy is the default. Except for deployment taget of 10.5,
3976 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3977 // gets ignored silently.
3978 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003979 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3980 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003981 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003982 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003983 if (getToolChain().UseObjCMixedDispatch())
3984 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3985 else
3986 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3987 }
3988 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003989
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003990 // When ObjectiveC legacy runtime is in effect on MacOSX,
3991 // turn on the option to do Array/Dictionary subscripting
3992 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003993 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3994 getToolChain().getTriple().isMacOSX() &&
3995 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3996 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003997 objcRuntime.isNeXTFamily())
3998 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3999
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004000 // -fencode-extended-block-signature=1 is default.
4001 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4002 CmdArgs.push_back("-fencode-extended-block-signature");
4003 }
4004
John McCall24fc0de2011-07-06 00:26:06 +00004005 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4006 // NOTE: This logic is duplicated in ToolChains.cpp.
4007 bool ARC = isObjCAutoRefCount(Args);
4008 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004009 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004010
John McCall24fc0de2011-07-06 00:26:06 +00004011 CmdArgs.push_back("-fobjc-arc");
4012
Chandler Carruth491db322011-11-04 07:34:47 +00004013 // FIXME: It seems like this entire block, and several around it should be
4014 // wrapped in isObjC, but for now we just use it here as this is where it
4015 // was being used previously.
4016 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4017 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4018 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4019 else
4020 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4021 }
4022
John McCall24fc0de2011-07-06 00:26:06 +00004023 // Allow the user to enable full exceptions code emission.
4024 // We define off for Objective-CC, on for Objective-C++.
4025 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4026 options::OPT_fno_objc_arc_exceptions,
4027 /*default*/ types::isCXX(InputType)))
4028 CmdArgs.push_back("-fobjc-arc-exceptions");
4029 }
4030
4031 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4032 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004033 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004034 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004035
John McCall24fc0de2011-07-06 00:26:06 +00004036 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4037 // takes precedence.
4038 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4039 if (!GCArg)
4040 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4041 if (GCArg) {
4042 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004043 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004044 << GCArg->getAsString(Args);
4045 } else if (getToolChain().SupportsObjCGC()) {
4046 GCArg->render(Args, CmdArgs);
4047 } else {
4048 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004049 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004050 << GCArg->getAsString(Args);
4051 }
4052 }
4053
Reid Klecknerc542d372014-06-27 17:02:02 +00004054 // Handle GCC-style exception args.
4055 if (!C.getDriver().IsCLMode())
4056 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
4057 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004058
4059 if (getToolChain().UseSjLjExceptions())
4060 CmdArgs.push_back("-fsjlj-exceptions");
4061
4062 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004063 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4064 options::OPT_fno_assume_sane_operator_new))
4065 CmdArgs.push_back("-fno-assume-sane-operator-new");
4066
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004067 // -fconstant-cfstrings is default, and may be subject to argument translation
4068 // on Darwin.
4069 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4070 options::OPT_fno_constant_cfstrings) ||
4071 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4072 options::OPT_mno_constant_cfstrings))
4073 CmdArgs.push_back("-fno-constant-cfstrings");
4074
John Thompsoned4e2952009-11-05 20:14:16 +00004075 // -fshort-wchar default varies depending on platform; only
4076 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004077 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4078 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004079 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004080
Hans Wennborg28c96312013-07-31 23:39:13 +00004081 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004082 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004083 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004084 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004085 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004086
Daniel Dunbar096ed292011-10-05 21:04:55 +00004087 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4088 // -fno-pack-struct doesn't apply to -fpack-struct=.
4089 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004090 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004091 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004092 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004093 } else if (Args.hasFlag(options::OPT_fpack_struct,
4094 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004095 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004096 }
4097
Robert Lytton0e076492013-08-13 09:43:10 +00004098 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004099 if (!Args.hasArg(options::OPT_fcommon))
4100 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004101 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004102 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004103
Daniel Dunbard18049a2009-04-07 21:16:11 +00004104 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004105 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004106 CmdArgs.push_back("-fno-common");
4107
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004108 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004109 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004110 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004111 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004112 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004113 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4114
Daniel Dunbar6358d682010-10-15 22:30:42 +00004115 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4116 if (!Args.hasFlag(options::OPT_ffor_scope,
4117 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004118 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004119 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4120
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004121 // -finput_charset=UTF-8 is default. Reject others
4122 if (Arg *inputCharset = Args.getLastArg(
4123 options::OPT_finput_charset_EQ)) {
4124 StringRef value = inputCharset->getValue();
4125 if (value != "UTF-8")
4126 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4127 }
4128
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004129 // -fcaret-diagnostics is default.
4130 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4131 options::OPT_fno_caret_diagnostics, true))
4132 CmdArgs.push_back("-fno-caret-diagnostics");
4133
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004134 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004135 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004136 options::OPT_fno_diagnostics_fixit_info))
4137 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004138
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004139 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004140 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004141 options::OPT_fno_diagnostics_show_option))
4142 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004143
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004144 if (const Arg *A =
4145 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4146 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004147 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004148 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004149
Douglas Gregor643c9222011-05-21 17:07:29 +00004150 if (const Arg *A =
4151 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4152 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004153 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004154 }
4155
Chandler Carruthb6766f02011-03-27 01:50:55 +00004156 if (Arg *A = Args.getLastArg(
4157 options::OPT_fdiagnostics_show_note_include_stack,
4158 options::OPT_fno_diagnostics_show_note_include_stack)) {
4159 if (A->getOption().matches(
4160 options::OPT_fdiagnostics_show_note_include_stack))
4161 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4162 else
4163 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4164 }
4165
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004166 // Color diagnostics are the default, unless the terminal doesn't support
4167 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004168 // Support both clang's -f[no-]color-diagnostics and gcc's
4169 // -f[no-]diagnostics-colors[=never|always|auto].
4170 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004171 for (const auto &Arg : Args) {
4172 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004173 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4174 !O.matches(options::OPT_fdiagnostics_color) &&
4175 !O.matches(options::OPT_fno_color_diagnostics) &&
4176 !O.matches(options::OPT_fno_diagnostics_color) &&
4177 !O.matches(options::OPT_fdiagnostics_color_EQ))
4178 continue;
4179
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004180 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004181 if (O.matches(options::OPT_fcolor_diagnostics) ||
4182 O.matches(options::OPT_fdiagnostics_color)) {
4183 ShowColors = Colors_On;
4184 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4185 O.matches(options::OPT_fno_diagnostics_color)) {
4186 ShowColors = Colors_Off;
4187 } else {
4188 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004189 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004190 if (value == "always")
4191 ShowColors = Colors_On;
4192 else if (value == "never")
4193 ShowColors = Colors_Off;
4194 else if (value == "auto")
4195 ShowColors = Colors_Auto;
4196 else
4197 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4198 << ("-fdiagnostics-color=" + value).str();
4199 }
4200 }
4201 if (ShowColors == Colors_On ||
4202 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004203 CmdArgs.push_back("-fcolor-diagnostics");
4204
Nico Rieck7857d462013-09-11 00:38:02 +00004205 if (Args.hasArg(options::OPT_fansi_escape_codes))
4206 CmdArgs.push_back("-fansi-escape-codes");
4207
Daniel Dunbardb097022009-06-08 21:13:54 +00004208 if (!Args.hasFlag(options::OPT_fshow_source_location,
4209 options::OPT_fno_show_source_location))
4210 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004211
Douglas Gregor643c9222011-05-21 17:07:29 +00004212 if (!Args.hasFlag(options::OPT_fshow_column,
4213 options::OPT_fno_show_column,
4214 true))
4215 CmdArgs.push_back("-fno-show-column");
4216
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004217 if (!Args.hasFlag(options::OPT_fspell_checking,
4218 options::OPT_fno_spell_checking))
4219 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004220
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004221
Chad Rosierc8e56e82012-12-05 21:08:21 +00004222 // -fno-asm-blocks is default.
4223 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4224 false))
4225 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004226
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004227 // Enable vectorization per default according to the optimization level
4228 // selected. For optimization levels that want vectorization we use the alias
4229 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004230 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004231 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004232 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004233 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004234 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004235 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004236
Chad Rosier136d67d2014-04-28 19:30:57 +00004237 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004238 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4239 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004240 options::OPT_fslp_vectorize;
4241 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004242 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004243 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004244
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004245 // -fno-slp-vectorize-aggressive is default.
4246 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004247 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004248 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004249
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004250 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4251 A->render(Args, CmdArgs);
4252
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004253 // -fdollars-in-identifiers default varies depending on platform and
4254 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004255 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004256 options::OPT_fno_dollars_in_identifiers)) {
4257 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004258 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004259 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004260 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004261 }
4262
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004263 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4264 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004265 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004266 options::OPT_fno_unit_at_a_time)) {
4267 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004268 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004269 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004270
Eli Friedman055c9702011-11-02 01:53:16 +00004271 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4272 options::OPT_fno_apple_pragma_pack, false))
4273 CmdArgs.push_back("-fapple-pragma-pack");
4274
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004275 // le32-specific flags:
4276 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4277 // by default.
4278 if (getToolChain().getArch() == llvm::Triple::le32) {
4279 CmdArgs.push_back("-fno-math-builtin");
4280 }
4281
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004282 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004283 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004284 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004285#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004286 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004287 (getToolChain().getArch() == llvm::Triple::arm ||
4288 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004289 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4290 CmdArgs.push_back("-fno-builtin-strcat");
4291 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4292 CmdArgs.push_back("-fno-builtin-strcpy");
4293 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004294#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004295
Justin Bognera88f0122014-06-20 22:59:50 +00004296 // Enable rewrite includes if the user's asked for it or if we're generating
4297 // diagnostics.
4298 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4299 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004300 if (Args.hasFlag(options::OPT_frewrite_includes,
4301 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004302 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004303 CmdArgs.push_back("-frewrite-includes");
4304
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004305 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004306 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004307 options::OPT_traditional_cpp)) {
4308 if (isa<PreprocessJobAction>(JA))
4309 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004310 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004311 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004312 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004313
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004314 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004315 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004316
4317 // Handle serialized diagnostics.
4318 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4319 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004320 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004321 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004322
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004323 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4324 CmdArgs.push_back("-fretain-comments-from-system-headers");
4325
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004326 // Forward -fcomment-block-commands to -cc1.
4327 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004328 // Forward -fparse-all-comments to -cc1.
4329 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004330
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004331 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4332 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004333 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004334 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4335 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004336 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004337
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004338 // We translate this by hand to the -cc1 argument, since nightly test uses
4339 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004340 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004341 CmdArgs.push_back("-disable-llvm-optzns");
4342 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004343 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004344 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004345
Daniel Dunbard67a3222009-03-30 06:36:42 +00004346 if (Output.getType() == types::TY_Dependencies) {
4347 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004348 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004349 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004350 CmdArgs.push_back(Output.getFilename());
4351 } else {
4352 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004353 }
4354
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004355 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004356 addDashXForInput(Args, II, CmdArgs);
4357
Daniel Dunbarb440f562010-08-02 02:38:21 +00004358 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004359 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004360 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004361 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004362 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004363
Chris Lattnere9d7d782009-11-03 19:50:27 +00004364 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4365
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004366 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004367
4368 // Optionally embed the -cc1 level arguments into the debug info, for build
4369 // analysis.
4370 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004371 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004372 for (const auto &Arg : Args)
4373 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004374
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004375 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004376 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004377 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004378 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004379 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004380 }
4381 CmdArgs.push_back("-dwarf-debug-flags");
4382 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4383 }
4384
Eric Christopherd3804002013-02-22 20:12:52 +00004385 // Add the split debug info name to the command lines here so we
4386 // can propagate it to the backend.
4387 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004388 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004389 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004390 const char *SplitDwarfOut;
4391 if (SplitDwarf) {
4392 CmdArgs.push_back("-split-dwarf-file");
4393 SplitDwarfOut = SplitDebugName(Args, Inputs);
4394 CmdArgs.push_back(SplitDwarfOut);
4395 }
4396
4397 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004398 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004399 Output.getType() == types::TY_Object &&
4400 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg1da044a2014-06-26 19:59:02 +00004401 Command *CLCommand = getCLFallback()->GetCommand(C, JA, Output, Inputs,
4402 Args, LinkingOutput);
David Majnemerf6072342014-07-01 22:24:56 +00004403 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004404 } else {
4405 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4406 }
4407
Daniel Dunbar17731772009-03-23 19:03:36 +00004408
Eric Christopherf1545832013-02-22 23:50:16 +00004409 // Handle the debug info splitting at object creation time if we're
4410 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004411 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004412 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004413 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004414
Roman Divacky178e01602011-02-10 16:52:03 +00004415 if (Arg *A = Args.getLastArg(options::OPT_pg))
4416 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004417 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004418 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004419
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004420 // Claim some arguments which clang supports automatically.
4421
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004422 // -fpch-preprocess is used with gcc to add a special marker in the output to
4423 // include the PCH file. Clang's PTH solution is completely transparent, so we
4424 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004425 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004426
Daniel Dunbar17731772009-03-23 19:03:36 +00004427 // Claim some arguments which clang doesn't support, but we don't
4428 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004429 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4430 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004431
Rafael Espindolab0092d72013-09-04 19:37:35 +00004432 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004433 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004434}
4435
John McCall5fb5df92012-06-20 06:18:46 +00004436/// Add options related to the Objective-C runtime/ABI.
4437///
4438/// Returns true if the runtime is non-fragile.
4439ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4440 ArgStringList &cmdArgs,
4441 RewriteKind rewriteKind) const {
4442 // Look for the controlling runtime option.
4443 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4444 options::OPT_fgnu_runtime,
4445 options::OPT_fobjc_runtime_EQ);
4446
4447 // Just forward -fobjc-runtime= to the frontend. This supercedes
4448 // options about fragility.
4449 if (runtimeArg &&
4450 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4451 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004452 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004453 if (runtime.tryParse(value)) {
4454 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4455 << value;
4456 }
4457
4458 runtimeArg->render(args, cmdArgs);
4459 return runtime;
4460 }
4461
4462 // Otherwise, we'll need the ABI "version". Version numbers are
4463 // slightly confusing for historical reasons:
4464 // 1 - Traditional "fragile" ABI
4465 // 2 - Non-fragile ABI, version 1
4466 // 3 - Non-fragile ABI, version 2
4467 unsigned objcABIVersion = 1;
4468 // If -fobjc-abi-version= is present, use that to set the version.
4469 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004470 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004471 if (value == "1")
4472 objcABIVersion = 1;
4473 else if (value == "2")
4474 objcABIVersion = 2;
4475 else if (value == "3")
4476 objcABIVersion = 3;
4477 else
4478 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4479 << value;
4480 } else {
4481 // Otherwise, determine if we are using the non-fragile ABI.
4482 bool nonFragileABIIsDefault =
4483 (rewriteKind == RK_NonFragile ||
4484 (rewriteKind == RK_None &&
4485 getToolChain().IsObjCNonFragileABIDefault()));
4486 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4487 options::OPT_fno_objc_nonfragile_abi,
4488 nonFragileABIIsDefault)) {
4489 // Determine the non-fragile ABI version to use.
4490#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4491 unsigned nonFragileABIVersion = 1;
4492#else
4493 unsigned nonFragileABIVersion = 2;
4494#endif
4495
4496 if (Arg *abiArg = args.getLastArg(
4497 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004498 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004499 if (value == "1")
4500 nonFragileABIVersion = 1;
4501 else if (value == "2")
4502 nonFragileABIVersion = 2;
4503 else
4504 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4505 << value;
4506 }
4507
4508 objcABIVersion = 1 + nonFragileABIVersion;
4509 } else {
4510 objcABIVersion = 1;
4511 }
4512 }
4513
4514 // We don't actually care about the ABI version other than whether
4515 // it's non-fragile.
4516 bool isNonFragile = objcABIVersion != 1;
4517
4518 // If we have no runtime argument, ask the toolchain for its default runtime.
4519 // However, the rewriter only really supports the Mac runtime, so assume that.
4520 ObjCRuntime runtime;
4521 if (!runtimeArg) {
4522 switch (rewriteKind) {
4523 case RK_None:
4524 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4525 break;
4526 case RK_Fragile:
4527 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4528 break;
4529 case RK_NonFragile:
4530 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4531 break;
4532 }
4533
4534 // -fnext-runtime
4535 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4536 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004537 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004538 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4539
4540 // Otherwise, build for a generic macosx port.
4541 } else {
4542 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4543 }
4544
4545 // -fgnu-runtime
4546 } else {
4547 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004548 // Legacy behaviour is to target the gnustep runtime if we are i
4549 // non-fragile mode or the GCC runtime in fragile mode.
4550 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004551 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004552 else
4553 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004554 }
4555
4556 cmdArgs.push_back(args.MakeArgString(
4557 "-fobjc-runtime=" + runtime.getAsString()));
4558 return runtime;
4559}
4560
Reid Klecknerc542d372014-06-27 17:02:02 +00004561static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4562 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4563 I += HaveDash;
4564 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004565}
Reid Klecknerc542d372014-06-27 17:02:02 +00004566
4567struct EHFlags {
4568 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4569 bool Synch;
4570 bool Asynch;
4571 bool NoExceptC;
4572};
4573
4574/// /EH controls whether to run destructor cleanups when exceptions are
4575/// thrown. There are three modifiers:
4576/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4577/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4578/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4579/// - c: Assume that extern "C" functions are implicitly noexcept. This
4580/// modifier is an optimization, so we ignore it for now.
4581/// The default is /EHs-c-, meaning cleanups are disabled.
4582static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4583 EHFlags EH;
4584 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4585 for (auto EHVal : EHArgs) {
4586 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4587 switch (EHVal[I]) {
4588 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4589 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4590 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4591 default: break;
4592 }
4593 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4594 break;
4595 }
4596 }
4597 return EH;
4598}
4599
Hans Wennborg75958c42013-08-08 00:17:41 +00004600void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4601 unsigned RTOptionID = options::OPT__SLASH_MT;
4602
Hans Wennborgf1a74252013-09-10 20:18:04 +00004603 if (Args.hasArg(options::OPT__SLASH_LDd))
4604 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4605 // but defining _DEBUG is sticky.
4606 RTOptionID = options::OPT__SLASH_MTd;
4607
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004608 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004609 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004610
Hans Wennborg75958c42013-08-08 00:17:41 +00004611 switch(RTOptionID) {
4612 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004613 if (Args.hasArg(options::OPT__SLASH_LDd))
4614 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004615 CmdArgs.push_back("-D_MT");
4616 CmdArgs.push_back("-D_DLL");
4617 CmdArgs.push_back("--dependent-lib=msvcrt");
4618 break;
4619 case options::OPT__SLASH_MDd:
4620 CmdArgs.push_back("-D_DEBUG");
4621 CmdArgs.push_back("-D_MT");
4622 CmdArgs.push_back("-D_DLL");
4623 CmdArgs.push_back("--dependent-lib=msvcrtd");
4624 break;
4625 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004626 if (Args.hasArg(options::OPT__SLASH_LDd))
4627 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004628 CmdArgs.push_back("-D_MT");
4629 CmdArgs.push_back("--dependent-lib=libcmt");
4630 break;
4631 case options::OPT__SLASH_MTd:
4632 CmdArgs.push_back("-D_DEBUG");
4633 CmdArgs.push_back("-D_MT");
4634 CmdArgs.push_back("--dependent-lib=libcmtd");
4635 break;
4636 default:
4637 llvm_unreachable("Unexpected option ID.");
4638 }
4639
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004640 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4641 // users want. The /Za flag to cl.exe turns this off, but it's not
4642 // implemented in clang.
4643 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004644
Hans Wennborg8858a032014-07-21 23:42:07 +00004645 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4646 // would produce interleaved output, so ignore /showIncludes in such cases.
4647 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4648 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4649 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004650
David Majnemerf6072342014-07-01 22:24:56 +00004651 // This controls whether or not we emit RTTI data for polymorphic types.
4652 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4653 /*default=*/false))
4654 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004655
Reid Klecknerc542d372014-06-27 17:02:02 +00004656 const Driver &D = getToolChain().getDriver();
4657 EHFlags EH = parseClangCLEHFlags(D, Args);
4658 // FIXME: Do something with NoExceptC.
4659 if (EH.Synch || EH.Asynch) {
4660 CmdArgs.push_back("-fexceptions");
4661 CmdArgs.push_back("-fcxx-exceptions");
4662 }
4663
Hans Wennborge50cec32014-06-13 20:59:54 +00004664 // /EP should expand to -E -P.
4665 if (Args.hasArg(options::OPT__SLASH_EP)) {
4666 CmdArgs.push_back("-E");
4667 CmdArgs.push_back("-P");
4668 }
4669
David Majnemer86c318f2014-02-11 21:05:00 +00004670 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4671 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4672 if (MostGeneralArg && BestCaseArg)
4673 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4674 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4675
4676 if (MostGeneralArg) {
4677 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4678 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4679 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4680
4681 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4682 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4683 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4684 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4685 << FirstConflict->getAsString(Args)
4686 << SecondConflict->getAsString(Args);
4687
4688 if (SingleArg)
4689 CmdArgs.push_back("-fms-memptr-rep=single");
4690 else if (MultipleArg)
4691 CmdArgs.push_back("-fms-memptr-rep=multiple");
4692 else
4693 CmdArgs.push_back("-fms-memptr-rep=virtual");
4694 }
4695
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004696 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4697 A->render(Args, CmdArgs);
4698
Hans Wennborg81f74482013-09-10 01:07:07 +00004699 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4700 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004701 if (Args.hasArg(options::OPT__SLASH_fallback))
4702 CmdArgs.push_back("msvc-fallback");
4703 else
4704 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004705 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004706}
4707
Hans Wennborg1da044a2014-06-26 19:59:02 +00004708visualstudio::Compile *Clang::getCLFallback() const {
4709 if (!CLFallback)
4710 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4711 return CLFallback.get();
4712}
4713
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004714void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004715 const InputInfo &Output,
4716 const InputInfoList &Inputs,
4717 const ArgList &Args,
4718 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004719 ArgStringList CmdArgs;
4720
4721 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4722 const InputInfo &Input = Inputs[0];
4723
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004724 // Don't warn about "clang -w -c foo.s"
4725 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004726 // and "clang -emit-llvm -c foo.s"
4727 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004728
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004729 // Invoke ourselves in -cc1as mode.
4730 //
4731 // FIXME: Implement custom jobs for internal actions.
4732 CmdArgs.push_back("-cc1as");
4733
4734 // Add the "effective" target triple.
4735 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004736 std::string TripleStr =
4737 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004738 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4739
4740 // Set the output mode, we currently only expect to be used as a real
4741 // assembler.
4742 CmdArgs.push_back("-filetype");
4743 CmdArgs.push_back("obj");
4744
Eric Christopher45f2e712012-12-18 00:31:10 +00004745 // Set the main file name, so that debug info works even with
4746 // -save-temps or preprocessed assembly.
4747 CmdArgs.push_back("-main-file-name");
4748 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4749
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004750 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004751 const llvm::Triple &Triple = getToolChain().getTriple();
4752 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004753 if (!CPU.empty()) {
4754 CmdArgs.push_back("-target-cpu");
4755 CmdArgs.push_back(Args.MakeArgString(CPU));
4756 }
4757
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004758 // Add the target features
4759 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004760 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004761
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004762 // Ignore explicit -force_cpusubtype_ALL option.
4763 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004764
Eric Christopherfc3ee562012-01-10 00:38:01 +00004765 // Determine the original source input.
4766 const Action *SourceAction = &JA;
4767 while (SourceAction->getKind() != Action::InputClass) {
4768 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4769 SourceAction = SourceAction->getInputs()[0];
4770 }
4771
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004772 // Forward -g and handle debug info related flags, assuming we are dealing
4773 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004774 if (SourceAction->getType() == types::TY_Asm ||
4775 SourceAction->getType() == types::TY_PP_Asm) {
4776 Args.ClaimAllArgs(options::OPT_g_Group);
4777 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4778 if (!A->getOption().matches(options::OPT_g0))
4779 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004780
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004781 if (Args.hasArg(options::OPT_gdwarf_2))
4782 CmdArgs.push_back("-gdwarf-2");
4783 if (Args.hasArg(options::OPT_gdwarf_3))
4784 CmdArgs.push_back("-gdwarf-3");
4785 if (Args.hasArg(options::OPT_gdwarf_4))
4786 CmdArgs.push_back("-gdwarf-4");
4787
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004788 // Add the -fdebug-compilation-dir flag if needed.
4789 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004790
4791 // Set the AT_producer to the clang version when using the integrated
4792 // assembler on assembly source files.
4793 CmdArgs.push_back("-dwarf-debug-producer");
4794 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004795 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004796
4797 // Optionally embed the -cc1as level arguments into the debug info, for build
4798 // analysis.
4799 if (getToolChain().UseDwarfDebugFlags()) {
4800 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004801 for (const auto &Arg : Args)
4802 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004803
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004804 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004805 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4806 Flags += Exec;
4807 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4808 Flags += " ";
4809 Flags += OriginalArgs[i];
4810 }
4811 CmdArgs.push_back("-dwarf-debug-flags");
4812 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4813 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004814
4815 // FIXME: Add -static support, once we have it.
4816
David Blaikie372d9502014-01-17 03:17:40 +00004817 // Consume all the warning flags. Usually this would be handled more
4818 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4819 // doesn't handle that so rather than warning about unused flags that are
4820 // actually used, we'll lie by omission instead.
4821 // FIXME: Stop lying and consume only the appropriate driver flags
4822 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4823 ie = Args.filtered_end();
4824 it != ie; ++it)
4825 (*it)->claim();
4826
David Blaikie9260ed62013-07-25 21:19:01 +00004827 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4828 getToolChain().getDriver());
4829
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004830 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004831
4832 assert(Output.isFilename() && "Unexpected lipo output.");
4833 CmdArgs.push_back("-o");
4834 CmdArgs.push_back(Output.getFilename());
4835
Daniel Dunbarb440f562010-08-02 02:38:21 +00004836 assert(Input.isFilename() && "Invalid input.");
4837 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004838
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004839 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004840 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004841
4842 // Handle the debug info splitting at object creation time if we're
4843 // creating an object.
4844 // TODO: Currently only works on linux with newer objcopy.
4845 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004846 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004847 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4848 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004849}
4850
Daniel Dunbara3246a02009-03-18 08:07:30 +00004851void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004852 const InputInfo &Output,
4853 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004854 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004855 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004856 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004857 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004858
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004859 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004860 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004861 // Don't forward any -g arguments to assembly steps.
4862 if (isa<AssembleJobAction>(JA) &&
4863 A->getOption().matches(options::OPT_g_Group))
4864 continue;
4865
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004866 // Don't forward any -W arguments to assembly and link steps.
4867 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4868 A->getOption().matches(options::OPT_W_Group))
4869 continue;
4870
Daniel Dunbar2da02722009-03-19 07:55:12 +00004871 // It is unfortunate that we have to claim here, as this means
4872 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004873 // platforms using a generic gcc, even if we are just using gcc
4874 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004875 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004876 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004877 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004878 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004879
Daniel Dunbar4e295052010-01-25 22:35:08 +00004880 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004881
4882 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004883 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004884 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004885 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004886
4887 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004888 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004889 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004890 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004891 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004892 else if (Arch == llvm::Triple::ppc64le)
4893 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004894 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004895 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004896 }
4897
Daniel Dunbar5716d872009-05-02 21:41:52 +00004898 // Try to force gcc to match the tool chain we want, if we recognize
4899 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004900 //
4901 // FIXME: The triple class should directly provide the information we want
4902 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004903 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004904 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004905 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4906 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004907 CmdArgs.push_back("-m64");
4908
Daniel Dunbarb440f562010-08-02 02:38:21 +00004909 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004910 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004911 CmdArgs.push_back(Output.getFilename());
4912 } else {
4913 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004914 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004915 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004916
Tony Linthicum76329bf2011-12-12 21:14:55 +00004917 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4918 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004919
4920 // Only pass -x if gcc will understand it; otherwise hope gcc
4921 // understands the suffix correctly. The main use case this would go
4922 // wrong in is for linker inputs if they happened to have an odd
4923 // suffix; really the only way to get this to happen is a command
4924 // like '-x foobar a.c' which will treat a.c like a linker input.
4925 //
4926 // FIXME: For the linker case specifically, can we safely convert
4927 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004928 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004929 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004930 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4931 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004932 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004933 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004934 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004935 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004936 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004937 else if (II.getType() == types::TY_ModuleFile)
4938 D.Diag(diag::err_drv_no_module_support)
4939 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004940
Daniel Dunbara3246a02009-03-18 08:07:30 +00004941 if (types::canTypeBeUserSpecified(II.getType())) {
4942 CmdArgs.push_back("-x");
4943 CmdArgs.push_back(types::getTypeName(II.getType()));
4944 }
4945
Daniel Dunbarb440f562010-08-02 02:38:21 +00004946 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004947 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004948 else {
4949 const Arg &A = II.getInputArg();
4950
4951 // Reverse translate some rewritten options.
4952 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4953 CmdArgs.push_back("-lstdc++");
4954 continue;
4955 }
4956
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004957 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004958 A.render(Args, CmdArgs);
4959 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004960 }
4961
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004962 const std::string customGCCName = D.getCCCGenericGCCName();
4963 const char *GCCName;
4964 if (!customGCCName.empty())
4965 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004966 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004967 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004968 } else
4969 GCCName = "gcc";
4970
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004971 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004972 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004973 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004974}
4975
Daniel Dunbar4e295052010-01-25 22:35:08 +00004976void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4977 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004978 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004979}
4980
Daniel Dunbar4e295052010-01-25 22:35:08 +00004981void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4982 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004983 const Driver &D = getToolChain().getDriver();
4984
Daniel Dunbar4e295052010-01-25 22:35:08 +00004985 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004986 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4987 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004988 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004989 else {
4990 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004991 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004992 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004993
Daniel Dunbar4e295052010-01-25 22:35:08 +00004994 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004995 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004996}
4997
Daniel Dunbar4e295052010-01-25 22:35:08 +00004998void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4999 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005000 // The types are (hopefully) good enough.
5001}
5002
Tony Linthicum76329bf2011-12-12 21:14:55 +00005003// Hexagon tools start.
5004void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5005 ArgStringList &CmdArgs) const {
5006
5007}
5008void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5009 const InputInfo &Output,
5010 const InputInfoList &Inputs,
5011 const ArgList &Args,
5012 const char *LinkingOutput) const {
5013
5014 const Driver &D = getToolChain().getDriver();
5015 ArgStringList CmdArgs;
5016
5017 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005018 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005019 CmdArgs.push_back(Args.MakeArgString(MarchString));
5020
5021 RenderExtraToolArgs(JA, CmdArgs);
5022
5023 if (Output.isFilename()) {
5024 CmdArgs.push_back("-o");
5025 CmdArgs.push_back(Output.getFilename());
5026 } else {
5027 assert(Output.isNothing() && "Unexpected output");
5028 CmdArgs.push_back("-fsyntax-only");
5029 }
5030
Matthew Curtise8f80a12012-12-06 17:49:03 +00005031 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5032 if (!SmallDataThreshold.empty())
5033 CmdArgs.push_back(
5034 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005035
Matthew Curtise5df3812012-12-07 17:23:04 +00005036 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5037 options::OPT_Xassembler);
5038
Tony Linthicum76329bf2011-12-12 21:14:55 +00005039 // Only pass -x if gcc will understand it; otherwise hope gcc
5040 // understands the suffix correctly. The main use case this would go
5041 // wrong in is for linker inputs if they happened to have an odd
5042 // suffix; really the only way to get this to happen is a command
5043 // like '-x foobar a.c' which will treat a.c like a linker input.
5044 //
5045 // FIXME: For the linker case specifically, can we safely convert
5046 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005047 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005048 // Don't try to pass LLVM or AST inputs to a generic gcc.
5049 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5050 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5051 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5052 << getToolChain().getTripleString();
5053 else if (II.getType() == types::TY_AST)
5054 D.Diag(clang::diag::err_drv_no_ast_support)
5055 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005056 else if (II.getType() == types::TY_ModuleFile)
5057 D.Diag(diag::err_drv_no_module_support)
5058 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005059
5060 if (II.isFilename())
5061 CmdArgs.push_back(II.getFilename());
5062 else
5063 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5064 II.getInputArg().render(Args, CmdArgs);
5065 }
5066
5067 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005068 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005069 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005070}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005071
Tony Linthicum76329bf2011-12-12 21:14:55 +00005072void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5073 ArgStringList &CmdArgs) const {
5074 // The types are (hopefully) good enough.
5075}
5076
5077void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5078 const InputInfo &Output,
5079 const InputInfoList &Inputs,
5080 const ArgList &Args,
5081 const char *LinkingOutput) const {
5082
Matthew Curtise689b052012-12-06 15:46:07 +00005083 const toolchains::Hexagon_TC& ToolChain =
5084 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5085 const Driver &D = ToolChain.getDriver();
5086
Tony Linthicum76329bf2011-12-12 21:14:55 +00005087 ArgStringList CmdArgs;
5088
Matthew Curtise689b052012-12-06 15:46:07 +00005089 //----------------------------------------------------------------------------
5090 //
5091 //----------------------------------------------------------------------------
5092 bool hasStaticArg = Args.hasArg(options::OPT_static);
5093 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005094 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005095 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5096 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5097 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5098 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005099
Matthew Curtise689b052012-12-06 15:46:07 +00005100 //----------------------------------------------------------------------------
5101 // Silence warnings for various options
5102 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005103
Matthew Curtise689b052012-12-06 15:46:07 +00005104 Args.ClaimAllArgs(options::OPT_g_Group);
5105 Args.ClaimAllArgs(options::OPT_emit_llvm);
5106 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5107 // handled somewhere else.
5108 Args.ClaimAllArgs(options::OPT_static_libgcc);
5109
5110 //----------------------------------------------------------------------------
5111 //
5112 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005113 for (const auto &Opt : ToolChain.ExtraOpts)
5114 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005115
Matthew Curtisf10a5952012-12-06 14:16:43 +00005116 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5117 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005118
Matthew Curtise689b052012-12-06 15:46:07 +00005119 if (buildingLib) {
5120 CmdArgs.push_back("-shared");
5121 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5122 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005123 }
5124
Matthew Curtise689b052012-12-06 15:46:07 +00005125 if (hasStaticArg)
5126 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005127
Matthew Curtise8f80a12012-12-06 17:49:03 +00005128 if (buildPIE && !buildingLib)
5129 CmdArgs.push_back("-pie");
5130
5131 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5132 if (!SmallDataThreshold.empty()) {
5133 CmdArgs.push_back(
5134 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5135 }
5136
Matthew Curtise689b052012-12-06 15:46:07 +00005137 //----------------------------------------------------------------------------
5138 //
5139 //----------------------------------------------------------------------------
5140 CmdArgs.push_back("-o");
5141 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005142
Matthew Curtise689b052012-12-06 15:46:07 +00005143 const std::string MarchSuffix = "/" + MarchString;
5144 const std::string G0Suffix = "/G0";
5145 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
5146 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
5147 + "/";
5148 const std::string StartFilesDir = RootDir
5149 + "hexagon/lib"
5150 + (buildingLib
5151 ? MarchG0Suffix : MarchSuffix);
5152
5153 //----------------------------------------------------------------------------
5154 // moslib
5155 //----------------------------------------------------------------------------
5156 std::vector<std::string> oslibs;
5157 bool hasStandalone= false;
5158
5159 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5160 ie = Args.filtered_end(); it != ie; ++it) {
5161 (*it)->claim();
5162 oslibs.push_back((*it)->getValue());
5163 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005164 }
Matthew Curtise689b052012-12-06 15:46:07 +00005165 if (oslibs.empty()) {
5166 oslibs.push_back("standalone");
5167 hasStandalone = true;
5168 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005169
Matthew Curtise689b052012-12-06 15:46:07 +00005170 //----------------------------------------------------------------------------
5171 // Start Files
5172 //----------------------------------------------------------------------------
5173 if (incStdLib && incStartFiles) {
5174
5175 if (!buildingLib) {
5176 if (hasStandalone) {
5177 CmdArgs.push_back(
5178 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5179 }
5180 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5181 }
5182 std::string initObj = useShared ? "/initS.o" : "/init.o";
5183 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5184 }
5185
5186 //----------------------------------------------------------------------------
5187 // Library Search Paths
5188 //----------------------------------------------------------------------------
5189 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005190 for (const auto &LibPath : LibPaths)
5191 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005192
5193 //----------------------------------------------------------------------------
5194 //
5195 //----------------------------------------------------------------------------
5196 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5197 Args.AddAllArgs(CmdArgs, options::OPT_e);
5198 Args.AddAllArgs(CmdArgs, options::OPT_s);
5199 Args.AddAllArgs(CmdArgs, options::OPT_t);
5200 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5201
5202 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5203
5204 //----------------------------------------------------------------------------
5205 // Libraries
5206 //----------------------------------------------------------------------------
5207 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005208 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005209 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5210 CmdArgs.push_back("-lm");
5211 }
5212
5213 CmdArgs.push_back("--start-group");
5214
5215 if (!buildingLib) {
5216 for(std::vector<std::string>::iterator i = oslibs.begin(),
5217 e = oslibs.end(); i != e; ++i)
5218 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5219 CmdArgs.push_back("-lc");
5220 }
5221 CmdArgs.push_back("-lgcc");
5222
5223 CmdArgs.push_back("--end-group");
5224 }
5225
5226 //----------------------------------------------------------------------------
5227 // End files
5228 //----------------------------------------------------------------------------
5229 if (incStdLib && incStartFiles) {
5230 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5231 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5232 }
5233
5234 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005235 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005236}
5237// Hexagon tools end.
5238
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005239/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005240const char *arm::getARMCPUForMArch(const ArgList &Args,
5241 const llvm::Triple &Triple) {
5242 StringRef MArch;
5243 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5244 // Otherwise, if we have -march= choose the base CPU for that arch.
5245 MArch = A->getValue();
5246 } else {
5247 // Otherwise, use the Arch from the triple.
5248 MArch = Triple.getArchName();
5249 }
5250
5251 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005252 if (MArch == "native") {
5253 std::string CPU = llvm::sys::getHostCPUName();
5254 if (CPU != "generic") {
5255 // Translate the native cpu into the architecture. The switch below will
5256 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005257 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005258 }
5259 }
5260
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005261 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005262}
5263
5264/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005265StringRef arm::getARMTargetCPU(const ArgList &Args,
5266 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005267 // FIXME: Warn on inconsistent use of -mcpu and -march.
5268 // If we have -mcpu=, use that.
5269 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5270 StringRef MCPU = A->getValue();
5271 // Handle -mcpu=native.
5272 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005273 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005274 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005275 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005276 }
5277
5278 return getARMCPUForMArch(Args, Triple);
5279}
5280
5281/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5282/// CPU.
5283//
5284// FIXME: This is redundant with -mcpu, why does LLVM use this.
5285// FIXME: tblgen this, or kill it!
5286const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5287 return llvm::StringSwitch<const char *>(CPU)
5288 .Case("strongarm", "v4")
5289 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5290 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5291 .Cases("arm920", "arm920t", "arm922t", "v4t")
5292 .Cases("arm940t", "ep9312","v4t")
5293 .Cases("arm10tdmi", "arm1020t", "v5")
5294 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5295 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5296 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5297 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5298 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5299 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005300 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005301 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5302 .Cases("cortex-r4", "cortex-r5", "v7r")
5303 .Case("cortex-m0", "v6m")
5304 .Case("cortex-m3", "v7m")
5305 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005306 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005307 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005308 .Cases("cortex-a53", "cortex-a57", "v8")
5309 .Default("");
5310}
5311
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005312bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5313 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5314 return A && (A->getValue() == StringRef(Value));
5315}
5316
Daniel Sanders2bf13662014-07-10 14:40:57 +00005317bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005318 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5319 return llvm::StringSwitch<bool>(NaNArg->getValue())
5320 .Case("2008", true)
5321 .Case("legacy", false)
5322 .Default(false);
5323
5324 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005325 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5326 .Cases("mips32r6", "mips64r6", true)
5327 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005328
5329 return false;
5330}
5331
Daniel Sanders379d44b2014-07-16 11:52:23 +00005332bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5333 StringRef ABIName) {
5334 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005335 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005336 return false;
5337
5338 if (ABIName != "32")
5339 return false;
5340
5341 return llvm::StringSwitch<bool>(CPUName)
5342 .Cases("mips2", "mips3", "mips4", "mips5", true)
5343 .Cases("mips32", "mips32r2", true)
5344 .Cases("mips64", "mips64r2", true)
5345 .Default(false);
5346}
5347
Tim Northover157d9112014-01-16 08:48:16 +00005348llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005349 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5350 // archs which Darwin doesn't use.
5351
5352 // The matching this routine does is fairly pointless, since it is neither the
5353 // complete architecture list, nor a reasonable subset. The problem is that
5354 // historically the driver driver accepts this and also ties its -march=
5355 // handling to the architecture name, so we need to be careful before removing
5356 // support for it.
5357
5358 // This code must be kept in sync with Clang's Darwin specific argument
5359 // translation.
5360
5361 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5362 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5363 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5364 .Case("ppc64", llvm::Triple::ppc64)
5365 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5366 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5367 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005368 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005369 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005370 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005371 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005372 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005373 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005374 .Case("r600", llvm::Triple::r600)
5375 .Case("nvptx", llvm::Triple::nvptx)
5376 .Case("nvptx64", llvm::Triple::nvptx64)
5377 .Case("amdil", llvm::Triple::amdil)
5378 .Case("spir", llvm::Triple::spir)
5379 .Default(llvm::Triple::UnknownArch);
5380}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005381
Tim Northover157d9112014-01-16 08:48:16 +00005382void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5383 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5384 T.setArch(Arch);
5385
5386 if (Str == "x86_64h")
5387 T.setArchName(Str);
5388 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5389 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005390 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005391 }
5392}
5393
Bob Wilsondecc03e2012-11-23 06:14:39 +00005394const char *Clang::getBaseInputName(const ArgList &Args,
5395 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005396 return Args.MakeArgString(
5397 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005398}
5399
Bob Wilsondecc03e2012-11-23 06:14:39 +00005400const char *Clang::getBaseInputStem(const ArgList &Args,
5401 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005402 const char *Str = getBaseInputName(Args, Inputs);
5403
Chris Lattner906bb902011-01-16 08:14:11 +00005404 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005405 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005406
5407 return Str;
5408}
5409
Bob Wilsondecc03e2012-11-23 06:14:39 +00005410const char *Clang::getDependencyFileName(const ArgList &Args,
5411 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005412 // FIXME: Think about this more.
5413 std::string Res;
5414
5415 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005416 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005417 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005418 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005419 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005420 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005421 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005422}
5423
Daniel Dunbarbe220842009-03-20 16:06:39 +00005424void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005425 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005426 const InputInfoList &Inputs,
5427 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005428 const char *LinkingOutput) const {
5429 ArgStringList CmdArgs;
5430
5431 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5432 const InputInfo &Input = Inputs[0];
5433
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005434 // Determine the original source input.
5435 const Action *SourceAction = &JA;
5436 while (SourceAction->getKind() != Action::InputClass) {
5437 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5438 SourceAction = SourceAction->getInputs()[0];
5439 }
5440
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005441 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005442 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005443 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5444 // FIXME: at run-time detect assembler capabilities or rely on version
5445 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005446 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005447 const llvm::Triple &T(getToolChain().getTriple());
5448 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005449 CmdArgs.push_back("-Q");
5450 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005451
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005452 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005453 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005454 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005455 if (Args.hasArg(options::OPT_gstabs))
5456 CmdArgs.push_back("--gstabs");
5457 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005458 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005459 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005460
Daniel Dunbarbe220842009-03-20 16:06:39 +00005461 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005462 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005463
Daniel Dunbar6d484762010-07-22 01:47:22 +00005464 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005465 if (getToolChain().getArch() == llvm::Triple::x86 ||
5466 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005467 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5468 CmdArgs.push_back("-force_cpusubtype_ALL");
5469
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005470 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005471 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005472 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005473 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005474 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005475 CmdArgs.push_back("-static");
5476
Daniel Dunbarbe220842009-03-20 16:06:39 +00005477 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5478 options::OPT_Xassembler);
5479
5480 assert(Output.isFilename() && "Unexpected lipo output.");
5481 CmdArgs.push_back("-o");
5482 CmdArgs.push_back(Output.getFilename());
5483
Daniel Dunbarb440f562010-08-02 02:38:21 +00005484 assert(Input.isFilename() && "Invalid input.");
5485 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005486
5487 // asm_final spec is empty.
5488
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005489 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005490 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005491 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005492}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005493
Tim Northover157d9112014-01-16 08:48:16 +00005494void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005495
Tim Northover157d9112014-01-16 08:48:16 +00005496void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5497 ArgStringList &CmdArgs) const {
5498 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005499
Daniel Dunbarc1964212009-03-26 16:23:12 +00005500 // Derived from darwin_arch spec.
5501 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005502 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005503
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005504 // FIXME: Is this needed anymore?
5505 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005506 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005507}
5508
Bill Wendling3b2000f2012-10-02 18:02:50 +00005509bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5510 // We only need to generate a temp path for LTO if we aren't compiling object
5511 // files. When compiling source files, we run 'dsymutil' after linking. We
5512 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005513 for (const auto &Input : Inputs)
5514 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005515 return true;
5516
5517 return false;
5518}
5519
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005520void darwin::Link::AddLinkArgs(Compilation &C,
5521 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005522 ArgStringList &CmdArgs,
5523 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005524 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005525 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005526
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005527 unsigned Version[3] = { 0, 0, 0 };
5528 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5529 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005530 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005531 Version[1], Version[2], HadExtra) ||
5532 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005533 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005534 << A->getAsString(Args);
5535 }
5536
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005537 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005538 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005539 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5540 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005541
Bob Wilson3d27dad2013-08-02 22:25:34 +00005542 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5543 CmdArgs.push_back("-export_dynamic");
5544
Bill Wendling313b6bf2012-11-16 23:03:00 +00005545 // If we are using LTO, then automatically create a temporary file path for
5546 // the linker to use, so that it's lifetime will extend past a possible
5547 // dsymutil step.
5548 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5549 const char *TmpPath = C.getArgs().MakeArgString(
5550 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5551 C.addTempFile(TmpPath);
5552 CmdArgs.push_back("-object_path_lto");
5553 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005554 }
5555
Daniel Dunbarc1964212009-03-26 16:23:12 +00005556 // Derived from the "link" spec.
5557 Args.AddAllArgs(CmdArgs, options::OPT_static);
5558 if (!Args.hasArg(options::OPT_static))
5559 CmdArgs.push_back("-dynamic");
5560 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5561 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5562 // here. How do we wish to handle such things?
5563 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005564
Daniel Dunbarc1964212009-03-26 16:23:12 +00005565 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005566 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005567 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005568 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005569
5570 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5571 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5572 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5573
5574 Arg *A;
5575 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5576 (A = Args.getLastArg(options::OPT_current__version)) ||
5577 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005578 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005579 << A->getAsString(Args) << "-dynamiclib";
5580
5581 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5582 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5583 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5584 } else {
5585 CmdArgs.push_back("-dylib");
5586
5587 Arg *A;
5588 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5589 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5590 (A = Args.getLastArg(options::OPT_client__name)) ||
5591 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5592 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5593 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005594 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005595 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005596
Daniel Dunbarc1964212009-03-26 16:23:12 +00005597 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5598 "-dylib_compatibility_version");
5599 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5600 "-dylib_current_version");
5601
Tim Northover157d9112014-01-16 08:48:16 +00005602 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005603
5604 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5605 "-dylib_install_name");
5606 }
5607
5608 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5609 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5610 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005611 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005612 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005613 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5614 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5615 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5616 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5617 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5618 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005619 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005620 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5621 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5622 Args.AddAllArgs(CmdArgs, options::OPT_init);
5623
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005624 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005625 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005626
Daniel Dunbarc1964212009-03-26 16:23:12 +00005627 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5628 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5629 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5630 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5631 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005632
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005633 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5634 options::OPT_fno_pie,
5635 options::OPT_fno_PIE)) {
5636 if (A->getOption().matches(options::OPT_fpie) ||
5637 A->getOption().matches(options::OPT_fPIE))
5638 CmdArgs.push_back("-pie");
5639 else
5640 CmdArgs.push_back("-no_pie");
5641 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005642
5643 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5644 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5645 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5646 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5647 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5648 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5649 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5650 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5651 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5652 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5653 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5654 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5655 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5656 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5657 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5658 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005659
Daniel Dunbar84384642011-05-02 21:03:47 +00005660 // Give --sysroot= preference, over the Apple specific behavior to also use
5661 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005662 StringRef sysroot = C.getSysRoot();
5663 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005664 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005665 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005666 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5667 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005668 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005669 }
5670
Daniel Dunbarc1964212009-03-26 16:23:12 +00005671 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5672 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5673 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5674 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5675 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005676 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005677 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5678 Args.AddAllArgs(CmdArgs, options::OPT_y);
5679 Args.AddLastArg(CmdArgs, options::OPT_w);
5680 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5681 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5682 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5683 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5684 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5685 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5686 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5687 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5688 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5689 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5690 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5691 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5692}
5693
Alexey Bataev186b28a2014-03-06 05:43:53 +00005694enum LibOpenMP {
5695 LibUnknown,
5696 LibGOMP,
5697 LibIOMP5
5698};
5699
Daniel Dunbarc1964212009-03-26 16:23:12 +00005700void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005701 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005702 const InputInfoList &Inputs,
5703 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005704 const char *LinkingOutput) const {
5705 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005706
Daniel Dunbarc1964212009-03-26 16:23:12 +00005707 // The logic here is derived from gcc's behavior; most of which
5708 // comes from specs (starting with link_command). Consult gcc for
5709 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005710 ArgStringList CmdArgs;
5711
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005712 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5713 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5714 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005715 for (const auto &Arg : Args)
5716 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005717 const char *Exec =
5718 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5719 CmdArgs.push_back(Output.getFilename());
5720 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5721 return;
5722 }
5723
Daniel Dunbarc1964212009-03-26 16:23:12 +00005724 // I'm not sure why this particular decomposition exists in gcc, but
5725 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005726 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005727
Daniel Dunbarc1964212009-03-26 16:23:12 +00005728 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5729 Args.AddAllArgs(CmdArgs, options::OPT_s);
5730 Args.AddAllArgs(CmdArgs, options::OPT_t);
5731 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5732 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005733 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005734 Args.AddAllArgs(CmdArgs, options::OPT_r);
5735
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005736 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5737 // members of static archive libraries which implement Objective-C classes or
5738 // categories.
5739 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5740 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005741
Daniel Dunbarc1964212009-03-26 16:23:12 +00005742 CmdArgs.push_back("-o");
5743 CmdArgs.push_back(Output.getFilename());
5744
Chad Rosier06fd3c62012-05-16 23:45:12 +00005745 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005746 !Args.hasArg(options::OPT_nostartfiles))
5747 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005748
5749 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005750
Alexey Bataev186b28a2014-03-06 05:43:53 +00005751 LibOpenMP UsedOpenMPLib = LibUnknown;
5752 if (Args.hasArg(options::OPT_fopenmp)) {
5753 UsedOpenMPLib = LibGOMP;
5754 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5755 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5756 .Case("libgomp", LibGOMP)
5757 .Case("libiomp5", LibIOMP5)
5758 .Default(LibUnknown);
5759 if (UsedOpenMPLib == LibUnknown)
5760 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5761 << A->getOption().getName() << A->getValue();
5762 }
5763 switch (UsedOpenMPLib) {
5764 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005765 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005766 break;
5767 case LibIOMP5:
5768 CmdArgs.push_back("-liomp5");
5769 break;
5770 case LibUnknown:
5771 break;
5772 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005773
Douglas Gregor9295df02012-05-15 21:00:27 +00005774 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5775
Bob Wilson16d93952012-05-15 18:57:39 +00005776 if (isObjCRuntimeLinked(Args) &&
5777 !Args.hasArg(options::OPT_nostdlib) &&
5778 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005779 // We use arclite library for both ARC and subscripting support.
5780 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5781
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005782 CmdArgs.push_back("-framework");
5783 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005784 // Link libobj.
5785 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005786 }
John McCall31168b02011-06-15 23:02:42 +00005787
Daniel Dunbarc1964212009-03-26 16:23:12 +00005788 if (LinkingOutput) {
5789 CmdArgs.push_back("-arch_multiple");
5790 CmdArgs.push_back("-final_output");
5791 CmdArgs.push_back(LinkingOutput);
5792 }
5793
Daniel Dunbarc1964212009-03-26 16:23:12 +00005794 if (Args.hasArg(options::OPT_fnested_functions))
5795 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005796
Daniel Dunbarc1964212009-03-26 16:23:12 +00005797 if (!Args.hasArg(options::OPT_nostdlib) &&
5798 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005799 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005800 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005801
Daniel Dunbarc1964212009-03-26 16:23:12 +00005802 // link_ssp spec is empty.
5803
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005804 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005805 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005806 }
5807
Chad Rosier06fd3c62012-05-16 23:45:12 +00005808 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005809 !Args.hasArg(options::OPT_nostartfiles)) {
5810 // endfile_spec is empty.
5811 }
5812
5813 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5814 Args.AddAllArgs(CmdArgs, options::OPT_F);
5815
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005816 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005817 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005818 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005819}
5820
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005821void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005822 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005823 const InputInfoList &Inputs,
5824 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005825 const char *LinkingOutput) const {
5826 ArgStringList CmdArgs;
5827
5828 CmdArgs.push_back("-create");
5829 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005830
5831 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005832 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005833
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005834 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005835 assert(II.isFilename() && "Unexpected lipo input.");
5836 CmdArgs.push_back(II.getFilename());
5837 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005838
5839 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005840 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005841}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005842
Daniel Dunbar88299622010-06-04 18:28:36 +00005843void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005844 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005845 const InputInfoList &Inputs,
5846 const ArgList &Args,
5847 const char *LinkingOutput) const {
5848 ArgStringList CmdArgs;
5849
Daniel Dunbareb86b042011-05-09 17:23:16 +00005850 CmdArgs.push_back("-o");
5851 CmdArgs.push_back(Output.getFilename());
5852
Daniel Dunbar88299622010-06-04 18:28:36 +00005853 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5854 const InputInfo &Input = Inputs[0];
5855 assert(Input.isFilename() && "Unexpected dsymutil input.");
5856 CmdArgs.push_back(Input.getFilename());
5857
Daniel Dunbar88299622010-06-04 18:28:36 +00005858 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005859 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005860 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005861}
5862
Eric Christopher551ef452011-08-23 17:56:55 +00005863void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005864 const InputInfo &Output,
5865 const InputInfoList &Inputs,
5866 const ArgList &Args,
5867 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005868 ArgStringList CmdArgs;
5869 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005870 CmdArgs.push_back("--debug-info");
5871 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005872 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005873
5874 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5875 const InputInfo &Input = Inputs[0];
5876 assert(Input.isFilename() && "Unexpected verify input");
5877
5878 // Grabbing the output of the earlier dsymutil run.
5879 CmdArgs.push_back(Input.getFilename());
5880
5881 const char *Exec =
5882 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5883 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5884}
5885
David Chisnallf571cde2012-02-15 13:39:01 +00005886void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5887 const InputInfo &Output,
5888 const InputInfoList &Inputs,
5889 const ArgList &Args,
5890 const char *LinkingOutput) const {
5891 ArgStringList CmdArgs;
5892
5893 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5894 options::OPT_Xassembler);
5895
5896 CmdArgs.push_back("-o");
5897 CmdArgs.push_back(Output.getFilename());
5898
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005899 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005900 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005901
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005902 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Chisnallf571cde2012-02-15 13:39:01 +00005903 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5904}
5905
David Chisnallf571cde2012-02-15 13:39:01 +00005906void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5907 const InputInfo &Output,
5908 const InputInfoList &Inputs,
5909 const ArgList &Args,
5910 const char *LinkingOutput) const {
5911 // FIXME: Find a real GCC, don't hard-code versions here
5912 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5913 const llvm::Triple &T = getToolChain().getTriple();
5914 std::string LibPath = "/usr/lib/";
5915 llvm::Triple::ArchType Arch = T.getArch();
5916 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005917 case llvm::Triple::x86:
5918 GCCLibPath +=
5919 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5920 break;
5921 case llvm::Triple::x86_64:
5922 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5923 GCCLibPath += "/4.5.2/amd64/";
5924 LibPath += "amd64/";
5925 break;
5926 default:
5927 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005928 }
5929
5930 ArgStringList CmdArgs;
5931
David Chisnall272a0712012-02-29 15:06:12 +00005932 // Demangle C++ names in errors
5933 CmdArgs.push_back("-C");
5934
David Chisnallf571cde2012-02-15 13:39:01 +00005935 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5936 (!Args.hasArg(options::OPT_shared))) {
5937 CmdArgs.push_back("-e");
5938 CmdArgs.push_back("_start");
5939 }
5940
5941 if (Args.hasArg(options::OPT_static)) {
5942 CmdArgs.push_back("-Bstatic");
5943 CmdArgs.push_back("-dn");
5944 } else {
5945 CmdArgs.push_back("-Bdynamic");
5946 if (Args.hasArg(options::OPT_shared)) {
5947 CmdArgs.push_back("-shared");
5948 } else {
5949 CmdArgs.push_back("--dynamic-linker");
5950 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5951 }
5952 }
5953
5954 if (Output.isFilename()) {
5955 CmdArgs.push_back("-o");
5956 CmdArgs.push_back(Output.getFilename());
5957 } else {
5958 assert(Output.isNothing() && "Invalid output.");
5959 }
5960
5961 if (!Args.hasArg(options::OPT_nostdlib) &&
5962 !Args.hasArg(options::OPT_nostartfiles)) {
5963 if (!Args.hasArg(options::OPT_shared)) {
5964 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5965 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005966 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005967 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5968 } else {
5969 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005970 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5971 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005972 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005973 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005974 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005975 }
5976
5977 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5978
5979 Args.AddAllArgs(CmdArgs, options::OPT_L);
5980 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5981 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005982 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005983
5984 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5985
5986 if (!Args.hasArg(options::OPT_nostdlib) &&
5987 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005988 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005989 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005990 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005991 if (!Args.hasArg(options::OPT_shared)) {
5992 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005993 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005994 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005995 }
David Chisnallf571cde2012-02-15 13:39:01 +00005996 }
5997
5998 if (!Args.hasArg(options::OPT_nostdlib) &&
5999 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006000 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006001 }
David Chisnall96de9932012-02-16 16:00:47 +00006002 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006003
Alexey Samsonov7811d192014-02-20 13:57:37 +00006004 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006005
6006 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006007 Args.MakeArgString(getToolChain().GetLinkerPath());
David Chisnallf571cde2012-02-15 13:39:01 +00006008 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6009}
6010
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006011void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006012 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006013 const InputInfoList &Inputs,
6014 const ArgList &Args,
6015 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006016 ArgStringList CmdArgs;
6017
6018 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6019 options::OPT_Xassembler);
6020
6021 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006022 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006023
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006024 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006025 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006026
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006027 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006028 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006029}
6030
6031void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006032 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006033 const InputInfoList &Inputs,
6034 const ArgList &Args,
6035 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006036 ArgStringList CmdArgs;
6037
6038 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006039 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006040 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00006041 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006042 }
6043
6044 if (Args.hasArg(options::OPT_static)) {
6045 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00006046 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006047 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00006048// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006049 CmdArgs.push_back("-Bdynamic");
6050 if (Args.hasArg(options::OPT_shared)) {
6051 CmdArgs.push_back("-shared");
6052 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00006053 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006054 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
6055 }
6056 }
6057
Daniel Dunbarb440f562010-08-02 02:38:21 +00006058 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006059 CmdArgs.push_back("-o");
6060 CmdArgs.push_back(Output.getFilename());
6061 } else {
6062 assert(Output.isNothing() && "Invalid output.");
6063 }
6064
6065 if (!Args.hasArg(options::OPT_nostdlib) &&
6066 !Args.hasArg(options::OPT_nostartfiles)) {
6067 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006068 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006069 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006070 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006071 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006072 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006073 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006074 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006075 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006076 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006077 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00006078 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006079 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006080 }
6081
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006082 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
6083 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006084 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006085
6086 Args.AddAllArgs(CmdArgs, options::OPT_L);
6087 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6088 Args.AddAllArgs(CmdArgs, options::OPT_e);
6089
Daniel Dunbar54423b22010-09-17 00:24:54 +00006090 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006091
6092 if (!Args.hasArg(options::OPT_nostdlib) &&
6093 !Args.hasArg(options::OPT_nodefaultlibs)) {
6094 // FIXME: For some reason GCC passes -lgcc before adding
6095 // the default system libraries. Just mimic this for now.
6096 CmdArgs.push_back("-lgcc");
6097
6098 if (Args.hasArg(options::OPT_pthread))
6099 CmdArgs.push_back("-pthread");
6100 if (!Args.hasArg(options::OPT_shared))
6101 CmdArgs.push_back("-lc");
6102 CmdArgs.push_back("-lgcc");
6103 }
6104
6105 if (!Args.hasArg(options::OPT_nostdlib) &&
6106 !Args.hasArg(options::OPT_nostartfiles)) {
6107 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006108 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006109 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006110 }
6111
Alexey Samsonov7811d192014-02-20 13:57:37 +00006112 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006113
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006114 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006115 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006116 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006117}
6118
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006119void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006120 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006121 const InputInfoList &Inputs,
6122 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006123 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006124 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006125 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006126
Rafael Espindolacc126272014-02-28 01:55:21 +00006127 switch (getToolChain().getArch()) {
6128 case llvm::Triple::x86:
6129 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6130 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006131 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006132 break;
6133
6134 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006135 CmdArgs.push_back("-mppc");
6136 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006137 break;
6138
6139 case llvm::Triple::sparc:
6140 CmdArgs.push_back("-32");
6141 NeedsKPIC = true;
6142 break;
6143
6144 case llvm::Triple::sparcv9:
6145 CmdArgs.push_back("-64");
6146 CmdArgs.push_back("-Av9a");
6147 NeedsKPIC = true;
6148 break;
6149
6150 case llvm::Triple::mips64:
6151 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006152 StringRef CPUName;
6153 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006154 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006155
6156 CmdArgs.push_back("-mabi");
6157 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6158
6159 if (getToolChain().getArch() == llvm::Triple::mips64)
6160 CmdArgs.push_back("-EB");
6161 else
6162 CmdArgs.push_back("-EL");
6163
Rafael Espindolacc126272014-02-28 01:55:21 +00006164 NeedsKPIC = true;
6165 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006166 }
6167
Rafael Espindolacc126272014-02-28 01:55:21 +00006168 default:
6169 break;
6170 }
6171
6172 if (NeedsKPIC)
6173 addAssemblerKPIC(Args, CmdArgs);
6174
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006175 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6176 options::OPT_Xassembler);
6177
6178 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006179 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006180
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006181 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006182 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006183
6184 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006185 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006186 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006187}
6188
6189void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006190 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006191 const InputInfoList &Inputs,
6192 const ArgList &Args,
6193 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006194 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006195 ArgStringList CmdArgs;
6196
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006197 // Silence warning for "clang -g foo.o -o foo"
6198 Args.ClaimAllArgs(options::OPT_g_Group);
6199 // and "clang -emit-llvm foo.o -o foo"
6200 Args.ClaimAllArgs(options::OPT_emit_llvm);
6201 // and for "clang -w foo.o -o foo". Other warning options are already
6202 // handled somewhere else.
6203 Args.ClaimAllArgs(options::OPT_w);
6204
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006205 if (getToolChain().getArch() == llvm::Triple::mips64)
6206 CmdArgs.push_back("-EB");
6207 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6208 CmdArgs.push_back("-EL");
6209
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006210 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006211 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006212 CmdArgs.push_back("-e");
6213 CmdArgs.push_back("__start");
6214 }
6215
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006216 if (Args.hasArg(options::OPT_static)) {
6217 CmdArgs.push_back("-Bstatic");
6218 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006219 if (Args.hasArg(options::OPT_rdynamic))
6220 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006221 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006222 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006223 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006224 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006225 } else {
6226 CmdArgs.push_back("-dynamic-linker");
6227 CmdArgs.push_back("/usr/libexec/ld.so");
6228 }
6229 }
6230
Rafael Espindola044f7832013-06-05 04:28:55 +00006231 if (Args.hasArg(options::OPT_nopie))
6232 CmdArgs.push_back("-nopie");
6233
Daniel Dunbarb440f562010-08-02 02:38:21 +00006234 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006235 CmdArgs.push_back("-o");
6236 CmdArgs.push_back(Output.getFilename());
6237 } else {
6238 assert(Output.isNothing() && "Invalid output.");
6239 }
6240
6241 if (!Args.hasArg(options::OPT_nostdlib) &&
6242 !Args.hasArg(options::OPT_nostartfiles)) {
6243 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006244 if (Args.hasArg(options::OPT_pg))
6245 CmdArgs.push_back(Args.MakeArgString(
6246 getToolChain().GetFilePath("gcrt0.o")));
6247 else
6248 CmdArgs.push_back(Args.MakeArgString(
6249 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006250 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006251 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006252 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006253 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006254 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006255 }
6256 }
6257
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006258 std::string Triple = getToolChain().getTripleString();
6259 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006260 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006261 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006262 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006263
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006264 Args.AddAllArgs(CmdArgs, options::OPT_L);
6265 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6266 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006267 Args.AddAllArgs(CmdArgs, options::OPT_s);
6268 Args.AddAllArgs(CmdArgs, options::OPT_t);
6269 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6270 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006271
Daniel Dunbar54423b22010-09-17 00:24:54 +00006272 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006273
6274 if (!Args.hasArg(options::OPT_nostdlib) &&
6275 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006276 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006277 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006278 if (Args.hasArg(options::OPT_pg))
6279 CmdArgs.push_back("-lm_p");
6280 else
6281 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006282 }
6283
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006284 // FIXME: For some reason GCC passes -lgcc before adding
6285 // the default system libraries. Just mimic this for now.
6286 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006287
Eric Christopher17674ec2012-09-13 06:32:34 +00006288 if (Args.hasArg(options::OPT_pthread)) {
6289 if (!Args.hasArg(options::OPT_shared) &&
6290 Args.hasArg(options::OPT_pg))
6291 CmdArgs.push_back("-lpthread_p");
6292 else
6293 CmdArgs.push_back("-lpthread");
6294 }
6295
Chandler Carruth45661652011-12-17 22:32:42 +00006296 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006297 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006298 CmdArgs.push_back("-lc_p");
6299 else
6300 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006301 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006302
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006303 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006304 }
6305
6306 if (!Args.hasArg(options::OPT_nostdlib) &&
6307 !Args.hasArg(options::OPT_nostartfiles)) {
6308 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006309 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006310 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006311 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006312 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006313 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006314 }
6315
6316 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006317 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006318 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006319}
Ed Schoutene33194b2009-04-02 19:13:12 +00006320
Eli Friedman9fa28852012-08-08 23:57:20 +00006321void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6322 const InputInfo &Output,
6323 const InputInfoList &Inputs,
6324 const ArgList &Args,
6325 const char *LinkingOutput) const {
6326 ArgStringList CmdArgs;
6327
6328 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6329 options::OPT_Xassembler);
6330
6331 CmdArgs.push_back("-o");
6332 CmdArgs.push_back(Output.getFilename());
6333
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006334 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006335 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006336
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006337 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Eli Friedman9fa28852012-08-08 23:57:20 +00006338 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6339}
6340
6341void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6342 const InputInfo &Output,
6343 const InputInfoList &Inputs,
6344 const ArgList &Args,
6345 const char *LinkingOutput) const {
6346 const Driver &D = getToolChain().getDriver();
6347 ArgStringList CmdArgs;
6348
6349 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6350 (!Args.hasArg(options::OPT_shared))) {
6351 CmdArgs.push_back("-e");
6352 CmdArgs.push_back("__start");
6353 }
6354
6355 if (Args.hasArg(options::OPT_static)) {
6356 CmdArgs.push_back("-Bstatic");
6357 } else {
6358 if (Args.hasArg(options::OPT_rdynamic))
6359 CmdArgs.push_back("-export-dynamic");
6360 CmdArgs.push_back("--eh-frame-hdr");
6361 CmdArgs.push_back("-Bdynamic");
6362 if (Args.hasArg(options::OPT_shared)) {
6363 CmdArgs.push_back("-shared");
6364 } else {
6365 CmdArgs.push_back("-dynamic-linker");
6366 CmdArgs.push_back("/usr/libexec/ld.so");
6367 }
6368 }
6369
6370 if (Output.isFilename()) {
6371 CmdArgs.push_back("-o");
6372 CmdArgs.push_back(Output.getFilename());
6373 } else {
6374 assert(Output.isNothing() && "Invalid output.");
6375 }
6376
6377 if (!Args.hasArg(options::OPT_nostdlib) &&
6378 !Args.hasArg(options::OPT_nostartfiles)) {
6379 if (!Args.hasArg(options::OPT_shared)) {
6380 if (Args.hasArg(options::OPT_pg))
6381 CmdArgs.push_back(Args.MakeArgString(
6382 getToolChain().GetFilePath("gcrt0.o")));
6383 else
6384 CmdArgs.push_back(Args.MakeArgString(
6385 getToolChain().GetFilePath("crt0.o")));
6386 CmdArgs.push_back(Args.MakeArgString(
6387 getToolChain().GetFilePath("crtbegin.o")));
6388 } else {
6389 CmdArgs.push_back(Args.MakeArgString(
6390 getToolChain().GetFilePath("crtbeginS.o")));
6391 }
6392 }
6393
6394 Args.AddAllArgs(CmdArgs, options::OPT_L);
6395 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6396 Args.AddAllArgs(CmdArgs, options::OPT_e);
6397
6398 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6399
6400 if (!Args.hasArg(options::OPT_nostdlib) &&
6401 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006402 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006403 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6404 if (Args.hasArg(options::OPT_pg))
6405 CmdArgs.push_back("-lm_p");
6406 else
6407 CmdArgs.push_back("-lm");
6408 }
6409
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006410 if (Args.hasArg(options::OPT_pthread)) {
6411 if (!Args.hasArg(options::OPT_shared) &&
6412 Args.hasArg(options::OPT_pg))
6413 CmdArgs.push_back("-lpthread_p");
6414 else
6415 CmdArgs.push_back("-lpthread");
6416 }
6417
Eli Friedman9fa28852012-08-08 23:57:20 +00006418 if (!Args.hasArg(options::OPT_shared)) {
6419 if (Args.hasArg(options::OPT_pg))
6420 CmdArgs.push_back("-lc_p");
6421 else
6422 CmdArgs.push_back("-lc");
6423 }
6424
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006425 StringRef MyArch;
6426 switch (getToolChain().getTriple().getArch()) {
6427 case llvm::Triple::arm:
6428 MyArch = "arm";
6429 break;
6430 case llvm::Triple::x86:
6431 MyArch = "i386";
6432 break;
6433 case llvm::Triple::x86_64:
6434 MyArch = "amd64";
6435 break;
6436 default:
6437 llvm_unreachable("Unsupported architecture");
6438 }
6439 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006440 }
6441
6442 if (!Args.hasArg(options::OPT_nostdlib) &&
6443 !Args.hasArg(options::OPT_nostartfiles)) {
6444 if (!Args.hasArg(options::OPT_shared))
6445 CmdArgs.push_back(Args.MakeArgString(
6446 getToolChain().GetFilePath("crtend.o")));
6447 else
6448 CmdArgs.push_back(Args.MakeArgString(
6449 getToolChain().GetFilePath("crtendS.o")));
6450 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006451
6452 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006453 Args.MakeArgString(getToolChain().GetLinkerPath());
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006454 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006455}
6456
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006457void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006458 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006459 const InputInfoList &Inputs,
6460 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006461 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006462 ArgStringList CmdArgs;
6463
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006464 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6465 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006466 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006467 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006468 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006469 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006470 else if (getToolChain().getArch() == llvm::Triple::mips ||
6471 getToolChain().getArch() == llvm::Triple::mipsel ||
6472 getToolChain().getArch() == llvm::Triple::mips64 ||
6473 getToolChain().getArch() == llvm::Triple::mips64el) {
6474 StringRef CPUName;
6475 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006476 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006477
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006478 CmdArgs.push_back("-march");
6479 CmdArgs.push_back(CPUName.data());
6480
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006481 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006482 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006483
6484 if (getToolChain().getArch() == llvm::Triple::mips ||
6485 getToolChain().getArch() == llvm::Triple::mips64)
6486 CmdArgs.push_back("-EB");
6487 else
6488 CmdArgs.push_back("-EL");
6489
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006490 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006491 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006492 getToolChain().getArch() == llvm::Triple::armeb ||
6493 getToolChain().getArch() == llvm::Triple::thumb ||
6494 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006495 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006496 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006497 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6498
6499 if (FloatABI == "hard") {
6500 CmdArgs.push_back("-mfpu=vfp");
6501 } else {
6502 CmdArgs.push_back("-mfpu=softvfp");
6503 }
6504
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006505 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006506 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006507 case llvm::Triple::GNUEABI:
6508 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006509 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006510 break;
6511
6512 default:
6513 CmdArgs.push_back("-matpcs");
6514 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006515 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006516 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006517 if (getToolChain().getArch() == llvm::Triple::sparc)
6518 CmdArgs.push_back("-Av8plusa");
6519 else
6520 CmdArgs.push_back("-Av9a");
6521
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006522 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006523 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006524
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006525 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6526 options::OPT_Xassembler);
6527
6528 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006529 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006530
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006531 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006532 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006533
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006534 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006535 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006536}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006537
6538void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006539 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006540 const InputInfoList &Inputs,
6541 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006542 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006543 const toolchains::FreeBSD& ToolChain =
6544 static_cast<const toolchains::FreeBSD&>(getToolChain());
6545 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006546 const bool IsPIE =
6547 !Args.hasArg(options::OPT_shared) &&
6548 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006549 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006550
6551 // Silence warning for "clang -g foo.o -o foo"
6552 Args.ClaimAllArgs(options::OPT_g_Group);
6553 // and "clang -emit-llvm foo.o -o foo"
6554 Args.ClaimAllArgs(options::OPT_emit_llvm);
6555 // and for "clang -w foo.o -o foo". Other warning options are already
6556 // handled somewhere else.
6557 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006558
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006559 if (!D.SysRoot.empty())
6560 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6561
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006562 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006563 CmdArgs.push_back("-pie");
6564
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006565 if (Args.hasArg(options::OPT_static)) {
6566 CmdArgs.push_back("-Bstatic");
6567 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006568 if (Args.hasArg(options::OPT_rdynamic))
6569 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006570 CmdArgs.push_back("--eh-frame-hdr");
6571 if (Args.hasArg(options::OPT_shared)) {
6572 CmdArgs.push_back("-Bshareable");
6573 } else {
6574 CmdArgs.push_back("-dynamic-linker");
6575 CmdArgs.push_back("/libexec/ld-elf.so.1");
6576 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006577 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6578 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006579 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6580 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6581 CmdArgs.push_back("--hash-style=both");
6582 }
6583 }
6584 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006585 }
6586
6587 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6588 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006589 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006590 CmdArgs.push_back("-m");
6591 CmdArgs.push_back("elf_i386_fbsd");
6592 }
6593
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006594 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006595 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006596 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006597 }
6598
Daniel Dunbarb440f562010-08-02 02:38:21 +00006599 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006600 CmdArgs.push_back("-o");
6601 CmdArgs.push_back(Output.getFilename());
6602 } else {
6603 assert(Output.isNothing() && "Invalid output.");
6604 }
6605
6606 if (!Args.hasArg(options::OPT_nostdlib) &&
6607 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006608 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006609 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006610 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006611 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006612 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006613 crt1 = "Scrt1.o";
6614 else
6615 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006616 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006617 if (crt1)
6618 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6619
6620 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6621
Craig Topper92fc2df2014-05-17 16:56:41 +00006622 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006623 if (Args.hasArg(options::OPT_static))
6624 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006625 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006626 crtbegin = "crtbeginS.o";
6627 else
6628 crtbegin = "crtbegin.o";
6629
6630 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006631 }
6632
6633 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006634 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006635 for (const auto &Path : Paths)
6636 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006637 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6638 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006639 Args.AddAllArgs(CmdArgs, options::OPT_s);
6640 Args.AddAllArgs(CmdArgs, options::OPT_t);
6641 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6642 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006643
Alp Tokerce365ca2013-12-02 12:43:03 +00006644 if (D.IsUsingLTO(Args))
6645 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006646
Roman Divackyafe2f232012-08-28 15:09:03 +00006647 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006648
6649 if (!Args.hasArg(options::OPT_nostdlib) &&
6650 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006651 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006652 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006653 if (Args.hasArg(options::OPT_pg))
6654 CmdArgs.push_back("-lm_p");
6655 else
6656 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006657 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006658 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6659 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006660 if (Args.hasArg(options::OPT_pg))
6661 CmdArgs.push_back("-lgcc_p");
6662 else
6663 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006664 if (Args.hasArg(options::OPT_static)) {
6665 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006666 } else if (Args.hasArg(options::OPT_pg)) {
6667 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006668 } else {
6669 CmdArgs.push_back("--as-needed");
6670 CmdArgs.push_back("-lgcc_s");
6671 CmdArgs.push_back("--no-as-needed");
6672 }
6673
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006674 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006675 if (Args.hasArg(options::OPT_pg))
6676 CmdArgs.push_back("-lpthread_p");
6677 else
6678 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006679 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006680
Roman Divacky66f22762011-02-10 16:59:40 +00006681 if (Args.hasArg(options::OPT_pg)) {
6682 if (Args.hasArg(options::OPT_shared))
6683 CmdArgs.push_back("-lc");
6684 else
6685 CmdArgs.push_back("-lc_p");
6686 CmdArgs.push_back("-lgcc_p");
6687 } else {
6688 CmdArgs.push_back("-lc");
6689 CmdArgs.push_back("-lgcc");
6690 }
6691
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006692 if (Args.hasArg(options::OPT_static)) {
6693 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006694 } else if (Args.hasArg(options::OPT_pg)) {
6695 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006696 } else {
6697 CmdArgs.push_back("--as-needed");
6698 CmdArgs.push_back("-lgcc_s");
6699 CmdArgs.push_back("--no-as-needed");
6700 }
6701 }
6702
6703 if (!Args.hasArg(options::OPT_nostdlib) &&
6704 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006705 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006706 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006707 else
6708 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006709 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006710 }
6711
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006712 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6713
Alexey Samsonov7811d192014-02-20 13:57:37 +00006714 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006715
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006716 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006717 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006718 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006719}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006720
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006721void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6722 const InputInfo &Output,
6723 const InputInfoList &Inputs,
6724 const ArgList &Args,
6725 const char *LinkingOutput) const {
6726 ArgStringList CmdArgs;
6727
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006728 // GNU as needs different flags for creating the correct output format
6729 // on architectures with different ABIs or optional feature sets.
6730 switch (getToolChain().getArch()) {
6731 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006732 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006733 break;
6734 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006735 case llvm::Triple::armeb:
6736 case llvm::Triple::thumb:
6737 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006738 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006739 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006740 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006741 }
6742
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006743 case llvm::Triple::mips:
6744 case llvm::Triple::mipsel:
6745 case llvm::Triple::mips64:
6746 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006747 StringRef CPUName;
6748 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006749 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006750
6751 CmdArgs.push_back("-march");
6752 CmdArgs.push_back(CPUName.data());
6753
6754 CmdArgs.push_back("-mabi");
6755 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6756
6757 if (getToolChain().getArch() == llvm::Triple::mips ||
6758 getToolChain().getArch() == llvm::Triple::mips64)
6759 CmdArgs.push_back("-EB");
6760 else
6761 CmdArgs.push_back("-EL");
6762
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006763 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006764 break;
6765 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006766
6767 case llvm::Triple::sparc:
6768 CmdArgs.push_back("-32");
6769 addAssemblerKPIC(Args, CmdArgs);
6770 break;
6771
6772 case llvm::Triple::sparcv9:
6773 CmdArgs.push_back("-64");
6774 CmdArgs.push_back("-Av9");
6775 addAssemblerKPIC(Args, CmdArgs);
6776 break;
6777
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006778 default:
6779 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006780 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006781
6782 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6783 options::OPT_Xassembler);
6784
6785 CmdArgs.push_back("-o");
6786 CmdArgs.push_back(Output.getFilename());
6787
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006788 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006789 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006790
David Chisnallddbd68f2011-09-27 22:03:18 +00006791 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006792 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6793}
6794
6795void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6796 const InputInfo &Output,
6797 const InputInfoList &Inputs,
6798 const ArgList &Args,
6799 const char *LinkingOutput) const {
6800 const Driver &D = getToolChain().getDriver();
6801 ArgStringList CmdArgs;
6802
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006803 if (!D.SysRoot.empty())
6804 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6805
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006806 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006807 if (Args.hasArg(options::OPT_static)) {
6808 CmdArgs.push_back("-Bstatic");
6809 } else {
6810 if (Args.hasArg(options::OPT_rdynamic))
6811 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006812 if (Args.hasArg(options::OPT_shared)) {
6813 CmdArgs.push_back("-Bshareable");
6814 } else {
6815 CmdArgs.push_back("-dynamic-linker");
6816 CmdArgs.push_back("/libexec/ld.elf_so");
6817 }
6818 }
6819
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006820 // Many NetBSD architectures support more than one ABI.
6821 // Determine the correct emulation for ld.
6822 switch (getToolChain().getArch()) {
6823 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006824 CmdArgs.push_back("-m");
6825 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006826 break;
6827 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006828 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006829 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006830 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006831 CmdArgs.push_back("-m");
6832 switch (getToolChain().getTriple().getEnvironment()) {
6833 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006834 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006835 CmdArgs.push_back("armelf_nbsd_eabi");
6836 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006837 case llvm::Triple::EABIHF:
6838 case llvm::Triple::GNUEABIHF:
6839 CmdArgs.push_back("armelf_nbsd_eabihf");
6840 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006841 default:
6842 CmdArgs.push_back("armelf_nbsd");
6843 break;
6844 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006845 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006846 case llvm::Triple::mips64:
6847 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006848 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006849 CmdArgs.push_back("-m");
6850 if (getToolChain().getArch() == llvm::Triple::mips64)
6851 CmdArgs.push_back("elf32btsmip");
6852 else
6853 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006854 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006855 CmdArgs.push_back("-m");
6856 if (getToolChain().getArch() == llvm::Triple::mips64)
6857 CmdArgs.push_back("elf64btsmip");
6858 else
6859 CmdArgs.push_back("elf64ltsmip");
6860 }
6861 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006862
6863 case llvm::Triple::sparc:
6864 CmdArgs.push_back("-m");
6865 CmdArgs.push_back("elf32_sparc");
6866 break;
6867
6868 case llvm::Triple::sparcv9:
6869 CmdArgs.push_back("-m");
6870 CmdArgs.push_back("elf64_sparc");
6871 break;
6872
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006873 default:
6874 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006875 }
6876
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006877 if (Output.isFilename()) {
6878 CmdArgs.push_back("-o");
6879 CmdArgs.push_back(Output.getFilename());
6880 } else {
6881 assert(Output.isNothing() && "Invalid output.");
6882 }
6883
6884 if (!Args.hasArg(options::OPT_nostdlib) &&
6885 !Args.hasArg(options::OPT_nostartfiles)) {
6886 if (!Args.hasArg(options::OPT_shared)) {
6887 CmdArgs.push_back(Args.MakeArgString(
6888 getToolChain().GetFilePath("crt0.o")));
6889 CmdArgs.push_back(Args.MakeArgString(
6890 getToolChain().GetFilePath("crti.o")));
6891 CmdArgs.push_back(Args.MakeArgString(
6892 getToolChain().GetFilePath("crtbegin.o")));
6893 } else {
6894 CmdArgs.push_back(Args.MakeArgString(
6895 getToolChain().GetFilePath("crti.o")));
6896 CmdArgs.push_back(Args.MakeArgString(
6897 getToolChain().GetFilePath("crtbeginS.o")));
6898 }
6899 }
6900
6901 Args.AddAllArgs(CmdArgs, options::OPT_L);
6902 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6903 Args.AddAllArgs(CmdArgs, options::OPT_e);
6904 Args.AddAllArgs(CmdArgs, options::OPT_s);
6905 Args.AddAllArgs(CmdArgs, options::OPT_t);
6906 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6907 Args.AddAllArgs(CmdArgs, options::OPT_r);
6908
6909 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6910
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006911 unsigned Major, Minor, Micro;
6912 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6913 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006914 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006915 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006916 case llvm::Triple::arm:
6917 case llvm::Triple::armeb:
6918 case llvm::Triple::thumb:
6919 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006920 case llvm::Triple::x86:
6921 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006922 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006923 break;
6924 default:
6925 break;
6926 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006927 }
6928
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006929 if (!Args.hasArg(options::OPT_nostdlib) &&
6930 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006931 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006932 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6933 CmdArgs.push_back("-lm");
6934 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006935 if (Args.hasArg(options::OPT_pthread))
6936 CmdArgs.push_back("-lpthread");
6937 CmdArgs.push_back("-lc");
6938
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006939 if (useLibgcc) {
6940 if (Args.hasArg(options::OPT_static)) {
6941 // libgcc_eh depends on libc, so resolve as much as possible,
6942 // pull in any new requirements from libc and then get the rest
6943 // of libgcc.
6944 CmdArgs.push_back("-lgcc_eh");
6945 CmdArgs.push_back("-lc");
6946 CmdArgs.push_back("-lgcc");
6947 } else {
6948 CmdArgs.push_back("-lgcc");
6949 CmdArgs.push_back("--as-needed");
6950 CmdArgs.push_back("-lgcc_s");
6951 CmdArgs.push_back("--no-as-needed");
6952 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006953 }
6954 }
6955
6956 if (!Args.hasArg(options::OPT_nostdlib) &&
6957 !Args.hasArg(options::OPT_nostartfiles)) {
6958 if (!Args.hasArg(options::OPT_shared))
6959 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6960 "crtend.o")));
6961 else
6962 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6963 "crtendS.o")));
6964 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6965 "crtn.o")));
6966 }
6967
Alexey Samsonov7811d192014-02-20 13:57:37 +00006968 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006969
Logan Chieneb9162f2014-06-26 14:23:45 +00006970 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006971 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6972}
6973
Thomas Schwinge4e555262013-03-28 19:04:25 +00006974void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6975 const InputInfo &Output,
6976 const InputInfoList &Inputs,
6977 const ArgList &Args,
6978 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006979 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006980 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006981
6982 // Add --32/--64 to make sure we get the format we want.
6983 // This is incomplete
6984 if (getToolChain().getArch() == llvm::Triple::x86) {
6985 CmdArgs.push_back("--32");
6986 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00006987 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
6988 CmdArgs.push_back("--x32");
6989 else
6990 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006991 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6992 CmdArgs.push_back("-a32");
6993 CmdArgs.push_back("-mppc");
6994 CmdArgs.push_back("-many");
6995 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6996 CmdArgs.push_back("-a64");
6997 CmdArgs.push_back("-mppc64");
6998 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006999 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
7000 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007001 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007002 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007003 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007004 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
7005 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007006 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007007 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007008 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
7009 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007010 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007011 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007012 } else if (getToolChain().getArch() == llvm::Triple::arm ||
7013 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007014 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00007015 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
7016 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007017 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
7018 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00007019 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007020
Tim Northover9c7e0352013-12-12 11:55:52 +00007021 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7022 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007023 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007024
7025 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007026
7027 // FIXME: remove krait check when GNU tools support krait cpu
7028 // for now replace it with -march=armv7-a to avoid a lower
7029 // march from being picked in the absence of a cpu flag.
7030 Arg *A;
7031 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7032 StringRef(A->getValue()) == "krait")
7033 CmdArgs.push_back("-march=armv7-a");
7034 else
7035 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007036 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007037 } else if (getToolChain().getArch() == llvm::Triple::mips ||
7038 getToolChain().getArch() == llvm::Triple::mipsel ||
7039 getToolChain().getArch() == llvm::Triple::mips64 ||
7040 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007041 StringRef CPUName;
7042 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007043 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007044 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007045
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007046 CmdArgs.push_back("-march");
7047 CmdArgs.push_back(CPUName.data());
7048
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007049 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007050 CmdArgs.push_back(ABIName.data());
7051
7052 // LLVM doesn't support -mabicalls yet and acts as if it is always given.
7053 CmdArgs.push_back("-mno-shared");
7054 // LLVM doesn't support -mplt yet and acts as if it is always given.
7055 // However, -mplt has no effect with the N64 ABI.
7056 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007057
7058 if (getToolChain().getArch() == llvm::Triple::mips ||
7059 getToolChain().getArch() == llvm::Triple::mips64)
7060 CmdArgs.push_back("-EB");
7061 else
7062 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007063
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007064 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7065 if (StringRef(A->getValue()) == "2008")
7066 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7067 }
7068
Daniel Sanders379d44b2014-07-16 11:52:23 +00007069 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7070 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7071 options::OPT_mfp64)) {
7072 A->claim();
7073 A->render(Args, CmdArgs);
7074 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7075 ABIName))
7076 CmdArgs.push_back("-mfpxx");
7077
7078 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7079 // -mno-mips16 is actually -no-mips16.
7080 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7081 options::OPT_mno_mips16)) {
7082 if (A->getOption().matches(options::OPT_mips16)) {
7083 A->claim();
7084 A->render(Args, CmdArgs);
7085 } else {
7086 A->claim();
7087 CmdArgs.push_back("-no-mips16");
7088 }
7089 }
7090
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007091 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7092 options::OPT_mno_micromips);
7093 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7094 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7095
Simon Atanasyanbd986632013-11-26 11:58:04 +00007096 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7097 // Do not use AddLastArg because not all versions of MIPS assembler
7098 // support -mmsa / -mno-msa options.
7099 if (A->getOption().matches(options::OPT_mmsa))
7100 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7101 }
7102
Daniel Sanders379d44b2014-07-16 11:52:23 +00007103 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7104 options::OPT_msoft_float);
7105
7106 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7107 options::OPT_mno_odd_spreg);
7108
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007109 NeedsKPIC = true;
7110 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7111 // Always pass an -march option, since our default of z10 is later
7112 // than the GNU assembler's default.
7113 StringRef CPUName = getSystemZTargetCPU(Args);
7114 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7115 }
7116
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007117 if (NeedsKPIC)
7118 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007119
7120 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7121 options::OPT_Xassembler);
7122
7123 CmdArgs.push_back("-o");
7124 CmdArgs.push_back(Output.getFilename());
7125
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007126 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007127 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007128
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007129 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Rafael Espindola92b00932010-08-10 00:25:48 +00007130 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007131
7132 // Handle the debug info splitting at object creation time if we're
7133 // creating an object.
7134 // TODO: Currently only works on linux with newer objcopy.
7135 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007136 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007137 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7138 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007139}
7140
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007141static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007142 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007143 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007144 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7145 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007146 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007147 CmdArgs.push_back("-lgcc");
7148
Logan Chien3d3373c2012-11-19 12:04:11 +00007149 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007150 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007151 CmdArgs.push_back("-lgcc");
7152 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007153 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007154 CmdArgs.push_back("--as-needed");
7155 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007156 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007157 CmdArgs.push_back("--no-as-needed");
7158 }
7159
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007160 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007161 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007162 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007163 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007164
7165 // According to Android ABI, we have to link with libdl if we are
7166 // linking with non-static libgcc.
7167 //
7168 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7169 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7170 if (isAndroid && !StaticLibgcc)
7171 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007172}
7173
Simon Atanasyan14ce18d2014-06-25 05:00:59 +00007174static StringRef getLinuxDynamicLinker(const ArgList &Args,
7175 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007176 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7177 if (ToolChain.getTriple().isArch64Bit())
7178 return "/system/bin/linker64";
7179 else
7180 return "/system/bin/linker";
7181 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7182 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007183 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00007184 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7185 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007186 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00007187 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7188 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007189 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007190 else if (ToolChain.getArch() == llvm::Triple::arm ||
7191 ToolChain.getArch() == llvm::Triple::thumb) {
7192 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7193 return "/lib/ld-linux-armhf.so.3";
7194 else
7195 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007196 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7197 ToolChain.getArch() == llvm::Triple::thumbeb) {
7198 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7199 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7200 else
7201 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007202 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007203 ToolChain.getArch() == llvm::Triple::mipsel) {
Daniel Sanders2bf13662014-07-10 14:40:57 +00007204 if (mips::isNaN2008(Args, ToolChain.getTriple()))
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007205 return "/lib/ld-linux-mipsn8.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007206 return "/lib/ld.so.1";
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007207 } else if (ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007208 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007209 if (mips::hasMipsAbiArg(Args, "n32"))
Daniel Sanders2bf13662014-07-10 14:40:57 +00007210 return mips::isNaN2008(Args, ToolChain.getTriple())
7211 ? "/lib32/ld-linux-mipsn8.so.1" : "/lib32/ld.so.1";
7212 return mips::isNaN2008(Args, ToolChain.getTriple())
7213 ? "/lib64/ld-linux-mipsn8.so.1" : "/lib64/ld.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007214 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7215 return "/lib/ld.so.1";
7216 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
7217 ToolChain.getArch() == llvm::Triple::systemz)
7218 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007219 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7220 return "/lib64/ld64.so.2";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007221 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7222 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007223 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7224 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7225 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007226 else
7227 return "/lib64/ld-linux-x86-64.so.2";
7228}
7229
Renato Golinc4b49242014-02-13 10:01:16 +00007230static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7231 ArgStringList &CmdArgs, const ArgList &Args) {
7232 // Make use of compiler-rt if --rtlib option is used
7233 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7234
7235 switch(RLT) {
7236 case ToolChain::RLT_CompilerRT:
7237 addClangRTLinux(TC, Args, CmdArgs);
7238 break;
7239 case ToolChain::RLT_Libgcc:
7240 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7241 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007242 }
7243}
7244
Thomas Schwinge4e555262013-03-28 19:04:25 +00007245void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7246 const InputInfo &Output,
7247 const InputInfoList &Inputs,
7248 const ArgList &Args,
7249 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007250 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007251 static_cast<const toolchains::Linux&>(getToolChain());
7252 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007253 const bool isAndroid =
7254 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007255 const bool IsPIE =
7256 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007257 !Args.hasArg(options::OPT_static) &&
7258 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7259 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007260 // Cannot use isPIEDefault here since otherwise
7261 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007262 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007263
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007264 ArgStringList CmdArgs;
7265
Rafael Espindolad1002f62010-11-15 18:28:16 +00007266 // Silence warning for "clang -g foo.o -o foo"
7267 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007268 // and "clang -emit-llvm foo.o -o foo"
7269 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007270 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007271 // handled somewhere else.
7272 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007273
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007274 if (!D.SysRoot.empty())
7275 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007276
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007277 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007278 CmdArgs.push_back("-pie");
7279
Rafael Espindola1c76c592010-11-07 22:57:16 +00007280 if (Args.hasArg(options::OPT_rdynamic))
7281 CmdArgs.push_back("-export-dynamic");
7282
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007283 if (Args.hasArg(options::OPT_s))
7284 CmdArgs.push_back("-s");
7285
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007286 for (const auto &Opt : ToolChain.ExtraOpts)
7287 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007288
7289 if (!Args.hasArg(options::OPT_static)) {
7290 CmdArgs.push_back("--eh-frame-hdr");
7291 }
7292
7293 CmdArgs.push_back("-m");
7294 if (ToolChain.getArch() == llvm::Triple::x86)
7295 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007296 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7297 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007298 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007299 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7300 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007301 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007302 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007303 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007304 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007305 else if (ToolChain.getArch() == llvm::Triple::armeb
7306 || ToolChain.getArch() == llvm::Triple::thumbeb)
7307 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007308 else if (ToolChain.getArch() == llvm::Triple::ppc)
7309 CmdArgs.push_back("elf32ppclinux");
7310 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7311 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007312 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7313 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007314 else if (ToolChain.getArch() == llvm::Triple::sparc)
7315 CmdArgs.push_back("elf32_sparc");
7316 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7317 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007318 else if (ToolChain.getArch() == llvm::Triple::mips)
7319 CmdArgs.push_back("elf32btsmip");
7320 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7321 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007322 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007323 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007324 CmdArgs.push_back("elf32btsmipn32");
7325 else
7326 CmdArgs.push_back("elf64btsmip");
7327 }
7328 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007329 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007330 CmdArgs.push_back("elf32ltsmipn32");
7331 else
7332 CmdArgs.push_back("elf64ltsmip");
7333 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007334 else if (ToolChain.getArch() == llvm::Triple::systemz)
7335 CmdArgs.push_back("elf64_s390");
Zinovy Nis1db95732014-07-10 15:27:19 +00007336 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7337 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7338 CmdArgs.push_back("elf32_x86_64");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007339 else
7340 CmdArgs.push_back("elf_x86_64");
7341
7342 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007343 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007344 ToolChain.getArch() == llvm::Triple::armeb ||
7345 ToolChain.getArch() == llvm::Triple::thumb ||
7346 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007347 CmdArgs.push_back("-Bstatic");
7348 else
7349 CmdArgs.push_back("-static");
7350 } else if (Args.hasArg(options::OPT_shared)) {
7351 CmdArgs.push_back("-shared");
7352 }
7353
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007354 if (ToolChain.getArch() == llvm::Triple::arm ||
7355 ToolChain.getArch() == llvm::Triple::armeb ||
7356 ToolChain.getArch() == llvm::Triple::thumb ||
7357 ToolChain.getArch() == llvm::Triple::thumbeb ||
7358 (!Args.hasArg(options::OPT_static) &&
7359 !Args.hasArg(options::OPT_shared))) {
7360 CmdArgs.push_back("-dynamic-linker");
7361 CmdArgs.push_back(Args.MakeArgString(
7362 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7363 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007364
7365 CmdArgs.push_back("-o");
7366 CmdArgs.push_back(Output.getFilename());
7367
Rafael Espindola81937ec2010-12-01 01:52:43 +00007368 if (!Args.hasArg(options::OPT_nostdlib) &&
7369 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007370 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007371 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007372 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007373 if (Args.hasArg(options::OPT_pg))
7374 crt1 = "gcrt1.o";
7375 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007376 crt1 = "Scrt1.o";
7377 else
7378 crt1 = "crt1.o";
7379 }
7380 if (crt1)
7381 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007382
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007383 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7384 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007385
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007386 const char *crtbegin;
7387 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007388 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007389 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007390 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007391 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007392 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007393 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007394 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007395 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007396
7397 // Add crtfastmath.o if available and fast math is enabled.
7398 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007399 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007400
7401 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007402 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007403
7404 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7405
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007406 for (const auto &Path : Paths)
7407 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007408
Alp Tokerce365ca2013-12-02 12:43:03 +00007409 if (D.IsUsingLTO(Args))
7410 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007411
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007412 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7413 CmdArgs.push_back("--no-demangle");
7414
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007415 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7416
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007417 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007418 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007419 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007420
Hans Wennborg70850d82013-07-18 20:29:38 +00007421 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007422 !Args.hasArg(options::OPT_nostdlib) &&
7423 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007424 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7425 !Args.hasArg(options::OPT_static);
7426 if (OnlyLibstdcxxStatic)
7427 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007428 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007429 if (OnlyLibstdcxxStatic)
7430 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007431 CmdArgs.push_back("-lm");
7432 }
7433
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007434 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007435 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7436 if (Args.hasArg(options::OPT_static))
7437 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007438
Alexey Bataev186b28a2014-03-06 05:43:53 +00007439 LibOpenMP UsedOpenMPLib = LibUnknown;
7440 if (Args.hasArg(options::OPT_fopenmp)) {
7441 UsedOpenMPLib = LibGOMP;
7442 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7443 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7444 .Case("libgomp", LibGOMP)
7445 .Case("libiomp5", LibIOMP5)
7446 .Default(LibUnknown);
7447 if (UsedOpenMPLib == LibUnknown)
7448 D.Diag(diag::err_drv_unsupported_option_argument)
7449 << A->getOption().getName() << A->getValue();
7450 }
7451 switch (UsedOpenMPLib) {
7452 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007453 CmdArgs.push_back("-lgomp");
7454
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007455 // FIXME: Exclude this for platforms with libgomp that don't require
7456 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007457 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007458 break;
7459 case LibIOMP5:
7460 CmdArgs.push_back("-liomp5");
7461 break;
7462 case LibUnknown:
7463 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007464 }
Renato Golinc4b49242014-02-13 10:01:16 +00007465 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007466
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007467 if ((Args.hasArg(options::OPT_pthread) ||
7468 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7469 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007470 CmdArgs.push_back("-lpthread");
7471
7472 CmdArgs.push_back("-lc");
7473
7474 if (Args.hasArg(options::OPT_static))
7475 CmdArgs.push_back("--end-group");
7476 else
Renato Golinc4b49242014-02-13 10:01:16 +00007477 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007478 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007479
Rafael Espindola81937ec2010-12-01 01:52:43 +00007480 if (!Args.hasArg(options::OPT_nostartfiles)) {
7481 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007482 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007483 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007484 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007485 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007486 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007487 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007488
Rafael Espindola81937ec2010-12-01 01:52:43 +00007489 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007490 if (!isAndroid)
7491 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007492 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007493 }
7494
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007495 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007496}
7497
Chris Lattner3e2ee142010-07-07 16:01:42 +00007498void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007499 const InputInfo &Output,
7500 const InputInfoList &Inputs,
7501 const ArgList &Args,
7502 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007503 ArgStringList CmdArgs;
7504
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007505 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007506
7507 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007508 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007509
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007510 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007511 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007512
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007513 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007514 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007515}
7516
7517void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007518 const InputInfo &Output,
7519 const InputInfoList &Inputs,
7520 const ArgList &Args,
7521 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007522 const Driver &D = getToolChain().getDriver();
7523 ArgStringList CmdArgs;
7524
Daniel Dunbarb440f562010-08-02 02:38:21 +00007525 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007526 CmdArgs.push_back("-o");
7527 CmdArgs.push_back(Output.getFilename());
7528 } else {
7529 assert(Output.isNothing() && "Invalid output.");
7530 }
7531
7532 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007533 !Args.hasArg(options::OPT_nostartfiles)) {
7534 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7535 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7536 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7537 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7538 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007539
7540 Args.AddAllArgs(CmdArgs, options::OPT_L);
7541 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7542 Args.AddAllArgs(CmdArgs, options::OPT_e);
7543
Daniel Dunbar54423b22010-09-17 00:24:54 +00007544 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007545
Alexey Samsonov7811d192014-02-20 13:57:37 +00007546 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007547
Chris Lattner3e2ee142010-07-07 16:01:42 +00007548 if (!Args.hasArg(options::OPT_nostdlib) &&
7549 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007550 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007551 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007552 CmdArgs.push_back("-lm");
7553 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007554 }
7555
7556 if (!Args.hasArg(options::OPT_nostdlib) &&
7557 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007558 if (Args.hasArg(options::OPT_pthread))
7559 CmdArgs.push_back("-lpthread");
7560 CmdArgs.push_back("-lc");
7561 CmdArgs.push_back("-lCompilerRT-Generic");
7562 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7563 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007564 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007565 }
7566
Logan Chieneb9162f2014-06-26 14:23:45 +00007567 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007568 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007569}
7570
Daniel Dunbarcc912342009-05-02 18:28:39 +00007571/// DragonFly Tools
7572
7573// For now, DragonFly Assemble does just about the same as for
7574// FreeBSD, but this may change soon.
7575void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007576 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007577 const InputInfoList &Inputs,
7578 const ArgList &Args,
7579 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007580 ArgStringList CmdArgs;
7581
7582 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7583 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007584 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007585 CmdArgs.push_back("--32");
7586
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007587 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007588
7589 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007590 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007591
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007592 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007593 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007594
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007595 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007596 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007597}
7598
7599void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007600 const InputInfo &Output,
7601 const InputInfoList &Inputs,
7602 const ArgList &Args,
7603 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007604 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007605 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007606 ArgStringList CmdArgs;
7607
John McCall65b8da02013-04-11 22:55:55 +00007608 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7609 UseGCC47 = false;
7610
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007611 if (!D.SysRoot.empty())
7612 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7613
John McCall65b8da02013-04-11 22:55:55 +00007614 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007615 if (Args.hasArg(options::OPT_static)) {
7616 CmdArgs.push_back("-Bstatic");
7617 } else {
John McCall65b8da02013-04-11 22:55:55 +00007618 if (Args.hasArg(options::OPT_rdynamic))
7619 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007620 if (Args.hasArg(options::OPT_shared))
7621 CmdArgs.push_back("-Bshareable");
7622 else {
7623 CmdArgs.push_back("-dynamic-linker");
7624 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7625 }
John McCall65b8da02013-04-11 22:55:55 +00007626 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007627 }
7628
7629 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7630 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007631 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007632 CmdArgs.push_back("-m");
7633 CmdArgs.push_back("elf_i386");
7634 }
7635
Daniel Dunbarb440f562010-08-02 02:38:21 +00007636 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007637 CmdArgs.push_back("-o");
7638 CmdArgs.push_back(Output.getFilename());
7639 } else {
7640 assert(Output.isNothing() && "Invalid output.");
7641 }
7642
7643 if (!Args.hasArg(options::OPT_nostdlib) &&
7644 !Args.hasArg(options::OPT_nostartfiles)) {
7645 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007646 if (Args.hasArg(options::OPT_pg))
7647 CmdArgs.push_back(Args.MakeArgString(
7648 getToolChain().GetFilePath("gcrt1.o")));
7649 else {
7650 if (Args.hasArg(options::OPT_pie))
7651 CmdArgs.push_back(Args.MakeArgString(
7652 getToolChain().GetFilePath("Scrt1.o")));
7653 else
7654 CmdArgs.push_back(Args.MakeArgString(
7655 getToolChain().GetFilePath("crt1.o")));
7656 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007657 }
John McCall65b8da02013-04-11 22:55:55 +00007658 CmdArgs.push_back(Args.MakeArgString(
7659 getToolChain().GetFilePath("crti.o")));
7660 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7661 CmdArgs.push_back(Args.MakeArgString(
7662 getToolChain().GetFilePath("crtbeginS.o")));
7663 else
7664 CmdArgs.push_back(Args.MakeArgString(
7665 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007666 }
7667
7668 Args.AddAllArgs(CmdArgs, options::OPT_L);
7669 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7670 Args.AddAllArgs(CmdArgs, options::OPT_e);
7671
Daniel Dunbar54423b22010-09-17 00:24:54 +00007672 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007673
7674 if (!Args.hasArg(options::OPT_nostdlib) &&
7675 !Args.hasArg(options::OPT_nodefaultlibs)) {
7676 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7677 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007678 if (UseGCC47)
7679 CmdArgs.push_back("-L/usr/lib/gcc47");
7680 else
7681 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007682
7683 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007684 if (UseGCC47) {
7685 CmdArgs.push_back("-rpath");
7686 CmdArgs.push_back("/usr/lib/gcc47");
7687 } else {
7688 CmdArgs.push_back("-rpath");
7689 CmdArgs.push_back("/usr/lib/gcc44");
7690 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007691 }
7692
Hans Wennborg70850d82013-07-18 20:29:38 +00007693 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007694 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007695 CmdArgs.push_back("-lm");
7696 }
7697
Daniel Dunbarcc912342009-05-02 18:28:39 +00007698 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007699 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007700
7701 if (!Args.hasArg(options::OPT_nolibc)) {
7702 CmdArgs.push_back("-lc");
7703 }
7704
John McCall65b8da02013-04-11 22:55:55 +00007705 if (UseGCC47) {
7706 if (Args.hasArg(options::OPT_static) ||
7707 Args.hasArg(options::OPT_static_libgcc)) {
7708 CmdArgs.push_back("-lgcc");
7709 CmdArgs.push_back("-lgcc_eh");
7710 } else {
7711 if (Args.hasArg(options::OPT_shared_libgcc)) {
7712 CmdArgs.push_back("-lgcc_pic");
7713 if (!Args.hasArg(options::OPT_shared))
7714 CmdArgs.push_back("-lgcc");
7715 } else {
7716 CmdArgs.push_back("-lgcc");
7717 CmdArgs.push_back("--as-needed");
7718 CmdArgs.push_back("-lgcc_pic");
7719 CmdArgs.push_back("--no-as-needed");
7720 }
7721 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007722 } else {
John McCall65b8da02013-04-11 22:55:55 +00007723 if (Args.hasArg(options::OPT_shared)) {
7724 CmdArgs.push_back("-lgcc_pic");
7725 } else {
7726 CmdArgs.push_back("-lgcc");
7727 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007728 }
7729 }
7730
7731 if (!Args.hasArg(options::OPT_nostdlib) &&
7732 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007733 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007734 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007735 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007736 else
7737 CmdArgs.push_back(Args.MakeArgString(
7738 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007739 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007740 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007741 }
7742
Alexey Samsonov7811d192014-02-20 13:57:37 +00007743 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007744
Logan Chieneb9162f2014-06-26 14:23:45 +00007745 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007746 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007747}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007748
Alexey Samsonov6424e022014-05-12 20:20:20 +00007749static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7750 ArgStringList &CmdArgs,
7751 const StringRef RTName) {
7752 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7753 llvm::sys::path::append(LibSanitizer,
7754 Twine("clang_rt.") + RTName + ".lib");
7755 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7756}
7757
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007758void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7759 const InputInfo &Output,
7760 const InputInfoList &Inputs,
7761 const ArgList &Args,
7762 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007763 ArgStringList CmdArgs;
7764
7765 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007766 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7767 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007768 } else {
7769 assert(Output.isNothing() && "Invalid output.");
7770 }
7771
7772 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007773 !Args.hasArg(options::OPT_nostartfiles) &&
7774 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007775 CmdArgs.push_back("-defaultlib:libcmt");
7776 }
7777
7778 CmdArgs.push_back("-nologo");
7779
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007780 if (Args.hasArg(options::OPT_g_Group)) {
7781 CmdArgs.push_back("-debug");
7782 }
7783
Hans Wennborgf1a74252013-09-10 20:18:04 +00007784 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7785
7786 if (DLL) {
7787 CmdArgs.push_back(Args.MakeArgString("-dll"));
7788
7789 SmallString<128> ImplibName(Output.getFilename());
7790 llvm::sys::path::replace_extension(ImplibName, "lib");
7791 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7792 ImplibName.str()));
7793 }
7794
Peter Collingbourne32701642013-11-01 18:16:25 +00007795 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007796 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007797 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007798 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007799 if (DLL) {
7800 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7801 "asan_dll_thunk-i386");
7802 } else {
7803 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7804 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7805 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007806 }
7807
Michael J. Spencere2f49362012-06-18 16:56:04 +00007808 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007809 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007810
7811 // Add filenames immediately.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007812 for (const auto &Input : Inputs)
7813 if (Input.isFilename())
7814 CmdArgs.push_back(Input.getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007815 else
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007816 Input.getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007817
7818 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007819 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007820 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7821}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007822
7823void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7824 const InputInfo &Output,
7825 const InputInfoList &Inputs,
7826 const ArgList &Args,
7827 const char *LinkingOutput) const {
7828 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7829}
7830
Hans Wennborg188382e2013-09-20 18:16:35 +00007831// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7832// If one cannot be found, return FallbackName.
7833// We do this special search to prevent clang-cl from falling back onto itself
7834// if it's available as cl.exe on the path.
7835static std::string FindFallback(const char *FallbackName,
7836 const char *ClangProgramPath) {
7837 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7838 if (!OptPath.hasValue())
7839 return FallbackName;
7840
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007841 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Hans Wennborg188382e2013-09-20 18:16:35 +00007842 SmallVector<StringRef, 8> PathSegments;
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007843 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
Hans Wennborg188382e2013-09-20 18:16:35 +00007844
7845 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7846 const StringRef &PathSegment = PathSegments[i];
7847 if (PathSegment.empty())
7848 continue;
7849
7850 SmallString<128> FilePath(PathSegment);
7851 llvm::sys::path::append(FilePath, FallbackName);
7852 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7853 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7854 return FilePath.str();
7855 }
7856
7857 return FallbackName;
7858}
7859
Hans Wennborg87cfa712013-09-19 20:32:16 +00007860Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7861 const InputInfo &Output,
7862 const InputInfoList &Inputs,
7863 const ArgList &Args,
7864 const char *LinkingOutput) const {
7865 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007866 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007867 CmdArgs.push_back("/c"); // Compile only.
7868 CmdArgs.push_back("/W0"); // No warnings.
7869
7870 // The goal is to be able to invoke this tool correctly based on
7871 // any flag accepted by clang-cl.
7872
7873 // These are spelled the same way in clang and cl.exe,.
7874 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7875 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007876
7877 // Optimization level.
7878 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7879 if (A->getOption().getID() == options::OPT_O0) {
7880 CmdArgs.push_back("/Od");
7881 } else {
7882 StringRef OptLevel = A->getValue();
7883 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7884 A->render(Args, CmdArgs);
7885 else if (OptLevel == "3")
7886 CmdArgs.push_back("/Ox");
7887 }
7888 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007889
7890 // Flags for which clang-cl have an alias.
7891 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7892
David Majnemerf6072342014-07-01 22:24:56 +00007893 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
7894 /*default=*/false))
7895 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007896 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7897 options::OPT_fno_function_sections))
7898 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7899 ? "/Gy"
7900 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007901 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7902 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007903 CmdArgs.push_back(
7904 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007905 if (Args.hasArg(options::OPT_fsyntax_only))
7906 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007907 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7908 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007909
Hans Wennborg260ff402013-09-27 17:54:18 +00007910 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007911 for (const auto &Include : Includes)
7912 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007913
Hans Wennborg87cfa712013-09-19 20:32:16 +00007914 // Flags that can simply be passed through.
7915 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7916 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00007917 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007918
7919 // The order of these flags is relevant, so pick the last one.
7920 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7921 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7922 A->render(Args, CmdArgs);
7923
7924
7925 // Input filename.
7926 assert(Inputs.size() == 1);
7927 const InputInfo &II = Inputs[0];
7928 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7929 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7930 if (II.isFilename())
7931 CmdArgs.push_back(II.getFilename());
7932 else
7933 II.getInputArg().renderAsInput(Args, CmdArgs);
7934
7935 // Output filename.
7936 assert(Output.getType() == types::TY_Object);
7937 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7938 Output.getFilename());
7939 CmdArgs.push_back(Fo);
7940
Hans Wennborg188382e2013-09-20 18:16:35 +00007941 const Driver &D = getToolChain().getDriver();
7942 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg188382e2013-09-20 18:16:35 +00007943 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007944}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007945
7946
7947/// XCore Tools
7948// We pass assemble and link construction to the xcc tool.
7949
7950void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7951 const InputInfo &Output,
7952 const InputInfoList &Inputs,
7953 const ArgList &Args,
7954 const char *LinkingOutput) const {
7955 ArgStringList CmdArgs;
7956
7957 CmdArgs.push_back("-o");
7958 CmdArgs.push_back(Output.getFilename());
7959
7960 CmdArgs.push_back("-c");
7961
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007962 if (Args.hasArg(options::OPT_v))
7963 CmdArgs.push_back("-v");
7964
Robert Lytton894d25c2014-05-02 09:33:25 +00007965 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7966 if (!A->getOption().matches(options::OPT_g0))
7967 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007968
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007969 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7970 false))
7971 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007972
7973 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7974 options::OPT_Xassembler);
7975
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007976 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007977 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007978
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007979 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007980 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7981}
7982
7983void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7984 const InputInfo &Output,
7985 const InputInfoList &Inputs,
7986 const ArgList &Args,
7987 const char *LinkingOutput) const {
7988 ArgStringList CmdArgs;
7989
7990 if (Output.isFilename()) {
7991 CmdArgs.push_back("-o");
7992 CmdArgs.push_back(Output.getFilename());
7993 } else {
7994 assert(Output.isNothing() && "Invalid output.");
7995 }
7996
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007997 if (Args.hasArg(options::OPT_v))
7998 CmdArgs.push_back("-v");
7999
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008000 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
8001 if (EH.ShouldUseExceptionTables)
8002 CmdArgs.push_back("-fexceptions");
8003
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008004 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8005
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008006 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008007 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
8008}