blob: e47db33803af580dfaa01a9ec09ef88e7809f1af [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
Chad Rosiercfbfc582012-04-04 20:51:35 +0000491// Handle -mfpu=.
492//
493// FIXME: Centralize feature selection, defaulting shouldn't be also in the
494// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000495static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
496 const ArgList &Args,
497 std::vector<const char *> &Features) {
498 StringRef FPU = A->getValue();
499 if (FPU == "fp-armv8") {
500 Features.push_back("+fp-armv8");
501 } else if (FPU == "neon-fp-armv8") {
502 Features.push_back("+fp-armv8");
503 Features.push_back("+neon");
504 } else if (FPU == "crypto-neon-fp-armv8") {
505 Features.push_back("+fp-armv8");
506 Features.push_back("+neon");
507 Features.push_back("+crypto");
508 } else if (FPU == "neon") {
509 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000510 } else
511 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
512}
513
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000514// Handle -mhwdiv=.
515static void getARMHWDivFeatures(const Driver &D, const Arg *A,
516 const ArgList &Args,
517 std::vector<const char *> &Features) {
518 StringRef HWDiv = A->getValue();
519 if (HWDiv == "arm") {
520 Features.push_back("+hwdiv-arm");
521 Features.push_back("-hwdiv");
522 } else if (HWDiv == "thumb") {
523 Features.push_back("-hwdiv-arm");
524 Features.push_back("+hwdiv");
525 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
526 Features.push_back("+hwdiv-arm");
527 Features.push_back("+hwdiv");
528 } else if (HWDiv == "none") {
529 Features.push_back("-hwdiv-arm");
530 Features.push_back("-hwdiv");
531 } else
532 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
533}
534
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000535// Handle -mfpu=.
536//
537// FIXME: Centralize feature selection, defaulting shouldn't be also in the
538// frontend target.
539static void getARMFPUFeatures(const Driver &D, const Arg *A,
540 const ArgList &Args,
541 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000542 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000543
544 // Set the target features based on the FPU.
545 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
546 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000547 Features.push_back("-vfp2");
548 Features.push_back("-vfp3");
549 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000550 } else if (FPU == "vfp") {
551 Features.push_back("+vfp2");
552 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000553 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000554 Features.push_back("+vfp3");
555 Features.push_back("+d16");
556 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000557 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000558 Features.push_back("+vfp3");
559 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000560 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
561 Features.push_back("+vfp4");
562 Features.push_back("+d16");
563 Features.push_back("-neon");
564 } else if (FPU == "vfp4" || FPU == "vfpv4") {
565 Features.push_back("+vfp4");
566 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000567 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
568 Features.push_back("+vfp4");
569 Features.push_back("+d16");
570 Features.push_back("+fp-only-sp");
571 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000572 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000573 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000574 Features.push_back("-neon");
575 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000576 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000577 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000578 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000579 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000580 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000581 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000582 Features.push_back("+neon");
583 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000584 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000585 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000586 } else if (FPU == "none") {
587 Features.push_back("-vfp2");
588 Features.push_back("-vfp3");
589 Features.push_back("-vfp4");
590 Features.push_back("-fp-armv8");
591 Features.push_back("-crypto");
592 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000593 } else
594 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
595}
596
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000597// Select the float ABI as determined by -msoft-float, -mhard-float, and
598// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000599StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
600 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000601 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000602 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
603 options::OPT_mhard_float,
604 options::OPT_mfloat_abi_EQ)) {
605 if (A->getOption().matches(options::OPT_msoft_float))
606 FloatABI = "soft";
607 else if (A->getOption().matches(options::OPT_mhard_float))
608 FloatABI = "hard";
609 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000610 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000611 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000612 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000613 << A->getAsString(Args);
614 FloatABI = "soft";
615 }
616 }
617 }
618
619 // If unspecified, choose the default based on the platform.
620 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000621 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000622 case llvm::Triple::Darwin:
623 case llvm::Triple::MacOSX:
624 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000625 // Darwin defaults to "softfp" for v6 and v7.
626 //
627 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000628 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000629 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000630 if (StringRef(ArchName).startswith("v6") ||
631 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 FloatABI = "softfp";
633 else
634 FloatABI = "soft";
635 break;
636 }
637
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000638 // FIXME: this is invalid for WindowsCE
639 case llvm::Triple::Win32:
640 FloatABI = "hard";
641 break;
642
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000643 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000644 switch(Triple.getEnvironment()) {
645 case llvm::Triple::GNUEABIHF:
646 FloatABI = "hard";
647 break;
648 default:
649 // FreeBSD defaults to soft float
650 FloatABI = "soft";
651 break;
652 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000653 break;
654
Daniel Dunbar78485922009-09-10 23:00:09 +0000655 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000656 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000657 case llvm::Triple::GNUEABIHF:
658 FloatABI = "hard";
659 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000660 case llvm::Triple::GNUEABI:
661 FloatABI = "softfp";
662 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000663 case llvm::Triple::EABIHF:
664 FloatABI = "hard";
665 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000666 case llvm::Triple::EABI:
667 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
668 FloatABI = "softfp";
669 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000670 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000671 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000672 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000673 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000674 FloatABI = "softfp";
675 else
676 FloatABI = "soft";
677 break;
678 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000679 default:
680 // Assume "soft", but warn the user we are guessing.
681 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000682 if (Triple.getOS() != llvm::Triple::UnknownOS ||
683 !Triple.isOSBinFormatMachO())
684 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000685 break;
686 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000687 }
688 }
689
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000690 return FloatABI;
691}
692
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000693static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
694 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000695 std::vector<const char *> &Features,
696 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000697 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000698 if (!ForAS) {
699 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
700 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
701 // stripped out by the ARM target. We should probably pass this a new
702 // -target-option, which is handled by the -cc1/-cc1as invocation.
703 //
704 // FIXME2: For consistency, it would be ideal if we set up the target
705 // machine state the same when using the frontend or the assembler. We don't
706 // currently do that for the assembler, we pass the options directly to the
707 // backend and never even instantiate the frontend TargetInfo. If we did,
708 // and used its handleTargetFeatures hook, then we could ensure the
709 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000710
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000711 // Use software floating point operations?
712 if (FloatABI == "soft")
713 Features.push_back("+soft-float");
714
715 // Use software floating point argument passing?
716 if (FloatABI != "hard")
717 Features.push_back("+soft-float-abi");
718 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000719
720 // Honor -mfpu=.
721 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000722 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000723 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
724 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000725
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000726 // Setting -msoft-float effectively disables NEON because of the GCC
727 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000728 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000729 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000730 // Also need to explicitly disable features which imply NEON.
731 Features.push_back("-crypto");
732 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000733
734 // En/disable crc
735 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
736 options::OPT_mnocrc)) {
737 if (A->getOption().matches(options::OPT_mcrc))
738 Features.push_back("+crc");
739 else
740 Features.push_back("-crc");
741 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000742}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000743
744void Clang::AddARMTargetArgs(const ArgList &Args,
745 ArgStringList &CmdArgs,
746 bool KernelOrKext) const {
747 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000748 // Get the effective triple, which takes into account the deployment target.
749 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
750 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000751 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000752
753 // Select the ABI to use.
754 //
755 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000756 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000757 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000758 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000759 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000760 // The backend is hardwired to assume AAPCS for M-class processors, ensure
761 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000762 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000763 (Triple.getOS() == llvm::Triple::UnknownOS &&
764 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000765 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000766 ABIName = "aapcs";
767 } else {
768 ABIName = "apcs-gnu";
769 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000770 } else if (Triple.isOSWindows()) {
771 // FIXME: this is invalid for WindowsCE
772 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000773 } else {
774 // Select the default based on the platform.
775 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000776 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000777 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000778 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000779 ABIName = "aapcs-linux";
780 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000781 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000782 case llvm::Triple::EABI:
783 ABIName = "aapcs";
784 break;
785 default:
786 ABIName = "apcs-gnu";
787 }
788 }
789 CmdArgs.push_back("-target-abi");
790 CmdArgs.push_back(ABIName);
791
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000792 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000793 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000794 if (FloatABI == "soft") {
795 // Floating point operations and argument passing are soft.
796 //
797 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000798 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000799 CmdArgs.push_back("-mfloat-abi");
800 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000801 } else if (FloatABI == "softfp") {
802 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000803 CmdArgs.push_back("-mfloat-abi");
804 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000805 } else {
806 // Floating point operations and argument passing are hard.
807 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000808 CmdArgs.push_back("-mfloat-abi");
809 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000810 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000811
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000812 // Kernel code has more strict alignment requirements.
813 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000814 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000815 CmdArgs.push_back("-backend-option");
816 CmdArgs.push_back("-arm-long-calls");
817 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000818
Daniel Dunbar12100e22011-03-22 16:48:17 +0000819 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000820 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000821
822 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000823 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000824 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000825 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000826
827 // Setting -mno-global-merge disables the codegen global merge pass. Setting
828 // -mglobal-merge has no effect as the pass is enabled by default.
829 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
830 options::OPT_mno_global_merge)) {
831 if (A->getOption().matches(options::OPT_mno_global_merge))
832 CmdArgs.push_back("-mno-global-merge");
833 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000834
Bob Wilson9c8af452013-04-11 18:53:25 +0000835 if (!Args.hasFlag(options::OPT_mimplicit_float,
836 options::OPT_mno_implicit_float,
837 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000838 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000839
Logan Chien749763e2014-04-03 13:12:44 +0000840 // llvm does not support reserving registers in general. There is support
841 // for reserving r9 on ARM though (defined as a platform-specific register
842 // in ARM EABI).
843 if (Args.hasArg(options::OPT_ffixed_r9)) {
844 CmdArgs.push_back("-backend-option");
845 CmdArgs.push_back("-arm-reserve-r9");
846 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000847}
848
Tim Northover573cbee2014-05-24 12:52:07 +0000849/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
850/// targeting.
851static std::string getAArch64TargetCPU(const ArgList &Args) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000852 // If we have -mcpu=, use that.
853 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
854 StringRef MCPU = A->getValue();
855 // Handle -mcpu=native.
856 if (MCPU == "native")
857 return llvm::sys::getHostCPUName();
858 else
859 return MCPU;
860 }
861
862 // At some point, we may need to check -march here, but for now we only
863 // one arm64 architecture.
864
James Molloy9b1586b2014-04-17 12:51:17 +0000865 // Make sure we pick "cyclone" if -arch is used.
866 // FIXME: Should this be picked by checking the target triple instead?
867 if (Args.getLastArg(options::OPT_arch))
868 return "cyclone";
869
870 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000871}
872
Tim Northover573cbee2014-05-24 12:52:07 +0000873void Clang::AddAArch64TargetArgs(const ArgList &Args,
874 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000875 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
876 llvm::Triple Triple(TripleStr);
877
878 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
879 Args.hasArg(options::OPT_mkernel) ||
880 Args.hasArg(options::OPT_fapple_kext))
881 CmdArgs.push_back("-disable-red-zone");
882
883 if (!Args.hasFlag(options::OPT_mimplicit_float,
884 options::OPT_mno_implicit_float, true))
885 CmdArgs.push_back("-no-implicit-float");
886
Craig Topper92fc2df2014-05-17 16:56:41 +0000887 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000888 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
889 ABIName = A->getValue();
890 else if (Triple.isOSDarwin())
891 ABIName = "darwinpcs";
892 else
893 ABIName = "aapcs";
894
895 CmdArgs.push_back("-target-abi");
896 CmdArgs.push_back(ABIName);
897
898 CmdArgs.push_back("-target-cpu");
Tim Northover573cbee2014-05-24 12:52:07 +0000899 CmdArgs.push_back(Args.MakeArgString(getAArch64TargetCPU(Args)));
Tim Northovera2ee4332014-03-29 15:09:45 +0000900
901 if (Args.hasArg(options::OPT_mstrict_align)) {
902 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +0000903 CmdArgs.push_back("-aarch64-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000904 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000905
906 // Setting -mno-global-merge disables the codegen global merge pass. Setting
907 // -mglobal-merge has no effect as the pass is enabled by default.
908 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
909 options::OPT_mno_global_merge)) {
910 if (A->getOption().matches(options::OPT_mno_global_merge))
911 CmdArgs.push_back("-mno-global-merge");
912 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000913}
914
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000915// Get CPU and ABI names. They are not independent
916// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000917void mips::getMipsCPUAndABI(const ArgList &Args,
918 const llvm::Triple &Triple,
919 StringRef &CPUName,
920 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000921 const char *DefMips32CPU = "mips32r2";
922 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000923
Daniel Sanders2bf13662014-07-10 14:40:57 +0000924 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
925 // default for mips64(el)?-img-linux-gnu.
926 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
927 Triple.getEnvironment() == llvm::Triple::GNU) {
928 DefMips32CPU = "mips32r6";
929 DefMips64CPU = "mips64r6";
930 }
931
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000932 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000933 options::OPT_mcpu_EQ))
934 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000935
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000936 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000937 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000938 // Convert a GNU style Mips ABI name to the name
939 // accepted by LLVM Mips backend.
940 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
941 .Case("32", "o32")
942 .Case("64", "n64")
943 .Default(ABIName);
944 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000945
946 // Setup default CPU and ABI names.
947 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000948 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000949 default:
950 llvm_unreachable("Unexpected triple arch name");
951 case llvm::Triple::mips:
952 case llvm::Triple::mipsel:
953 CPUName = DefMips32CPU;
954 break;
955 case llvm::Triple::mips64:
956 case llvm::Triple::mips64el:
957 CPUName = DefMips64CPU;
958 break;
959 }
960 }
961
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000962 if (ABIName.empty()) {
963 // Deduce ABI name from the target triple.
964 if (Triple.getArch() == llvm::Triple::mips ||
965 Triple.getArch() == llvm::Triple::mipsel)
966 ABIName = "o32";
967 else
968 ABIName = "n64";
969 }
970
971 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000972 // Deduce CPU name from ABI name.
973 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000974 .Cases("o32", "eabi", DefMips32CPU)
975 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000976 .Default("");
977 }
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000978}
979
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000980// Convert ABI name to the GNU tools acceptable variant.
981static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
982 return llvm::StringSwitch<llvm::StringRef>(ABI)
983 .Case("o32", "32")
984 .Case("n64", "64")
985 .Default(ABI);
986}
987
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000988// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
989// and -mfloat-abi=.
990static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000991 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000992 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000993 options::OPT_mhard_float,
994 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000995 if (A->getOption().matches(options::OPT_msoft_float))
996 FloatABI = "soft";
997 else if (A->getOption().matches(options::OPT_mhard_float))
998 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000999 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001000 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001001 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001002 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001003 FloatABI = "hard";
1004 }
1005 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001006 }
1007
1008 // If unspecified, choose the default based on the platform.
1009 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001010 // Assume "hard", because it's a default value used by gcc.
1011 // When we start to recognize specific target MIPS processors,
1012 // we will be able to select the default more correctly.
1013 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001014 }
1015
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001016 return FloatABI;
1017}
1018
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001019static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001020 std::vector<const char *> &Features,
1021 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001022 StringRef FeatureName) {
1023 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001024 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001025 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001026 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001027 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001028 }
1029}
1030
Daniel Sanders379d44b2014-07-16 11:52:23 +00001031static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1032 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001033 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001034 StringRef CPUName;
1035 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001036 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001037 ABIName = getGnuCompatibleMipsABIName(ABIName);
1038
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001039 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001040 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001041 // FIXME: Note, this is a hack. We need to pass the selected float
1042 // mode to the MipsTargetInfoBase to define appropriate macros there.
1043 // Now it is the only method.
1044 Features.push_back("+soft-float");
1045 }
1046
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001047 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001048 StringRef Val = StringRef(A->getValue());
1049 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001050 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001051 else if (Val == "legacy")
1052 Features.push_back("-nan2008");
1053 else
1054 D.Diag(diag::err_drv_unsupported_option_argument)
1055 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001056 }
1057
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001058 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1059 options::OPT_mdouble_float, "single-float");
1060 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1061 "mips16");
1062 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1063 options::OPT_mno_micromips, "micromips");
1064 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1065 "dsp");
1066 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1067 "dspr2");
1068 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1069 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001070
1071 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1072 // pass -mfpxx
1073 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1074 options::OPT_mfp64)) {
1075 if (A->getOption().matches(options::OPT_mfp32))
1076 Features.push_back(Args.MakeArgString("-fp64"));
1077 else if (A->getOption().matches(options::OPT_mfpxx)) {
1078 Features.push_back(Args.MakeArgString("+fpxx"));
1079 Features.push_back(Args.MakeArgString("+nooddspreg"));
1080 } else
1081 Features.push_back(Args.MakeArgString("+fp64"));
1082 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001083 Features.push_back(Args.MakeArgString("+fpxx"));
1084 Features.push_back(Args.MakeArgString("+nooddspreg"));
1085 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001086
Daniel Sanders28e5d392014-07-10 10:39:51 +00001087 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1088 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001089}
1090
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001091void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001092 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001093 const Driver &D = getToolChain().getDriver();
1094 StringRef CPUName;
1095 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001096 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001097 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001098
1099 CmdArgs.push_back("-target-abi");
1100 CmdArgs.push_back(ABIName.data());
1101
1102 StringRef FloatABI = getMipsFloatABI(D, Args);
1103
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001104 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001105 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001106 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001107 CmdArgs.push_back("-mfloat-abi");
1108 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001109 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001110 else {
1111 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001112 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001113 CmdArgs.push_back("-mfloat-abi");
1114 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001115 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001116
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001117 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1118 if (A->getOption().matches(options::OPT_mxgot)) {
1119 CmdArgs.push_back("-mllvm");
1120 CmdArgs.push_back("-mxgot");
1121 }
1122 }
1123
Simon Atanasyanc580b322013-05-11 06:33:44 +00001124 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1125 options::OPT_mno_ldc1_sdc1)) {
1126 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1127 CmdArgs.push_back("-mllvm");
1128 CmdArgs.push_back("-mno-ldc1-sdc1");
1129 }
1130 }
1131
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001132 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1133 options::OPT_mno_check_zero_division)) {
1134 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1135 CmdArgs.push_back("-mllvm");
1136 CmdArgs.push_back("-mno-check-zero-division");
1137 }
1138 }
1139
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001140 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001141 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001142 CmdArgs.push_back("-mllvm");
1143 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1144 A->claim();
1145 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001146}
1147
Hal Finkel8eb59282012-06-11 22:35:19 +00001148/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1149static std::string getPPCTargetCPU(const ArgList &Args) {
1150 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001151 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001152
1153 if (CPUName == "native") {
1154 std::string CPU = llvm::sys::getHostCPUName();
1155 if (!CPU.empty() && CPU != "generic")
1156 return CPU;
1157 else
1158 return "";
1159 }
1160
1161 return llvm::StringSwitch<const char *>(CPUName)
1162 .Case("common", "generic")
1163 .Case("440", "440")
1164 .Case("440fp", "440")
1165 .Case("450", "450")
1166 .Case("601", "601")
1167 .Case("602", "602")
1168 .Case("603", "603")
1169 .Case("603e", "603e")
1170 .Case("603ev", "603ev")
1171 .Case("604", "604")
1172 .Case("604e", "604e")
1173 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001174 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001175 .Case("G3", "g3")
1176 .Case("7400", "7400")
1177 .Case("G4", "g4")
1178 .Case("7450", "7450")
1179 .Case("G4+", "g4+")
1180 .Case("750", "750")
1181 .Case("970", "970")
1182 .Case("G5", "g5")
1183 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001184 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001185 .Case("e500mc", "e500mc")
1186 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001187 .Case("power3", "pwr3")
1188 .Case("power4", "pwr4")
1189 .Case("power5", "pwr5")
1190 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001191 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001192 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001193 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001194 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001195 .Case("pwr3", "pwr3")
1196 .Case("pwr4", "pwr4")
1197 .Case("pwr5", "pwr5")
1198 .Case("pwr5x", "pwr5x")
1199 .Case("pwr6", "pwr6")
1200 .Case("pwr6x", "pwr6x")
1201 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001202 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001203 .Case("powerpc", "ppc")
1204 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001205 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001206 .Default("");
1207 }
1208
1209 return "";
1210}
1211
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001212static void getPPCTargetFeatures(const ArgList &Args,
1213 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001214 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1215 ie = Args.filtered_end();
1216 it != ie; ++it) {
1217 StringRef Name = (*it)->getOption().getName();
1218 (*it)->claim();
1219
1220 // Skip over "-m".
1221 assert(Name.startswith("m") && "Invalid feature name.");
1222 Name = Name.substr(1);
1223
1224 bool IsNegative = Name.startswith("no-");
1225 if (IsNegative)
1226 Name = Name.substr(3);
1227
1228 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1229 // pass the correct option to the backend while calling the frontend
1230 // option the same.
1231 // TODO: Change the LLVM backend option maybe?
1232 if (Name == "mfcrf")
1233 Name = "mfocrf";
1234
1235 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1236 }
1237
1238 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001239 AddTargetFeature(Args, Features, options::OPT_faltivec,
1240 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001241}
1242
Tom Stellard6674c702013-04-01 20:56:53 +00001243/// Get the (LLVM) name of the R600 gpu we are targeting.
1244static std::string getR600TargetGPU(const ArgList &Args) {
1245 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001246 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001247 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001248 .Cases("rv630", "rv635", "r600")
1249 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001250 .Case("rv740", "rv770")
1251 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001252 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001253 .Case("hemlock", "cypress")
1254 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001255 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001256 }
1257 return "";
1258}
1259
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001260static void getSparcTargetFeatures(const ArgList &Args,
1261 std::vector<const char *> Features) {
1262 bool SoftFloatABI = true;
1263 if (Arg *A =
1264 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1265 if (A->getOption().matches(options::OPT_mhard_float))
1266 SoftFloatABI = false;
1267 }
1268 if (SoftFloatABI)
1269 Features.push_back("+soft-float");
1270}
1271
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001272void Clang::AddSparcTargetArgs(const ArgList &Args,
1273 ArgStringList &CmdArgs) const {
1274 const Driver &D = getToolChain().getDriver();
1275
Brad Smith10cd0f42014-07-11 20:12:08 +00001276 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001277 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001278 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1279 options::OPT_mhard_float)) {
1280 if (A->getOption().matches(options::OPT_msoft_float))
1281 FloatABI = "soft";
1282 else if (A->getOption().matches(options::OPT_mhard_float))
1283 FloatABI = "hard";
1284 }
1285
1286 // If unspecified, choose the default based on the platform.
1287 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001288 // Assume "soft", but warn the user we are guessing.
1289 FloatABI = "soft";
1290 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001291 }
1292
1293 if (FloatABI == "soft") {
1294 // Floating point operations and argument passing are soft.
1295 //
1296 // FIXME: This changes CPP defines, we need -target-soft-float.
1297 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001298 } else {
1299 assert(FloatABI == "hard" && "Invalid float abi!");
1300 CmdArgs.push_back("-mhard-float");
1301 }
1302}
1303
Richard Sandiford4652d892013-07-19 16:51:51 +00001304static const char *getSystemZTargetCPU(const ArgList &Args) {
1305 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1306 return A->getValue();
1307 return "z10";
1308}
1309
Chandler Carruth953fb082013-01-13 11:46:33 +00001310static const char *getX86TargetCPU(const ArgList &Args,
1311 const llvm::Triple &Triple) {
1312 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001313 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001314 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001315 return "core-avx2";
1316
Chandler Carruth953fb082013-01-13 11:46:33 +00001317 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001318 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001319
1320 // FIXME: Reject attempts to use -march=native unless the target matches
1321 // the host.
1322 //
1323 // FIXME: We should also incorporate the detected target features for use
1324 // with -native.
1325 std::string CPU = llvm::sys::getHostCPUName();
1326 if (!CPU.empty() && CPU != "generic")
1327 return Args.MakeArgString(CPU);
1328 }
1329
1330 // Select the default CPU if none was given (or detection failed).
1331
1332 if (Triple.getArch() != llvm::Triple::x86_64 &&
1333 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001334 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001335
1336 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1337
1338 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001339 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001340 if (Triple.getArchName() == "x86_64h")
1341 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001342 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001343 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001344
Alexey Bataev286d1b92014-01-31 04:07:13 +00001345 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001346 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001347 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001348
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001349 // Everything else goes to x86-64 in 64-bit mode.
1350 if (Is64Bit)
1351 return "x86-64";
1352
1353 switch (Triple.getOS()) {
1354 case llvm::Triple::FreeBSD:
1355 case llvm::Triple::NetBSD:
1356 case llvm::Triple::OpenBSD:
1357 return "i486";
1358 case llvm::Triple::Haiku:
1359 return "i586";
1360 case llvm::Triple::Bitrig:
1361 return "i686";
1362 default:
1363 // Fallback to p4.
1364 return "pentium4";
1365 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001366}
1367
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001368static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1369 switch(T.getArch()) {
1370 default:
1371 return "";
1372
Amara Emerson703da2e2013-10-31 09:32:33 +00001373 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001374 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001375 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001376 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001377 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001378
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001379 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001380 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001381 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001382 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001383 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001384
1385 case llvm::Triple::mips:
1386 case llvm::Triple::mipsel:
1387 case llvm::Triple::mips64:
1388 case llvm::Triple::mips64el: {
1389 StringRef CPUName;
1390 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001391 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001392 return CPUName;
1393 }
1394
1395 case llvm::Triple::ppc:
1396 case llvm::Triple::ppc64:
1397 case llvm::Triple::ppc64le: {
1398 std::string TargetCPUName = getPPCTargetCPU(Args);
1399 // LLVM may default to generating code for the native CPU,
1400 // but, like gcc, we default to a more generic option for
1401 // each architecture. (except on Darwin)
1402 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1403 if (T.getArch() == llvm::Triple::ppc64)
1404 TargetCPUName = "ppc64";
1405 else if (T.getArch() == llvm::Triple::ppc64le)
1406 TargetCPUName = "ppc64le";
1407 else
1408 TargetCPUName = "ppc";
1409 }
1410 return TargetCPUName;
1411 }
1412
1413 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001414 case llvm::Triple::sparcv9:
1415 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001416 return A->getValue();
1417 return "";
1418
1419 case llvm::Triple::x86:
1420 case llvm::Triple::x86_64:
1421 return getX86TargetCPU(Args, T);
1422
1423 case llvm::Triple::hexagon:
1424 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1425
1426 case llvm::Triple::systemz:
1427 return getSystemZTargetCPU(Args);
1428
1429 case llvm::Triple::r600:
1430 return getR600TargetGPU(Args);
1431 }
1432}
1433
Alp Tokerce365ca2013-12-02 12:43:03 +00001434static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1435 ArgStringList &CmdArgs) {
1436 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1437 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1438 // forward.
1439 CmdArgs.push_back("-plugin");
1440 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1441 CmdArgs.push_back(Args.MakeArgString(Plugin));
1442
1443 // Try to pass driver level flags relevant to LTO code generation down to
1444 // the plugin.
1445
1446 // Handle flags for selecting CPU variants.
1447 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1448 if (!CPU.empty())
1449 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1450}
1451
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001452static void getX86TargetFeatures(const Driver & D,
1453 const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001454 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001455 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001456 if (Triple.getArchName() == "x86_64h") {
1457 // x86_64h implies quite a few of the more modern subtarget features
1458 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1459 Features.push_back("-rdrnd");
1460 Features.push_back("-aes");
1461 Features.push_back("-pclmul");
1462 Features.push_back("-rtm");
1463 Features.push_back("-hle");
1464 Features.push_back("-fsgsbase");
1465 }
1466
Alexey Volkov54ff0802014-06-25 12:15:36 +00001467 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001468 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001469 if (Triple.getArch() == llvm::Triple::x86_64) {
1470 Features.push_back("+sse4.2");
1471 Features.push_back("+popcnt");
1472 } else
1473 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001474 }
1475
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001476 // Set features according to the -arch flag on MSVC
1477 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1478 StringRef Arch = A->getValue();
1479 bool ArchUsed = false;
1480 // First, look for flags that are shared in x86 and x86-64.
1481 if (Triple.getArch() == llvm::Triple::x86_64 ||
1482 Triple.getArch() == llvm::Triple::x86) {
1483 if (Arch == "AVX" || Arch == "AVX2") {
1484 ArchUsed = true;
1485 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1486 }
1487 }
1488 // Then, look for x86-specific flags.
1489 if (Triple.getArch() == llvm::Triple::x86) {
1490 if (Arch == "IA32") {
1491 ArchUsed = true;
1492 } else if (Arch == "SSE" || Arch == "SSE2") {
1493 ArchUsed = true;
1494 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1495 }
1496 }
1497 if (!ArchUsed)
1498 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1499 }
1500
Jim Grosbach82eee262013-11-16 00:53:35 +00001501 // Now add any that the user explicitly requested on the command line,
1502 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001503 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1504 ie = Args.filtered_end();
1505 it != ie; ++it) {
1506 StringRef Name = (*it)->getOption().getName();
1507 (*it)->claim();
1508
1509 // Skip over "-m".
1510 assert(Name.startswith("m") && "Invalid feature name.");
1511 Name = Name.substr(1);
1512
1513 bool IsNegative = Name.startswith("no-");
1514 if (IsNegative)
1515 Name = Name.substr(3);
1516
1517 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1518 }
1519}
1520
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001521void Clang::AddX86TargetArgs(const ArgList &Args,
1522 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001523 if (!Args.hasFlag(options::OPT_mred_zone,
1524 options::OPT_mno_red_zone,
1525 true) ||
1526 Args.hasArg(options::OPT_mkernel) ||
1527 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001528 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001529
Bob Wilson2616e2e2013-02-10 16:01:41 +00001530 // Default to avoid implicit floating-point for kernel/kext code, but allow
1531 // that to be overridden with -mno-soft-float.
1532 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1533 Args.hasArg(options::OPT_fapple_kext));
1534 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1535 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001536 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001537 options::OPT_mno_implicit_float)) {
1538 const Option &O = A->getOption();
1539 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1540 O.matches(options::OPT_msoft_float));
1541 }
1542 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001543 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001544
1545 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1546 StringRef Value = A->getValue();
1547 if (Value == "intel" || Value == "att") {
1548 CmdArgs.push_back("-mllvm");
1549 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1550 } else {
1551 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1552 << A->getOption().getName() << Value;
1553 }
1554 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001555}
1556
Matthew Curtise8f80a12012-12-06 17:49:03 +00001557static inline bool HasPICArg(const ArgList &Args) {
1558 return Args.hasArg(options::OPT_fPIC)
1559 || Args.hasArg(options::OPT_fpic);
1560}
1561
1562static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1563 return Args.getLastArg(options::OPT_G,
1564 options::OPT_G_EQ,
1565 options::OPT_msmall_data_threshold_EQ);
1566}
1567
1568static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1569 std::string value;
1570 if (HasPICArg(Args))
1571 value = "0";
1572 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1573 value = A->getValue();
1574 A->claim();
1575 }
1576 return value;
1577}
1578
Tony Linthicum76329bf2011-12-12 21:14:55 +00001579void Clang::AddHexagonTargetArgs(const ArgList &Args,
1580 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001581 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001582 CmdArgs.push_back("-mqdsp6-compat");
1583 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001584
Matthew Curtise8f80a12012-12-06 17:49:03 +00001585 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1586 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001587 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001588 CmdArgs.push_back(Args.MakeArgString(
1589 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001590 }
1591
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001592 if (!Args.hasArg(options::OPT_fno_short_enums))
1593 CmdArgs.push_back("-fshort-enums");
1594 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1595 CmdArgs.push_back ("-mllvm");
1596 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1597 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001598 CmdArgs.push_back ("-mllvm");
1599 CmdArgs.push_back ("-machine-sink-split=0");
1600}
1601
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001602static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1603 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001604 // Honor -mfpu=.
1605 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001606 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001607 else
1608 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001609
1610 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1611 Features.push_back("-fp-armv8");
1612 Features.push_back("-crypto");
1613 Features.push_back("-neon");
1614 }
Bradley Smith418c5932014-05-02 15:17:51 +00001615
1616 // En/disable crc
1617 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1618 options::OPT_mnocrc)) {
1619 if (A->getOption().matches(options::OPT_mcrc))
1620 Features.push_back("+crc");
1621 else
1622 Features.push_back("-crc");
1623 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001624}
1625
1626static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001627 const ArgList &Args, ArgStringList &CmdArgs,
1628 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001629 std::vector<const char *> Features;
1630 switch (Triple.getArch()) {
1631 default:
1632 break;
1633 case llvm::Triple::mips:
1634 case llvm::Triple::mipsel:
1635 case llvm::Triple::mips64:
1636 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001637 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001638 break;
1639
1640 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001641 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001642 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001643 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001644 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001645 break;
1646
1647 case llvm::Triple::ppc:
1648 case llvm::Triple::ppc64:
1649 case llvm::Triple::ppc64le:
1650 getPPCTargetFeatures(Args, Features);
1651 break;
1652 case llvm::Triple::sparc:
1653 getSparcTargetFeatures(Args, Features);
1654 break;
1655 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001656 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001657 case llvm::Triple::arm64:
1658 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001659 getAArch64TargetFeatures(D, Args, Features);
1660 break;
1661 case llvm::Triple::x86:
1662 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001663 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001664 break;
1665 }
Rafael Espindola43964802013-08-21 17:34:32 +00001666
1667 // Find the last of each feature.
1668 llvm::StringMap<unsigned> LastOpt;
1669 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1670 const char *Name = Features[I];
1671 assert(Name[0] == '-' || Name[0] == '+');
1672 LastOpt[Name + 1] = I;
1673 }
1674
1675 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1676 // If this feature was overridden, ignore it.
1677 const char *Name = Features[I];
1678 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1679 assert(LastI != LastOpt.end());
1680 unsigned Last = LastI->second;
1681 if (Last != I)
1682 continue;
1683
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001684 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001685 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001686 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001687}
1688
Eric Christopher84fbdb42011-08-19 00:30:14 +00001689static bool
John McCall5fb5df92012-06-20 06:18:46 +00001690shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001691 const llvm::Triple &Triple) {
1692 // We use the zero-cost exception tables for Objective-C if the non-fragile
1693 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1694 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001695 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001696 return true;
1697
Bob Wilson83e723a2013-12-05 19:38:42 +00001698 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001699 return false;
1700
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001701 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001702 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001703 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001704}
1705
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001706namespace {
1707 struct ExceptionSettings {
1708 bool ExceptionsEnabled;
1709 bool ShouldUseExceptionTables;
1710 ExceptionSettings() : ExceptionsEnabled(false),
1711 ShouldUseExceptionTables(false) {}
1712 };
1713} // end anonymous namespace.
1714
Nico Webere8e53112014-05-11 01:04:02 +00001715// exceptionSettings() exists to share the logic between -cc1 and linker
1716// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001717static ExceptionSettings exceptionSettings(const ArgList &Args,
1718 const llvm::Triple &Triple) {
1719 ExceptionSettings ES;
1720
1721 // Are exceptions enabled by default?
1722 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1723
1724 // This keeps track of whether exceptions were explicitly turned on or off.
1725 bool DidHaveExplicitExceptionFlag = false;
1726
1727 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1728 options::OPT_fno_exceptions)) {
1729 if (A->getOption().matches(options::OPT_fexceptions))
1730 ES.ExceptionsEnabled = true;
1731 else
1732 ES.ExceptionsEnabled = false;
1733
1734 DidHaveExplicitExceptionFlag = true;
1735 }
1736
1737 // Exception tables and cleanups can be enabled with -fexceptions even if the
1738 // language itself doesn't support exceptions.
1739 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1740 ES.ShouldUseExceptionTables = true;
1741
1742 return ES;
1743}
1744
Anders Carlssone96ab552011-02-28 02:27:16 +00001745/// addExceptionArgs - Adds exception related arguments to the driver command
1746/// arguments. There's a master flag, -fexceptions and also language specific
1747/// flags to enable/disable C++ and Objective-C exceptions.
1748/// This makes it possible to for example disable C++ exceptions but enable
1749/// Objective-C exceptions.
1750static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1751 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001752 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001753 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001754 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001755 if (KernelOrKext) {
1756 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1757 // arguments now to avoid warnings about unused arguments.
1758 Args.ClaimAllArgs(options::OPT_fexceptions);
1759 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1760 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1761 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1762 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1763 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001764 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001765 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001766
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001767 // Gather the exception settings from the command line arguments.
1768 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001769
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001770 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1771 // is not necessarily sensible, but follows GCC.
1772 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001773 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001774 options::OPT_fno_objc_exceptions,
1775 true)) {
1776 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001777
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001778 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001779 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001780 }
1781
1782 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001783 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001784
Eric Christopher84fbdb42011-08-19 00:30:14 +00001785 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1786 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001787 options::OPT_fexceptions,
1788 options::OPT_fno_exceptions)) {
1789 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1790 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001791 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001792 CXXExceptionsEnabled = false;
1793 }
1794
1795 if (CXXExceptionsEnabled) {
1796 CmdArgs.push_back("-fcxx-exceptions");
1797
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001798 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001799 }
1800 }
1801
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001802 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001803 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001804}
1805
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001806static bool ShouldDisableAutolink(const ArgList &Args,
1807 const ToolChain &TC) {
1808 bool Default = true;
1809 if (TC.getTriple().isOSDarwin()) {
1810 // The native darwin assembler doesn't support the linker_option directives,
1811 // so we disable them if we think the .s file will be passed to it.
1812 Default = TC.useIntegratedAs();
1813 }
1814 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1815 Default);
1816}
1817
Ted Kremenek62093662013-03-12 17:02:12 +00001818static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1819 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001820 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1821 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001822 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001823 return !UseDwarfDirectory;
1824}
1825
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001826/// \brief Check whether the given input tree contains any compilation actions.
1827static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001828 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001829 return true;
1830
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001831 for (const auto &Act : *A)
1832 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001833 return true;
1834
1835 return false;
1836}
1837
1838/// \brief Check if -relax-all should be passed to the internal assembler.
1839/// This is done by default when compiling non-assembler source with -O0.
1840static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1841 bool RelaxDefault = true;
1842
1843 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1844 RelaxDefault = A->getOption().matches(options::OPT_O0);
1845
1846 if (RelaxDefault) {
1847 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001848 for (const auto &Act : C.getActions()) {
1849 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001850 RelaxDefault = true;
1851 break;
1852 }
1853 }
1854 }
1855
1856 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1857 RelaxDefault);
1858}
1859
David Blaikie9260ed62013-07-25 21:19:01 +00001860static void CollectArgsForIntegratedAssembler(Compilation &C,
1861 const ArgList &Args,
1862 ArgStringList &CmdArgs,
1863 const Driver &D) {
1864 if (UseRelaxAll(C, Args))
1865 CmdArgs.push_back("-mrelax-all");
1866
David Peixottodfb66142013-11-14 22:52:58 +00001867 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001868 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001869 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1870 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1871 // arg after parsing the '-I' arg.
1872 bool TakeNextArg = false;
1873
David Blaikie9260ed62013-07-25 21:19:01 +00001874 // When using an integrated assembler, translate -Wa, and -Xassembler
1875 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001876 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001877 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1878 options::OPT_Xassembler),
1879 ie = Args.filtered_end(); it != ie; ++it) {
1880 const Arg *A = *it;
1881 A->claim();
1882
1883 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1884 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001885 if (TakeNextArg) {
1886 CmdArgs.push_back(Value.data());
1887 TakeNextArg = false;
1888 continue;
1889 }
David Blaikie9260ed62013-07-25 21:19:01 +00001890
1891 if (Value == "-force_cpusubtype_ALL") {
1892 // Do nothing, this is the default and we don't support anything else.
1893 } else if (Value == "-L") {
1894 CmdArgs.push_back("-msave-temp-labels");
1895 } else if (Value == "--fatal-warnings") {
1896 CmdArgs.push_back("-mllvm");
1897 CmdArgs.push_back("-fatal-assembler-warnings");
1898 } else if (Value == "--noexecstack") {
1899 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001900 } else if (Value == "-compress-debug-sections" ||
1901 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001902 CompressDebugSections = true;
1903 } else if (Value == "-nocompress-debug-sections" ||
1904 Value == "--nocompress-debug-sections") {
1905 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001906 } else if (Value.startswith("-I")) {
1907 CmdArgs.push_back(Value.data());
1908 // We need to consume the next argument if the current arg is a plain
1909 // -I. The next arg will be the include directory.
1910 if (Value == "-I")
1911 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00001912 } else if (Value.startswith("-gdwarf-")) {
1913 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00001914 } else {
1915 D.Diag(diag::err_drv_unsupported_option_argument)
1916 << A->getOption().getName() << Value;
1917 }
1918 }
1919 }
David Blaikie24bbfed22014-03-31 23:29:38 +00001920 if (CompressDebugSections) {
1921 if (llvm::zlib::isAvailable())
1922 CmdArgs.push_back("-compress-debug-sections");
1923 else
1924 D.Diag(diag::warn_debug_compression_unavailable);
1925 }
David Blaikie9260ed62013-07-25 21:19:01 +00001926}
1927
Renato Goline807c122014-01-31 11:47:28 +00001928// Until ARM libraries are build separately, we have them all in one library
1929static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001930 if (TC.getArch() == llvm::Triple::arm ||
1931 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00001932 return "arm";
1933 else
1934 return TC.getArchName();
1935}
1936
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001937static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1938 // The runtimes are located in the OS-specific resource directory.
1939 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001940 const llvm::Triple &Triple = TC.getTriple();
1941 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1942 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1943 "freebsd" : TC.getOS();
1944 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001945 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001946}
1947
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001948// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00001949// FIXME: Make sure we can also emit shared objects if they're requested
1950// and available, check for possible errors, etc.
1951static void addClangRTLinux(
1952 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001953 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001954 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
1955 getArchNameForCompilerRTLib(TC) +
1956 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00001957
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001958 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001959 CmdArgs.push_back("-lgcc_s");
1960 if (TC.getDriver().CCCIsCXX())
1961 CmdArgs.push_back("-lgcc_eh");
1962}
1963
Alexey Samsonov7811d192014-02-20 13:57:37 +00001964static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001965 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1966 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1967 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001968 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001969 Args.hasArg(options::OPT_fcreate_profile) ||
1970 Args.hasArg(options::OPT_coverage)))
1971 return;
1972
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001973 // -fprofile-instr-generate requires position-independent code to build with
1974 // shared objects. Link against the right archive.
1975 const char *Lib = "libclang_rt.profile-";
1976 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1977 Args.hasArg(options::OPT_shared))
1978 Lib = "libclang_rt.profile-pic-";
1979
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001980 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1981 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001982 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001983
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00001984 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00001985}
1986
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001987static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
1988 const StringRef Sanitizer,
1989 bool Shared) {
1990 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
1991 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
1992 const char *EnvSuffix =
1993 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001994 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1995 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001996 Twine("libclang_rt.") + Sanitizer + "-" +
1997 getArchNameForCompilerRTLib(TC) + EnvSuffix +
1998 (Shared ? ".so" : ".a"));
1999 return LibSanitizer;
2000}
2001
2002static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
2003 ArgStringList &CmdArgs,
2004 const StringRef Sanitizer,
2005 bool BeforeLibStdCXX,
2006 bool ExportSymbols = true,
2007 bool LinkDeps = true) {
2008 SmallString<128> LibSanitizer =
2009 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00002010
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002011 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
2012 // etc.) so that the linker picks custom versions of the global 'operator
2013 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002014 // strategy of inserting it at the front of the link command. It also
2015 // needs to be forced to end up in the executable, so wrap it in
2016 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00002017 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002018 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00002019 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002020 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00002021
2022 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
2023 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
2024
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002025 if (LinkDeps) {
2026 // Link sanitizer dependencies explicitly
2027 CmdArgs.push_back("-lpthread");
2028 CmdArgs.push_back("-lrt");
2029 CmdArgs.push_back("-lm");
2030 // There's no libdl on FreeBSD.
2031 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2032 CmdArgs.push_back("-ldl");
2033 }
Richard Smithf3e624c2013-03-23 00:30:08 +00002034
2035 // If possible, use a dynamic symbols file to export the symbols from the
2036 // runtime library. If we can't do so, use -export-dynamic instead to export
2037 // all symbols from the binary.
2038 if (ExportSymbols) {
2039 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
2040 CmdArgs.push_back(
2041 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
2042 else
2043 CmdArgs.push_back("-export-dynamic");
2044 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002045}
2046
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002047/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
2048/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002049static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002050 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002051 if (Shared) {
2052 // Link dynamic runtime if necessary.
2053 SmallString<128> LibSanitizer =
2054 getSanitizerRTLibName(TC, "asan", Shared);
2055 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002056 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002057
2058 // Do not link static runtime to DSOs or if compiling for Android.
2059 if (Args.hasArg(options::OPT_shared) ||
2060 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
2061 return;
2062
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002063 if (Shared) {
2064 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
2065 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
2066 /*LinkDeps*/ false);
2067 } else {
2068 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2069 if (IsCXX)
2070 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2071 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002072}
2073
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002074/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2075/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002076static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2077 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002078 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002079 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002080}
2081
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002082/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2083/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002084static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2085 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002086 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002087 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002088}
2089
2090/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2091/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002092static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2093 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002094 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002095 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002096}
2097
Richard Smithe30752c2012-10-09 19:52:38 +00002098/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2099/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002100static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2101 ArgStringList &CmdArgs, bool IsCXX,
2102 bool HasOtherSanitizerRt) {
Alexey Samsonovc6496812014-06-30 20:27:16 +00002103 // Do not link runtime into shared libraries.
2104 if (Args.hasArg(options::OPT_shared))
2105 return;
Richard Smith4244ea92014-06-04 23:28:46 +00002106
Nick Lewycky24921692013-10-19 00:27:23 +00002107 // Need a copy of sanitizer_common. This could come from another sanitizer
2108 // runtime; if we're not including one, include our own copy.
2109 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002110 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002111
Alexey Samsonovc6496812014-06-30 20:27:16 +00002112 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, true);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002113
2114 // Only include the bits of the runtime which need a C++ ABI library if
2115 // we're linking in C++ mode.
2116 if (IsCXX)
Alexey Samsonovc6496812014-06-30 20:27:16 +00002117 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false, true);
Richard Smithe30752c2012-10-09 19:52:38 +00002118}
2119
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002120static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2121 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002122 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002123 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2124}
2125
2126// Should be called before we add C++ ABI library.
2127static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2128 ArgStringList &CmdArgs) {
2129 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2130 const Driver &D = TC.getDriver();
2131 if (Sanitize.needsUbsanRt())
2132 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2133 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2134 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2135 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002136 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002137 if (Sanitize.needsTsanRt())
2138 addTsanRT(TC, Args, CmdArgs);
2139 if (Sanitize.needsMsanRt())
2140 addMsanRT(TC, Args, CmdArgs);
2141 if (Sanitize.needsLsanRt())
2142 addLsanRT(TC, Args, CmdArgs);
2143 if (Sanitize.needsDfsanRt())
2144 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002145}
2146
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002147static bool shouldUseFramePointerForTarget(const ArgList &Args,
2148 const llvm::Triple &Triple) {
2149 switch (Triple.getArch()) {
2150 // Don't use a frame pointer on linux if optimizing for certain targets.
2151 case llvm::Triple::mips64:
2152 case llvm::Triple::mips64el:
2153 case llvm::Triple::mips:
2154 case llvm::Triple::mipsel:
2155 case llvm::Triple::systemz:
2156 case llvm::Triple::x86:
2157 case llvm::Triple::x86_64:
2158 if (Triple.isOSLinux())
2159 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2160 if (!A->getOption().matches(options::OPT_O0))
2161 return false;
2162 return true;
2163 case llvm::Triple::xcore:
2164 return false;
2165 default:
2166 return true;
2167 }
2168}
2169
Rafael Espindola224dd632011-12-14 21:02:23 +00002170static bool shouldUseFramePointer(const ArgList &Args,
2171 const llvm::Triple &Triple) {
2172 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2173 options::OPT_fomit_frame_pointer))
2174 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2175
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002176 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002177}
2178
Eric Christopherb7d97e92013-04-03 01:58:53 +00002179static bool shouldUseLeafFramePointer(const ArgList &Args,
2180 const llvm::Triple &Triple) {
2181 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2182 options::OPT_momit_leaf_frame_pointer))
2183 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2184
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002185 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002186}
2187
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002188/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002189static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002190 SmallString<128> cwd;
2191 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002192 CmdArgs.push_back("-fdebug-compilation-dir");
2193 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002194 }
2195}
2196
Eric Christopherd3804002013-02-22 20:12:52 +00002197static const char *SplitDebugName(const ArgList &Args,
2198 const InputInfoList &Inputs) {
2199 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2200 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2201 SmallString<128> T(FinalOutput->getValue());
2202 llvm::sys::path::replace_extension(T, "dwo");
2203 return Args.MakeArgString(T);
2204 } else {
2205 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002206 SmallString<128> T(
2207 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002208 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2209 llvm::sys::path::replace_extension(F, "dwo");
2210 T += F;
2211 return Args.MakeArgString(F);
2212 }
2213}
2214
2215static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2216 const Tool &T, const JobAction &JA,
2217 const ArgList &Args, const InputInfo &Output,
2218 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002219 ArgStringList ExtractArgs;
2220 ExtractArgs.push_back("--extract-dwo");
2221
2222 ArgStringList StripArgs;
2223 StripArgs.push_back("--strip-dwo");
2224
2225 // Grabbing the output of the earlier compile step.
2226 StripArgs.push_back(Output.getFilename());
2227 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002228 ExtractArgs.push_back(OutFile);
2229
2230 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002231 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002232
2233 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002234 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002235
2236 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002237 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002238}
2239
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002240/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002241/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2242static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002243 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002244 if (A->getOption().matches(options::OPT_O4) ||
2245 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002246 return true;
2247
2248 if (A->getOption().matches(options::OPT_O0))
2249 return false;
2250
2251 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2252
Rafael Espindola91780de2013-08-26 14:05:41 +00002253 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002254 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002255 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002256 return true;
2257
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002258 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002259 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002260 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002261
2262 unsigned OptLevel = 0;
2263 if (S.getAsInteger(10, OptLevel))
2264 return false;
2265
2266 return OptLevel > 1;
2267 }
2268
2269 return false;
2270}
2271
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002272/// Add -x lang to \p CmdArgs for \p Input.
2273static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2274 ArgStringList &CmdArgs) {
2275 // When using -verify-pch, we don't want to provide the type
2276 // 'precompiled-header' if it was inferred from the file extension
2277 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2278 return;
2279
2280 CmdArgs.push_back("-x");
2281 if (Args.hasArg(options::OPT_rewrite_objc))
2282 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2283 else
2284 CmdArgs.push_back(types::getTypeName(Input.getType()));
2285}
2286
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002287static std::string getMSCompatibilityVersion(const char *VersionStr) {
2288 unsigned Version;
2289 if (StringRef(VersionStr).getAsInteger(10, Version))
2290 return "0";
2291
2292 if (Version < 100)
2293 return llvm::utostr_32(Version) + ".0";
2294
2295 if (Version < 10000)
2296 return llvm::utostr_32(Version / 100) + "." +
2297 llvm::utostr_32(Version % 100);
2298
2299 unsigned Build = 0, Factor = 1;
2300 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2301 Build = Build + (Version % 10) * Factor;
2302 return llvm::utostr_32(Version / 100) + "." +
2303 llvm::utostr_32(Version % 100) + "." +
2304 llvm::utostr_32(Build);
2305}
2306
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002307void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002308 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002309 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002310 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002311 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002312 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2313 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002314 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002315 ArgStringList CmdArgs;
2316
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002317 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002318 bool IsWindowsCygnus =
2319 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002320 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2321
Daniel Dunbare521a892009-03-31 20:53:55 +00002322 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2323
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002324 // Invoke ourselves in -cc1 mode.
2325 //
2326 // FIXME: Implement custom jobs for internal actions.
2327 CmdArgs.push_back("-cc1");
2328
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002329 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002330 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002331 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002332 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002333
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002334 const llvm::Triple TT(TripleStr);
2335 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2336 TT.getArch() == llvm::Triple::thumb)) {
2337 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2338 unsigned Version;
2339 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2340 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002341 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2342 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002343 }
2344
Tim Northover336f1892014-03-29 13:16:12 +00002345 // Push all default warning arguments that are specific to
2346 // the given target. These come before user provided warning options
2347 // are provided.
2348 getToolChain().addClangWarningOptions(CmdArgs);
2349
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002350 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002351 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002352
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002353 if (isa<AnalyzeJobAction>(JA)) {
2354 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2355 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002356 } else if (isa<MigrateJobAction>(JA)) {
2357 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002358 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002359 if (Output.getType() == types::TY_Dependencies)
2360 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002361 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002362 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002363 if (Args.hasArg(options::OPT_rewrite_objc) &&
2364 !Args.hasArg(options::OPT_g_Group))
2365 CmdArgs.push_back("-P");
2366 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002367 } else if (isa<AssembleJobAction>(JA)) {
2368 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002369
David Blaikie9260ed62013-07-25 21:19:01 +00002370 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002371
2372 // Also ignore explicit -force_cpusubtype_ALL option.
2373 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002374 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002375 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002376 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002377
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002378 if (JA.getType() == types::TY_Nothing)
2379 CmdArgs.push_back("-fsyntax-only");
2380 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002381 CmdArgs.push_back("-emit-pch");
2382 else
2383 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002384 } else if (isa<VerifyPCHJobAction>(JA)) {
2385 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002386 } else {
2387 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002388
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002389 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002390 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002391 } else if (JA.getType() == types::TY_LLVM_IR ||
2392 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002393 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002394 } else if (JA.getType() == types::TY_LLVM_BC ||
2395 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002396 CmdArgs.push_back("-emit-llvm-bc");
2397 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002398 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002399 } else if (JA.getType() == types::TY_AST) {
2400 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002401 } else if (JA.getType() == types::TY_ModuleFile) {
2402 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002403 } else if (JA.getType() == types::TY_RewrittenObjC) {
2404 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002405 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002406 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2407 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002408 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002409 } else {
2410 assert(JA.getType() == types::TY_PP_Asm &&
2411 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002412 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002413 }
2414
Justin Bognera88f0122014-06-20 22:59:50 +00002415 // We normally speed up the clang process a bit by skipping destructors at
2416 // exit, but when we're generating diagnostics we can rely on some of the
2417 // cleanup.
2418 if (!C.isForDiagnostics())
2419 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002420
John McCallbb79b5f2010-02-13 03:50:24 +00002421 // Disable the verification pass in -asserts builds.
2422#ifdef NDEBUG
2423 CmdArgs.push_back("-disable-llvm-verifier");
2424#endif
2425
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002426 // Set the main file name, so that debug info works even with
2427 // -save-temps.
2428 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002429 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002430
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002431 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002432 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002433 if (Args.hasArg(options::OPT_static))
2434 CmdArgs.push_back("-static-define");
2435
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002436 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002437 // Enable region store model by default.
2438 CmdArgs.push_back("-analyzer-store=region");
2439
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002440 // Treat blocks as analysis entry points.
2441 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2442
Ted Kremenek49c79792011-03-24 00:28:47 +00002443 CmdArgs.push_back("-analyzer-eagerly-assume");
2444
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002445 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002446 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002447 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002448
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002449 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002450 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002451
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002452 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002453 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002454
2455 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002456
Jordan Rose10ad0812013-04-05 17:55:07 +00002457 if (types::isCXX(Inputs[0].getType()))
2458 CmdArgs.push_back("-analyzer-checker=cplusplus");
2459
Nico Webere8e53112014-05-11 01:04:02 +00002460 // Enable the following experimental checkers for testing.
2461 CmdArgs.push_back(
2462 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002463 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2464 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2465 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2466 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2467 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002468 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002469
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002470 // Set the output format. The default is plist, for (lame) historical
2471 // reasons.
2472 CmdArgs.push_back("-analyzer-output");
2473 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002474 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002475 else
2476 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002477
Ted Kremenekfe449a22010-03-22 22:32:05 +00002478 // Disable the presentation of standard compiler warnings when
2479 // using --analyze. We only want to show static analyzer diagnostics
2480 // or frontend errors.
2481 CmdArgs.push_back("-w");
2482
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002483 // Add -Xanalyzer arguments when running as analyzer.
2484 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002485 }
2486
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002487 CheckCodeGenerationOptions(D, Args);
2488
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002489 bool PIE = getToolChain().isPIEDefault();
2490 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002491 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002492
Alexey Bataev40e75222014-01-28 06:30:35 +00002493 // Android-specific defaults for PIC/PIE
2494 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2495 switch (getToolChain().getTriple().getArch()) {
2496 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002497 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002498 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002499 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002500 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002501 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002502 case llvm::Triple::mips:
2503 case llvm::Triple::mipsel:
2504 case llvm::Triple::mips64:
2505 case llvm::Triple::mips64el:
2506 PIC = true; // "-fpic"
2507 break;
2508
2509 case llvm::Triple::x86:
2510 case llvm::Triple::x86_64:
2511 PIC = true; // "-fPIC"
2512 IsPICLevelTwo = true;
2513 break;
2514
2515 default:
2516 break;
2517 }
2518 }
2519
Brad Smith5b05db82014-06-24 19:51:29 +00002520 // OpenBSD-specific defaults for PIE
2521 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2522 switch (getToolChain().getTriple().getArch()) {
2523 case llvm::Triple::mips64:
2524 case llvm::Triple::mips64el:
2525 case llvm::Triple::sparc:
2526 case llvm::Triple::x86:
2527 case llvm::Triple::x86_64:
2528 IsPICLevelTwo = false; // "-fpie"
2529 break;
2530
2531 case llvm::Triple::ppc:
2532 case llvm::Triple::sparcv9:
2533 IsPICLevelTwo = true; // "-fPIE"
2534 break;
2535
2536 default:
2537 break;
2538 }
2539 }
2540
Alexey Samsonov090301e2013-04-09 12:28:19 +00002541 // For the PIC and PIE flag options, this logic is different from the
2542 // legacy logic in very old versions of GCC, as that logic was just
2543 // a bug no one had ever fixed. This logic is both more rational and
2544 // consistent with GCC's new logic now that the bugs are fixed. The last
2545 // argument relating to either PIC or PIE wins, and no other argument is
2546 // used. If the last argument is any flavor of the '-fno-...' arguments,
2547 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2548 // at the same level.
2549 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2550 options::OPT_fpic, options::OPT_fno_pic,
2551 options::OPT_fPIE, options::OPT_fno_PIE,
2552 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002553 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2554 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002555 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002556 if (LastPICArg) {
2557 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002558 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2559 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2560 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2561 PIC = PIE || O.matches(options::OPT_fPIC) ||
2562 O.matches(options::OPT_fpic);
2563 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2564 O.matches(options::OPT_fPIC);
2565 } else {
2566 PIE = PIC = false;
2567 }
2568 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002569 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002570
Nick Lewycky609dd662013-10-11 03:33:53 +00002571 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002572 // specified while enabling PIC enabled level 1 PIC, just force it back to
2573 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2574 // informal testing).
2575 if (PIC && getToolChain().getTriple().isOSDarwin())
2576 IsPICLevelTwo |= getToolChain().isPICDefault();
2577
Chandler Carruthc0c04552012-04-08 16:40:35 +00002578 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2579 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002580 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002581 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002582 Triple.getArch() == llvm::Triple::arm64 ||
2583 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002584 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002585 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002586 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002587
Chandler Carruth76a943b2012-11-19 03:52:03 +00002588 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2589 // This is a very special mode. It trumps the other modes, almost no one
2590 // uses it, and it isn't even valid on any OS but Darwin.
2591 if (!getToolChain().getTriple().isOSDarwin())
2592 D.Diag(diag::err_drv_unsupported_opt_for_target)
2593 << A->getSpelling() << getToolChain().getTriple().str();
2594
2595 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2596
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002597 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002598 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002599
Chandler Carruth76a943b2012-11-19 03:52:03 +00002600 // Only a forced PIC mode can cause the actual compile to have PIC defines
2601 // etc., no flags are sufficient. This behavior was selected to closely
2602 // match that of llvm-gcc and Apple GCC before that.
2603 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2604 CmdArgs.push_back("-pic-level");
2605 CmdArgs.push_back("2");
2606 }
2607 } else {
2608 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2609 // handled in Clang's IRGen by the -pie-level flag.
2610 CmdArgs.push_back("-mrelocation-model");
2611 CmdArgs.push_back(PIC ? "pic" : "static");
2612
2613 if (PIC) {
2614 CmdArgs.push_back("-pic-level");
2615 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2616 if (PIE) {
2617 CmdArgs.push_back("-pie-level");
2618 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2619 }
2620 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002621 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002622
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002623 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2624 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002625 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002626
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002627 // LLVM Code Generator Options.
2628
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002629 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2630 StringRef v = A->getValue();
2631 CmdArgs.push_back("-mllvm");
2632 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2633 A->claim();
2634 }
2635
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002636 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2637 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002638 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002639 }
2640
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002641 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2642 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002643 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002644 D.Diag(diag::err_drv_unsupported_opt_for_target)
2645 << A->getSpelling() << getToolChain().getTriple().str();
2646 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2647 CmdArgs.push_back("-fpcc-struct-return");
2648 } else {
2649 assert(A->getOption().matches(options::OPT_freg_struct_return));
2650 CmdArgs.push_back("-freg-struct-return");
2651 }
2652 }
2653
Roman Divacky65b88cd2011-03-01 17:40:53 +00002654 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2655 CmdArgs.push_back("-mrtd");
2656
Rafael Espindola224dd632011-12-14 21:02:23 +00002657 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002658 CmdArgs.push_back("-mdisable-fp-elim");
2659 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2660 options::OPT_fno_zero_initialized_in_bss))
2661 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002662
2663 bool OFastEnabled = isOptimizationLevelFast(Args);
2664 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2665 // enabled. This alias option is being used to simplify the hasFlag logic.
2666 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2667 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002668 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2669 // doesn't do any TBAA.
2670 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002671 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002672 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002673 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002674 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2675 options::OPT_fno_struct_path_tbaa))
2676 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002677 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2678 false))
2679 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002680 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2681 options::OPT_fno_optimize_sibling_calls))
2682 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002683
Eric Christopher006208c2013-04-04 06:29:47 +00002684 // Handle segmented stacks.
2685 if (Args.hasArg(options::OPT_fsplit_stack))
2686 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002687
2688 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2689 // This alias option is being used to simplify the getLastArg logic.
2690 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2691 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002692
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002693 // Handle various floating point optimization flags, mapping them to the
2694 // appropriate LLVM code generation flags. The pattern for all of these is to
2695 // default off the codegen optimizations, and if any flag enables them and no
2696 // flag disables them after the flag enabling them, enable the codegen
2697 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002698 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002699 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002700 options::OPT_ffinite_math_only,
2701 options::OPT_fno_finite_math_only,
2702 options::OPT_fhonor_infinities,
2703 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002704 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2705 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002706 A->getOption().getID() != options::OPT_fhonor_infinities)
2707 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002708 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002709 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002710 options::OPT_ffinite_math_only,
2711 options::OPT_fno_finite_math_only,
2712 options::OPT_fhonor_nans,
2713 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002714 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2715 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002716 A->getOption().getID() != options::OPT_fhonor_nans)
2717 CmdArgs.push_back("-menable-no-nans");
2718
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002719 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2720 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002721 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002722 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002723 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002724 options::OPT_fno_math_errno)) {
2725 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2726 // However, turning *off* -ffast_math merely restores the toolchain default
2727 // (which may be false).
2728 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2729 A->getOption().getID() == options::OPT_ffast_math ||
2730 A->getOption().getID() == options::OPT_Ofast)
2731 MathErrno = false;
2732 else if (A->getOption().getID() == options::OPT_fmath_errno)
2733 MathErrno = true;
2734 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002735 if (MathErrno)
2736 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002737
2738 // There are several flags which require disabling very specific
2739 // optimizations. Any of these being disabled forces us to turn off the
2740 // entire set of LLVM optimizations, so collect them through all the flag
2741 // madness.
2742 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002743 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002744 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002745 options::OPT_funsafe_math_optimizations,
2746 options::OPT_fno_unsafe_math_optimizations,
2747 options::OPT_fassociative_math,
2748 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002749 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2750 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002751 A->getOption().getID() != options::OPT_fno_associative_math)
2752 AssociativeMath = true;
2753 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002754 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002755 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002756 options::OPT_funsafe_math_optimizations,
2757 options::OPT_fno_unsafe_math_optimizations,
2758 options::OPT_freciprocal_math,
2759 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002760 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2761 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002762 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2763 ReciprocalMath = true;
2764 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002765 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002766 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002767 options::OPT_funsafe_math_optimizations,
2768 options::OPT_fno_unsafe_math_optimizations,
2769 options::OPT_fsigned_zeros,
2770 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002771 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2772 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002773 A->getOption().getID() != options::OPT_fsigned_zeros)
2774 SignedZeros = false;
2775 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002776 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002777 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002778 options::OPT_funsafe_math_optimizations,
2779 options::OPT_fno_unsafe_math_optimizations,
2780 options::OPT_ftrapping_math,
2781 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002782 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2783 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002784 A->getOption().getID() != options::OPT_ftrapping_math)
2785 TrappingMath = false;
2786 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2787 !TrappingMath)
2788 CmdArgs.push_back("-menable-unsafe-fp-math");
2789
Lang Hamesaa53b932012-07-06 00:59:19 +00002790
2791 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002792 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002793 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002794 options::OPT_ffp_contract)) {
2795 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002796 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002797 if (Val == "fast" || Val == "on" || Val == "off") {
2798 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2799 } else {
2800 D.Diag(diag::err_drv_unsupported_option_argument)
2801 << A->getOption().getName() << Val;
2802 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002803 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2804 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002805 // If fast-math is set then set the fp-contract mode to fast.
2806 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2807 }
2808 }
2809
Bob Wilson6a039162012-07-19 03:52:53 +00002810 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2811 // and if we find them, tell the frontend to provide the appropriate
2812 // preprocessor macros. This is distinct from enabling any optimizations as
2813 // these options induce language changes which must survive serialization
2814 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002815 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2816 options::OPT_fno_fast_math))
2817 if (!A->getOption().matches(options::OPT_fno_fast_math))
2818 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002819 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2820 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002821 if (A->getOption().matches(options::OPT_ffinite_math_only))
2822 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002823
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002824 // Decide whether to use verbose asm. Verbose assembly is the default on
2825 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002826 bool IsIntegratedAssemblerDefault =
2827 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002828 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002829 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002830 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002831 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002832
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002833 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002834 IsIntegratedAssemblerDefault))
2835 CmdArgs.push_back("-no-integrated-as");
2836
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002837 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2838 CmdArgs.push_back("-mdebug-pass");
2839 CmdArgs.push_back("Structure");
2840 }
2841 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2842 CmdArgs.push_back("-mdebug-pass");
2843 CmdArgs.push_back("Arguments");
2844 }
2845
John McCall8517abc2010-02-19 02:45:38 +00002846 // Enable -mconstructor-aliases except on darwin, where we have to
2847 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002848 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002849 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002850
John McCall7ef5cb32011-03-18 02:56:14 +00002851 // Darwin's kernel doesn't support guard variables; just die if we
2852 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002853 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002854 CmdArgs.push_back("-fforbid-guard-variables");
2855
Douglas Gregordbe39272011-02-01 15:15:22 +00002856 if (Args.hasArg(options::OPT_mms_bitfields)) {
2857 CmdArgs.push_back("-mms-bitfields");
2858 }
John McCall8517abc2010-02-19 02:45:38 +00002859
Daniel Dunbar306945d2009-09-16 06:17:29 +00002860 // This is a coarse approximation of what llvm-gcc actually does, both
2861 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2862 // complicated ways.
2863 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002864 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2865 options::OPT_fno_asynchronous_unwind_tables,
2866 (getToolChain().IsUnwindTablesDefault() ||
2867 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2868 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002869 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2870 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002871 CmdArgs.push_back("-munwind-tables");
2872
Chandler Carruth05fb5852012-11-21 23:40:23 +00002873 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002874
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002875 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2876 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002877 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002878 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002879
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002880 // FIXME: Handle -mtune=.
2881 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002882
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002883 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002884 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002885 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002886 }
2887
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002888 // Add the target cpu
2889 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2890 llvm::Triple ETriple(ETripleStr);
2891 std::string CPU = getCPUName(Args, ETriple);
2892 if (!CPU.empty()) {
2893 CmdArgs.push_back("-target-cpu");
2894 CmdArgs.push_back(Args.MakeArgString(CPU));
2895 }
2896
Rafael Espindolaeb265472013-08-21 21:59:03 +00002897 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2898 CmdArgs.push_back("-mfpmath");
2899 CmdArgs.push_back(A->getValue());
2900 }
2901
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002902 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002903 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002904
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002905 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002906 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002907 default:
2908 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002909
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002910 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002911 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002912 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002913 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002914 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002915 break;
2916
Tim Northover573cbee2014-05-24 12:52:07 +00002917 case llvm::Triple::aarch64:
2918 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002919 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002920 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002921 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002922 break;
2923
Eric Christopher0b26a612010-03-02 02:41:08 +00002924 case llvm::Triple::mips:
2925 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002926 case llvm::Triple::mips64:
2927 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002928 AddMIPSTargetArgs(Args, CmdArgs);
2929 break;
2930
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002931 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00002932 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002933 AddSparcTargetArgs(Args, CmdArgs);
2934 break;
2935
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002936 case llvm::Triple::x86:
2937 case llvm::Triple::x86_64:
2938 AddX86TargetArgs(Args, CmdArgs);
2939 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002940
2941 case llvm::Triple::hexagon:
2942 AddHexagonTargetArgs(Args, CmdArgs);
2943 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002944 }
2945
Hans Wennborg75958c42013-08-08 00:17:41 +00002946 // Add clang-cl arguments.
2947 if (getToolChain().getDriver().IsCLMode())
2948 AddClangCLArgs(Args, CmdArgs);
2949
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002950 // Pass the linker version in use.
2951 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2952 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002953 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002954 }
2955
Eric Christopherb7d97e92013-04-03 01:58:53 +00002956 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002957 CmdArgs.push_back("-momit-leaf-frame-pointer");
2958
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002959 // Explicitly error on some things we know we don't support and can't just
2960 // ignore.
2961 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002962 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2963 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002964 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002965 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002966 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002967 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2968 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002969 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002970 << Unsupported->getOption().getName();
2971 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002972 }
2973
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002974 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002975 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002976 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002977 CmdArgs.push_back("-header-include-file");
2978 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2979 D.CCPrintHeadersFilename : "-");
2980 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002981 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002982 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002983
Chad Rosierbe10f982011-08-02 17:58:04 +00002984 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002985 CmdArgs.push_back("-diagnostic-log-file");
2986 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2987 D.CCLogDiagnosticsFilename : "-");
2988 }
2989
Manman Ren17bdb0f2013-11-20 20:22:14 +00002990 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2991 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002992 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002993 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002994 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002995 // FIXME: we should support specifying dwarf version with
2996 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002997 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00002998 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2999 const llvm::Triple &Triple = getToolChain().getTriple();
3000 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3001 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003002 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003003 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003004 CmdArgs.push_back("-gdwarf-2");
3005 else if (A->getOption().matches(options::OPT_gdwarf_3))
3006 CmdArgs.push_back("-gdwarf-3");
3007 else if (A->getOption().matches(options::OPT_gdwarf_4))
3008 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003009 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003010 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00003011 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
3012 const llvm::Triple &Triple = getToolChain().getTriple();
3013 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3014 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00003015 CmdArgs.push_back("-gdwarf-2");
3016 else
3017 CmdArgs.push_back("-g");
3018 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003019 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003020
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003021 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3022 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003023 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3024 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003025 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003026
Eric Christopher138c32b2013-09-13 22:37:55 +00003027 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003028 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3029 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003030 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003031 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003032 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003033 CmdArgs.push_back("-g");
3034 CmdArgs.push_back("-backend-option");
3035 CmdArgs.push_back("-split-dwarf=Enable");
3036 }
3037
Eric Christopher138c32b2013-09-13 22:37:55 +00003038 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3039 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3040 CmdArgs.push_back("-backend-option");
3041 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3042 }
Eric Christophereec89c22013-06-18 00:03:50 +00003043
Eric Christopher0d403d22014-02-14 01:27:03 +00003044 // -gdwarf-aranges turns on the emission of the aranges section in the
3045 // backend.
3046 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3047 CmdArgs.push_back("-backend-option");
3048 CmdArgs.push_back("-generate-arange-section");
3049 }
3050
David Blaikief36d9ba2014-01-27 18:52:43 +00003051 if (Args.hasFlag(options::OPT_fdebug_types_section,
3052 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003053 CmdArgs.push_back("-backend-option");
3054 CmdArgs.push_back("-generate-type-units");
3055 }
Eric Christophereec89c22013-06-18 00:03:50 +00003056
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003057 if (Args.hasFlag(options::OPT_ffunction_sections,
3058 options::OPT_fno_function_sections, false)) {
3059 CmdArgs.push_back("-ffunction-sections");
3060 }
3061
3062 if (Args.hasFlag(options::OPT_fdata_sections,
3063 options::OPT_fno_data_sections, false)) {
3064 CmdArgs.push_back("-fdata-sections");
3065 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003066
Chris Lattner3c77a352010-06-22 00:03:40 +00003067 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3068
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003069 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3070 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3071 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3072 D.Diag(diag::err_drv_argument_not_allowed_with)
3073 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3074
3075 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3076
3077 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3078 A->render(Args, CmdArgs);
3079 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3080 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3081
Nick Lewycky207bce32011-04-21 23:44:07 +00003082 if (Args.hasArg(options::OPT_ftest_coverage) ||
3083 Args.hasArg(options::OPT_coverage))
3084 CmdArgs.push_back("-femit-coverage-notes");
3085 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3086 Args.hasArg(options::OPT_coverage))
3087 CmdArgs.push_back("-femit-coverage-data");
3088
Nick Lewycky480cb992011-05-04 20:46:58 +00003089 if (C.getArgs().hasArg(options::OPT_c) ||
3090 C.getArgs().hasArg(options::OPT_S)) {
3091 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003092 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00003093 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00003094 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003095 SmallString<128> Pwd;
3096 if (!llvm::sys::fs::current_path(Pwd)) {
3097 llvm::sys::path::append(Pwd, CoverageFilename.str());
3098 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003099 }
3100 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003101 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003102 }
3103 }
3104
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003105 // Pass options for controlling the default header search paths.
3106 if (Args.hasArg(options::OPT_nostdinc)) {
3107 CmdArgs.push_back("-nostdsysteminc");
3108 CmdArgs.push_back("-nobuiltininc");
3109 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003110 if (Args.hasArg(options::OPT_nostdlibinc))
3111 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003112 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3113 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3114 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003115
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003116 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003117 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003118 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003119
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003120 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3121
Ted Kremenekf7639e12012-03-06 20:06:33 +00003122 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003123 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003124 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003125 options::OPT_ccc_arcmt_modify,
3126 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003127 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003128 switch (A->getOption().getID()) {
3129 default:
3130 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003131 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003132 CmdArgs.push_back("-arcmt-check");
3133 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003134 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003135 CmdArgs.push_back("-arcmt-modify");
3136 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003137 case options::OPT_ccc_arcmt_migrate:
3138 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003139 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003140 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003141
3142 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3143 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003144 break;
John McCalld70fb982011-06-15 23:25:17 +00003145 }
3146 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003147 } else {
3148 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3149 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3150 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003151 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003152
Ted Kremenekf7639e12012-03-06 20:06:33 +00003153 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3154 if (ARCMTEnabled) {
3155 D.Diag(diag::err_drv_argument_not_allowed_with)
3156 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3157 }
3158 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003159 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003160
3161 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003162 options::OPT_objcmt_migrate_subscripting,
3163 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003164 // None specified, means enable them all.
3165 CmdArgs.push_back("-objcmt-migrate-literals");
3166 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003167 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003168 } else {
3169 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3170 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003171 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003172 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003173 } else {
3174 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3175 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3176 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3177 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3178 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3179 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3180 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3181 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3182 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3183 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3184 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3185 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3186 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003187 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003188 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003189 }
3190
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003191 // Add preprocessing options like -I, -D, etc. if we are using the
3192 // preprocessor.
3193 //
3194 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003195 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003196 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003197
Rafael Espindolaa7431922011-07-21 23:40:37 +00003198 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3199 // that "The compiler can only warn and ignore the option if not recognized".
3200 // When building with ccache, it will pass -D options to clang even on
3201 // preprocessed inputs and configure concludes that -fPIC is not supported.
3202 Args.ClaimAllArgs(options::OPT_D);
3203
Alp Toker7874bdc2013-11-15 20:40:58 +00003204 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003205 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3206 if (A->getOption().matches(options::OPT_O4)) {
3207 CmdArgs.push_back("-O3");
3208 D.Diag(diag::warn_O4_is_O3);
3209 } else {
3210 A->render(Args, CmdArgs);
3211 }
3212 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003213
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003214 // Warn about ignored options to clang.
3215 for (arg_iterator it = Args.filtered_begin(
3216 options::OPT_clang_ignored_gcc_optimization_f_Group),
3217 ie = Args.filtered_end(); it != ie; ++it) {
3218 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3219 }
3220
Chad Rosier86b82082012-12-12 20:06:31 +00003221 // Don't warn about unused -flto. This can happen when we're preprocessing or
3222 // precompiling.
3223 Args.ClaimAllArgs(options::OPT_flto);
3224
Daniel Dunbar945577c2009-10-29 02:24:45 +00003225 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003226 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3227 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003228 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003229 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003230
3231 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003232 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003233 //
3234 // If a std is supplied, only add -trigraphs if it follows the
3235 // option.
3236 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3237 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003238 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003239 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003240 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003241 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003242 else
3243 Std->render(Args, CmdArgs);
3244
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003245 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3246 options::OPT_trigraphs))
3247 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003248 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003249 } else {
3250 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003251 //
3252 // FIXME: Clang doesn't correctly handle -std= when the input language
3253 // doesn't match. For the time being just ignore this for C++ inputs;
3254 // eventually we want to do all the standard defaulting here instead of
3255 // splitting it between the driver and clang -cc1.
3256 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003257 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3258 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003259 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003260 CmdArgs.push_back("-std=c++11");
3261
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003262 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003263 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003264
Richard Smith282b4492013-09-04 22:50:31 +00003265 // GCC's behavior for -Wwrite-strings is a bit strange:
3266 // * In C, this "warning flag" changes the types of string literals from
3267 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3268 // for the discarded qualifier.
3269 // * In C++, this is just a normal warning flag.
3270 //
3271 // Implementing this warning correctly in C is hard, so we follow GCC's
3272 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3273 // a non-const char* in C, rather than using this crude hack.
3274 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003275 // FIXME: This should behave just like a warning flag, and thus should also
3276 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3277 Arg *WriteStrings =
3278 Args.getLastArg(options::OPT_Wwrite_strings,
3279 options::OPT_Wno_write_strings, options::OPT_w);
3280 if (WriteStrings &&
3281 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003282 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003283 }
3284
Chandler Carruth61fbf622011-04-23 09:27:53 +00003285 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003286 // during C++ compilation, which it is by default. GCC keeps this define even
3287 // in the presence of '-w', match this behavior bug-for-bug.
3288 if (types::isCXX(InputType) &&
3289 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3290 true)) {
3291 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003292 }
3293
Chandler Carruthe0391482010-05-22 02:21:53 +00003294 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3295 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3296 if (Asm->getOption().matches(options::OPT_fasm))
3297 CmdArgs.push_back("-fgnu-keywords");
3298 else
3299 CmdArgs.push_back("-fno-gnu-keywords");
3300 }
3301
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003302 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3303 CmdArgs.push_back("-fno-dwarf-directory-asm");
3304
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003305 if (ShouldDisableAutolink(Args, getToolChain()))
3306 CmdArgs.push_back("-fno-autolink");
3307
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003308 // Add in -fdebug-compilation-dir if necessary.
3309 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003310
Richard Smith9a568822011-11-21 19:36:32 +00003311 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3312 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003313 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003314 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003315 }
3316
Richard Smith79c927b2013-11-06 19:31:51 +00003317 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3318 CmdArgs.push_back("-foperator-arrow-depth");
3319 CmdArgs.push_back(A->getValue());
3320 }
3321
Richard Smith9a568822011-11-21 19:36:32 +00003322 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3323 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003324 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003325 }
3326
Richard Smitha3d3bd22013-05-08 02:12:03 +00003327 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3328 CmdArgs.push_back("-fconstexpr-steps");
3329 CmdArgs.push_back(A->getValue());
3330 }
3331
Richard Smithb3a14522013-02-22 01:59:51 +00003332 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3333 CmdArgs.push_back("-fbracket-depth");
3334 CmdArgs.push_back(A->getValue());
3335 }
3336
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003337 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3338 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003339 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003340 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003341 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3342 } else
3343 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003344 }
3345
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003346
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003347 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003348 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003349
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003350 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3351 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003352 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003353 }
David Chisnall5778fce2009-08-31 16:41:57 +00003354
Chris Lattnere23003d2010-01-09 21:54:33 +00003355 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3356 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003357 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003358 }
3359
Chris Lattnerb35583d2010-04-07 20:49:23 +00003360 CmdArgs.push_back("-ferror-limit");
3361 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003362 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003363 else
3364 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003365
Chandler Carrutha77a7272010-05-06 04:55:18 +00003366 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3367 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003368 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003369 }
3370
3371 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3372 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003373 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003374 }
3375
Richard Smithf6f003a2011-12-16 19:06:07 +00003376 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3377 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003378 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003379 }
3380
Daniel Dunbar2c978472009-11-04 06:24:47 +00003381 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003382 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003383 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003384 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003385 } else {
3386 // If -fmessage-length=N was not specified, determine whether this is a
3387 // terminal and, if so, implicitly define -fmessage-length appropriately.
3388 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003389 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003390 }
3391
John McCallb4a99d32013-02-19 01:57:35 +00003392 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3393 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3394 options::OPT_fvisibility_ms_compat)) {
3395 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3396 CmdArgs.push_back("-fvisibility");
3397 CmdArgs.push_back(A->getValue());
3398 } else {
3399 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3400 CmdArgs.push_back("-fvisibility");
3401 CmdArgs.push_back("hidden");
3402 CmdArgs.push_back("-ftype-visibility");
3403 CmdArgs.push_back("default");
3404 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003405 }
3406
Douglas Gregor08329632010-06-15 17:05:35 +00003407 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003408
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003409 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3410
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003411 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003412 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3413 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003414 CmdArgs.push_back("-ffreestanding");
3415
Daniel Dunbare357d562009-12-03 18:42:11 +00003416 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003417 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003418 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003419 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3420 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003421 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003422 // AltiVec language extensions aren't relevant for assembling.
3423 if (!isa<PreprocessJobAction>(JA) ||
3424 Output.getType() != types::TY_PP_Asm)
3425 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003426 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3427 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003428
Peter Collingbourne32701642013-11-01 18:16:25 +00003429 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3430 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003431
Will Dietz3676d562012-12-30 20:53:28 +00003432 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3433 options::OPT_fno_sanitize_recover,
3434 true))
3435 CmdArgs.push_back("-fno-sanitize-recover");
3436
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003437 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003438 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3439 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3440
Eric Christopher459d2712013-02-19 06:16:53 +00003441 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003442 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003443 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003444 getToolChain().getArch() == llvm::Triple::ppc64 ||
3445 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003446 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003447 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003448
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003449 if (getToolChain().SupportsProfiling())
3450 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003451
3452 // -flax-vector-conversions is default.
3453 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3454 options::OPT_fno_lax_vector_conversions))
3455 CmdArgs.push_back("-fno-lax-vector-conversions");
3456
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003457 if (Args.getLastArg(options::OPT_fapple_kext))
3458 CmdArgs.push_back("-fapple-kext");
3459
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003460 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003461 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003462 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003463 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3464 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003465
3466 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3467 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003468 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003469 }
3470
Bob Wilson14adb362012-02-03 06:27:22 +00003471 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003472
Chandler Carruth6e501032011-03-27 00:04:55 +00003473 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3474 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3475 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3476 options::OPT_fno_wrapv)) {
3477 if (A->getOption().matches(options::OPT_fwrapv))
3478 CmdArgs.push_back("-fwrapv");
3479 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3480 options::OPT_fno_strict_overflow)) {
3481 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3482 CmdArgs.push_back("-fwrapv");
3483 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003484
3485 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3486 options::OPT_fno_reroll_loops))
3487 if (A->getOption().matches(options::OPT_freroll_loops))
3488 CmdArgs.push_back("-freroll-loops");
3489
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003490 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003491 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3492 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003493
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003494 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3495
Mahesha S6a682be42012-10-27 07:47:56 +00003496
Daniel Dunbar4930e332009-11-17 08:07:36 +00003497 // -stack-protector=0 is default.
3498 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003499 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3500 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003501 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003502 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003503 if (A->getOption().matches(options::OPT_fstack_protector)) {
3504 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3505 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3506 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003507 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003508 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003509 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003510 } else {
3511 StackProtectorLevel =
3512 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3513 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003514 if (StackProtectorLevel) {
3515 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003516 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003517 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003518
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003519 // --param ssp-buffer-size=
3520 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3521 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003522 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003523 if (Str.startswith("ssp-buffer-size=")) {
3524 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003525 CmdArgs.push_back("-stack-protector-buffer-size");
3526 // FIXME: Verify the argument is a valid integer.
3527 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003528 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003529 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003530 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003531 }
3532
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003533 // Translate -mstackrealign
3534 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3535 false)) {
3536 CmdArgs.push_back("-backend-option");
3537 CmdArgs.push_back("-force-align-stack");
3538 }
3539 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3540 false)) {
3541 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3542 }
3543
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003544 if (Args.hasArg(options::OPT_mstack_alignment)) {
3545 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3546 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003547 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003548 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003549 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003550 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3551 options::OPT_munaligned_access)) {
3552 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3553 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003554 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3555 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3556 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003557 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003558 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003559 else
3560 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003561 } else {
3562 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003563 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3564 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3565 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003566 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003567 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003568 else
3569 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003570 }
Renato Golina146a482013-08-24 14:44:41 +00003571 }
Chad Rosier60027022012-11-09 17:29:19 +00003572 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003573
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003574 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3575 options::OPT_mno_restrict_it)) {
3576 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3577 CmdArgs.push_back("-backend-option");
3578 CmdArgs.push_back("-arm-restrict-it");
3579 } else {
3580 CmdArgs.push_back("-backend-option");
3581 CmdArgs.push_back("-arm-no-restrict-it");
3582 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003583 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3584 TT.getArch() == llvm::Triple::thumb)) {
3585 // Windows on ARM expects restricted IT blocks
3586 CmdArgs.push_back("-backend-option");
3587 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003588 }
3589
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003590 if (TT.getArch() == llvm::Triple::arm ||
3591 TT.getArch() == llvm::Triple::thumb) {
3592 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3593 options::OPT_mno_long_calls)) {
3594 if (A->getOption().matches(options::OPT_mlong_calls)) {
3595 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003596 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003597 }
3598 }
3599 }
3600
Daniel Dunbard18049a2009-04-07 21:16:11 +00003601 // Forward -f options with positive and negative forms; we translate
3602 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003603 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3604 StringRef fname = A->getValue();
3605 if (!llvm::sys::fs::exists(fname))
3606 D.Diag(diag::err_drv_no_such_file) << fname;
3607 else
3608 A->render(Args, CmdArgs);
3609 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003610
Diego Novillo829b1702014-04-16 16:54:24 +00003611 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3612 A->render(Args, CmdArgs);
3613
Diego Novillod23ec942014-05-29 19:55:06 +00003614 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3615 A->render(Args, CmdArgs);
3616
3617 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3618 A->render(Args, CmdArgs);
3619
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003620 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003621 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003622 CmdArgs.push_back("-fapple-kext");
3623 if (!Args.hasArg(options::OPT_fbuiltin))
3624 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003625 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003626 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003627 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003628 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003629 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003630
Nuno Lopes13c88c72009-12-16 16:59:22 +00003631 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3632 options::OPT_fno_assume_sane_operator_new))
3633 CmdArgs.push_back("-fno-assume-sane-operator-new");
3634
Daniel Dunbar4930e332009-11-17 08:07:36 +00003635 // -fblocks=0 is default.
3636 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003637 getToolChain().IsBlocksDefault()) ||
3638 (Args.hasArg(options::OPT_fgnu_runtime) &&
3639 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3640 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003641 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003642
3643 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3644 !getToolChain().hasBlocksRuntime())
3645 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003646 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003647
Douglas Gregor226173a2012-01-18 15:19:58 +00003648 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3649 // users must also pass -fcxx-modules. The latter flag will disappear once the
3650 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003651 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003652 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3653 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3654 options::OPT_fno_cxx_modules,
3655 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003656 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003657 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003658 HaveModules = true;
3659 }
3660 }
3661
Daniel Jasper07e6c402013-08-05 20:26:17 +00003662 // -fmodule-maps enables module map processing (off by default) for header
3663 // checking. It is implied by -fmodules.
3664 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3665 false)) {
3666 CmdArgs.push_back("-fmodule-maps");
3667 }
3668
Daniel Jasperac42b752013-10-21 06:34:34 +00003669 // -fmodules-decluse checks that modules used are declared so (off by
3670 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003671 if (Args.hasFlag(options::OPT_fmodules_decluse,
3672 options::OPT_fno_modules_decluse,
3673 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003674 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003675 }
3676
Daniel Jasper962b38e2014-04-11 11:47:45 +00003677 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3678 // all #included headers are part of modules.
3679 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3680 options::OPT_fno_modules_strict_decluse,
3681 false)) {
3682 CmdArgs.push_back("-fmodules-strict-decluse");
3683 }
3684
Daniel Jasperac42b752013-10-21 06:34:34 +00003685 // -fmodule-name specifies the module that is currently being built (or
3686 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003687 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003688 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003689
3690 // -fmodule-map-file can be used to specify a file containing module
3691 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003692 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003693 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003694
Justin Bognera88f0122014-06-20 22:59:50 +00003695 // -fmodule-cache-path specifies where our module files should be written.
3696 SmallString<128> ModuleCachePath;
3697 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3698 ModuleCachePath = A->getValue();
3699 if (HaveModules) {
3700 if (C.isForDiagnostics()) {
3701 // When generating crash reports, we want to emit the modules along with
3702 // the reproduction sources, so we ignore any provided module path.
3703 ModuleCachePath = Output.getFilename();
3704 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3705 llvm::sys::path::append(ModuleCachePath, "modules");
3706 } else if (ModuleCachePath.empty()) {
3707 // No module path was provided: use the default.
3708 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3709 ModuleCachePath);
3710 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3711 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3712 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003713 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003714 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3715 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3716 }
3717
3718 // When building modules and generating crashdumps, we need to dump a module
3719 // dependency VFS alongside the output.
3720 if (HaveModules && C.isForDiagnostics()) {
3721 SmallString<128> VFSDir(Output.getFilename());
3722 llvm::sys::path::replace_extension(VFSDir, ".cache");
3723 llvm::sys::path::append(VFSDir, "vfs");
3724 CmdArgs.push_back("-module-dependency-dir");
3725 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003726 }
3727
Justin Bogner5443ad52014-06-20 21:12:53 +00003728 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3729 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003730 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003731
Douglas Gregor35b04d62013-02-07 19:01:24 +00003732 // Pass through all -fmodules-ignore-macro arguments.
3733 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003734 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3735 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003736
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003737 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3738
3739 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3740 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3741 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3742
3743 Args.AddLastArg(CmdArgs,
3744 options::OPT_fmodules_validate_once_per_build_session);
3745 }
3746
Ben Langmuirdcf73862014-03-12 00:06:17 +00003747 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3748
John McCalldfea9982010-04-09 19:12:06 +00003749 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003750 if (Args.hasFlag(options::OPT_fno_access_control,
3751 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003752 false))
John McCall3155f572010-04-09 19:03:51 +00003753 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003754
Anders Carlssond470fef2010-11-21 00:09:52 +00003755 // -felide-constructors is the default.
3756 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3757 options::OPT_felide_constructors,
3758 false))
3759 CmdArgs.push_back("-fno-elide-constructors");
3760
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003761 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003762 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003763 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003764 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003765
Richard Smith52be6192012-11-05 22:04:41 +00003766 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003767 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003768 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003769 Args.getLastArg(options::OPT_mkernel,
3770 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003771 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003772 D.Diag(diag::err_drv_argument_not_allowed_with)
3773 << "-fsanitize=vptr" << NoRttiArg;
3774 }
3775 }
3776
Tony Linthicum76329bf2011-12-12 21:14:55 +00003777 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003778 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003779 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003780 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003781 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003782 CmdArgs.push_back("-fshort-enums");
3783
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003784 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003785 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003786 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003787 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003788
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003789 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003790 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003791 options::OPT_fno_threadsafe_statics))
3792 CmdArgs.push_back("-fno-threadsafe-statics");
3793
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003794 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003795 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3796 options::OPT_fno_use_cxa_atexit,
3797 !IsWindowsCygnus && !IsWindowsGNU &&
3798 getToolChain().getArch() != llvm::Triple::hexagon &&
3799 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003800 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003801 CmdArgs.push_back("-fno-use-cxa-atexit");
3802
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003803 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003804 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003805 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003806 CmdArgs.push_back("-fms-extensions");
3807
Francois Pichet1b4f1632011-09-17 04:32:15 +00003808 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003809 if (Args.hasFlag(options::OPT_fms_compatibility,
3810 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003811 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3812 options::OPT_fno_ms_extensions,
3813 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003814 CmdArgs.push_back("-fms-compatibility");
3815
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003816 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003817 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003818 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3819 Args.hasArg(options::OPT_fms_compatibility_version)) {
3820 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3821 const Arg *MSCompatibilityVersion =
3822 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003823
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003824 if (MSCVersion && MSCompatibilityVersion)
3825 D.Diag(diag::err_drv_argument_not_allowed_with)
3826 << MSCVersion->getAsString(Args)
3827 << MSCompatibilityVersion->getAsString(Args);
3828
3829 std::string Ver;
3830 if (MSCompatibilityVersion)
3831 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
3832 else if (MSCVersion)
3833 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
3834
3835 if (Ver.empty())
3836 CmdArgs.push_back("-fms-compatibility-version=17.00");
3837 else
3838 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
3839 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003840
Eric Christopher5ecce122013-02-18 00:38:31 +00003841 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003842 if (Args.hasFlag(options::OPT_fborland_extensions,
3843 options::OPT_fno_borland_extensions, false))
3844 CmdArgs.push_back("-fborland-extensions");
3845
Francois Pichet02744872011-09-01 16:38:08 +00003846 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3847 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003848 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003849 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003850 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003851
Chandler Carruthe03aa552010-04-17 20:17:31 +00003852 // -fgnu-keywords default varies depending on language; only pass if
3853 // specified.
3854 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003855 options::OPT_fno_gnu_keywords))
3856 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003857
Rafael Espindola922a6242011-06-02 17:30:53 +00003858 if (Args.hasFlag(options::OPT_fgnu89_inline,
3859 options::OPT_fno_gnu89_inline,
3860 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003861 CmdArgs.push_back("-fgnu89-inline");
3862
Chad Rosier9c76d242012-03-15 22:31:42 +00003863 if (Args.hasArg(options::OPT_fno_inline))
3864 CmdArgs.push_back("-fno-inline");
3865
Chad Rosier64d6be92012-03-06 21:17:19 +00003866 if (Args.hasArg(options::OPT_fno_inline_functions))
3867 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003868
John McCall5fb5df92012-06-20 06:18:46 +00003869 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003870
John McCall5fb5df92012-06-20 06:18:46 +00003871 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003872 // legacy is the default. Except for deployment taget of 10.5,
3873 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3874 // gets ignored silently.
3875 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003876 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3877 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003878 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003879 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003880 if (getToolChain().UseObjCMixedDispatch())
3881 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3882 else
3883 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3884 }
3885 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003886
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003887 // When ObjectiveC legacy runtime is in effect on MacOSX,
3888 // turn on the option to do Array/Dictionary subscripting
3889 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003890 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3891 getToolChain().getTriple().isMacOSX() &&
3892 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3893 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003894 objcRuntime.isNeXTFamily())
3895 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3896
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003897 // -fencode-extended-block-signature=1 is default.
3898 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3899 CmdArgs.push_back("-fencode-extended-block-signature");
3900 }
3901
John McCall24fc0de2011-07-06 00:26:06 +00003902 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3903 // NOTE: This logic is duplicated in ToolChains.cpp.
3904 bool ARC = isObjCAutoRefCount(Args);
3905 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003906 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003907
John McCall24fc0de2011-07-06 00:26:06 +00003908 CmdArgs.push_back("-fobjc-arc");
3909
Chandler Carruth491db322011-11-04 07:34:47 +00003910 // FIXME: It seems like this entire block, and several around it should be
3911 // wrapped in isObjC, but for now we just use it here as this is where it
3912 // was being used previously.
3913 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3914 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3915 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3916 else
3917 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3918 }
3919
John McCall24fc0de2011-07-06 00:26:06 +00003920 // Allow the user to enable full exceptions code emission.
3921 // We define off for Objective-CC, on for Objective-C++.
3922 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3923 options::OPT_fno_objc_arc_exceptions,
3924 /*default*/ types::isCXX(InputType)))
3925 CmdArgs.push_back("-fobjc-arc-exceptions");
3926 }
3927
3928 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3929 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003930 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003931 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003932
John McCall24fc0de2011-07-06 00:26:06 +00003933 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3934 // takes precedence.
3935 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3936 if (!GCArg)
3937 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3938 if (GCArg) {
3939 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003940 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003941 << GCArg->getAsString(Args);
3942 } else if (getToolChain().SupportsObjCGC()) {
3943 GCArg->render(Args, CmdArgs);
3944 } else {
3945 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003946 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003947 << GCArg->getAsString(Args);
3948 }
3949 }
3950
Reid Klecknerc542d372014-06-27 17:02:02 +00003951 // Handle GCC-style exception args.
3952 if (!C.getDriver().IsCLMode())
3953 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
3954 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003955
3956 if (getToolChain().UseSjLjExceptions())
3957 CmdArgs.push_back("-fsjlj-exceptions");
3958
3959 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003960 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3961 options::OPT_fno_assume_sane_operator_new))
3962 CmdArgs.push_back("-fno-assume-sane-operator-new");
3963
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003964 // -fconstant-cfstrings is default, and may be subject to argument translation
3965 // on Darwin.
3966 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3967 options::OPT_fno_constant_cfstrings) ||
3968 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3969 options::OPT_mno_constant_cfstrings))
3970 CmdArgs.push_back("-fno-constant-cfstrings");
3971
John Thompsoned4e2952009-11-05 20:14:16 +00003972 // -fshort-wchar default varies depending on platform; only
3973 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003974 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3975 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003976 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003977
Hans Wennborg28c96312013-07-31 23:39:13 +00003978 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003979 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003980 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003981 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003982 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003983
Daniel Dunbar096ed292011-10-05 21:04:55 +00003984 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3985 // -fno-pack-struct doesn't apply to -fpack-struct=.
3986 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003987 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003988 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003989 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003990 } else if (Args.hasFlag(options::OPT_fpack_struct,
3991 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003992 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003993 }
3994
Robert Lytton0e076492013-08-13 09:43:10 +00003995 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003996 if (!Args.hasArg(options::OPT_fcommon))
3997 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003998 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003999 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004000
Daniel Dunbard18049a2009-04-07 21:16:11 +00004001 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004002 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004003 CmdArgs.push_back("-fno-common");
4004
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004005 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004006 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004007 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004008 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004009 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004010 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4011
Daniel Dunbar6358d682010-10-15 22:30:42 +00004012 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4013 if (!Args.hasFlag(options::OPT_ffor_scope,
4014 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004015 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004016 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4017
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004018 // -finput_charset=UTF-8 is default. Reject others
4019 if (Arg *inputCharset = Args.getLastArg(
4020 options::OPT_finput_charset_EQ)) {
4021 StringRef value = inputCharset->getValue();
4022 if (value != "UTF-8")
4023 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4024 }
4025
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004026 // -fcaret-diagnostics is default.
4027 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4028 options::OPT_fno_caret_diagnostics, true))
4029 CmdArgs.push_back("-fno-caret-diagnostics");
4030
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004031 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004032 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004033 options::OPT_fno_diagnostics_fixit_info))
4034 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004035
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004036 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004037 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004038 options::OPT_fno_diagnostics_show_option))
4039 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004040
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004041 if (const Arg *A =
4042 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4043 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004044 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004045 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004046
Douglas Gregor643c9222011-05-21 17:07:29 +00004047 if (const Arg *A =
4048 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4049 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004050 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004051 }
4052
Chandler Carruthb6766f02011-03-27 01:50:55 +00004053 if (Arg *A = Args.getLastArg(
4054 options::OPT_fdiagnostics_show_note_include_stack,
4055 options::OPT_fno_diagnostics_show_note_include_stack)) {
4056 if (A->getOption().matches(
4057 options::OPT_fdiagnostics_show_note_include_stack))
4058 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4059 else
4060 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4061 }
4062
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004063 // Color diagnostics are the default, unless the terminal doesn't support
4064 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004065 // Support both clang's -f[no-]color-diagnostics and gcc's
4066 // -f[no-]diagnostics-colors[=never|always|auto].
4067 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004068 for (const auto &Arg : Args) {
4069 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004070 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4071 !O.matches(options::OPT_fdiagnostics_color) &&
4072 !O.matches(options::OPT_fno_color_diagnostics) &&
4073 !O.matches(options::OPT_fno_diagnostics_color) &&
4074 !O.matches(options::OPT_fdiagnostics_color_EQ))
4075 continue;
4076
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004077 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004078 if (O.matches(options::OPT_fcolor_diagnostics) ||
4079 O.matches(options::OPT_fdiagnostics_color)) {
4080 ShowColors = Colors_On;
4081 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4082 O.matches(options::OPT_fno_diagnostics_color)) {
4083 ShowColors = Colors_Off;
4084 } else {
4085 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004086 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004087 if (value == "always")
4088 ShowColors = Colors_On;
4089 else if (value == "never")
4090 ShowColors = Colors_Off;
4091 else if (value == "auto")
4092 ShowColors = Colors_Auto;
4093 else
4094 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4095 << ("-fdiagnostics-color=" + value).str();
4096 }
4097 }
4098 if (ShowColors == Colors_On ||
4099 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004100 CmdArgs.push_back("-fcolor-diagnostics");
4101
Nico Rieck7857d462013-09-11 00:38:02 +00004102 if (Args.hasArg(options::OPT_fansi_escape_codes))
4103 CmdArgs.push_back("-fansi-escape-codes");
4104
Daniel Dunbardb097022009-06-08 21:13:54 +00004105 if (!Args.hasFlag(options::OPT_fshow_source_location,
4106 options::OPT_fno_show_source_location))
4107 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004108
Douglas Gregor643c9222011-05-21 17:07:29 +00004109 if (!Args.hasFlag(options::OPT_fshow_column,
4110 options::OPT_fno_show_column,
4111 true))
4112 CmdArgs.push_back("-fno-show-column");
4113
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004114 if (!Args.hasFlag(options::OPT_fspell_checking,
4115 options::OPT_fno_spell_checking))
4116 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004117
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004118
Chad Rosierc8e56e82012-12-05 21:08:21 +00004119 // -fno-asm-blocks is default.
4120 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4121 false))
4122 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004123
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004124 // Enable vectorization per default according to the optimization level
4125 // selected. For optimization levels that want vectorization we use the alias
4126 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004127 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004128 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004129 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004130 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004131 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004132 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004133
Chad Rosier136d67d2014-04-28 19:30:57 +00004134 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004135 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4136 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004137 options::OPT_fslp_vectorize;
4138 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004139 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004140 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004141
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004142 // -fno-slp-vectorize-aggressive is default.
4143 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004144 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004145 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004146
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004147 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4148 A->render(Args, CmdArgs);
4149
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004150 // -fdollars-in-identifiers default varies depending on platform and
4151 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004152 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004153 options::OPT_fno_dollars_in_identifiers)) {
4154 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004155 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004156 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004157 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004158 }
4159
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004160 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4161 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004162 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004163 options::OPT_fno_unit_at_a_time)) {
4164 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004165 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004166 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004167
Eli Friedman055c9702011-11-02 01:53:16 +00004168 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4169 options::OPT_fno_apple_pragma_pack, false))
4170 CmdArgs.push_back("-fapple-pragma-pack");
4171
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004172 // le32-specific flags:
4173 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4174 // by default.
4175 if (getToolChain().getArch() == llvm::Triple::le32) {
4176 CmdArgs.push_back("-fno-math-builtin");
4177 }
4178
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004179 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004180 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004181 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004182#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004183 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004184 (getToolChain().getArch() == llvm::Triple::arm ||
4185 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004186 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4187 CmdArgs.push_back("-fno-builtin-strcat");
4188 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4189 CmdArgs.push_back("-fno-builtin-strcpy");
4190 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004191#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004192
Justin Bognera88f0122014-06-20 22:59:50 +00004193 // Enable rewrite includes if the user's asked for it or if we're generating
4194 // diagnostics.
4195 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4196 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004197 if (Args.hasFlag(options::OPT_frewrite_includes,
4198 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004199 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004200 CmdArgs.push_back("-frewrite-includes");
4201
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004202 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004203 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004204 options::OPT_traditional_cpp)) {
4205 if (isa<PreprocessJobAction>(JA))
4206 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004207 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004208 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004209 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004210
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004211 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004212 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004213
4214 // Handle serialized diagnostics.
4215 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4216 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004217 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004218 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004219
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004220 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4221 CmdArgs.push_back("-fretain-comments-from-system-headers");
4222
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004223 // Forward -fcomment-block-commands to -cc1.
4224 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004225 // Forward -fparse-all-comments to -cc1.
4226 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004227
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004228 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4229 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004230 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004231 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4232 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004233 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004234
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004235 // We translate this by hand to the -cc1 argument, since nightly test uses
4236 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004237 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004238 CmdArgs.push_back("-disable-llvm-optzns");
4239 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004240 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004241 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004242
Daniel Dunbard67a3222009-03-30 06:36:42 +00004243 if (Output.getType() == types::TY_Dependencies) {
4244 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004245 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004246 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004247 CmdArgs.push_back(Output.getFilename());
4248 } else {
4249 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004250 }
4251
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004252 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004253 addDashXForInput(Args, II, CmdArgs);
4254
Daniel Dunbarb440f562010-08-02 02:38:21 +00004255 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004256 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004257 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004258 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004259 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004260
Chris Lattnere9d7d782009-11-03 19:50:27 +00004261 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4262
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004263 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004264
4265 // Optionally embed the -cc1 level arguments into the debug info, for build
4266 // analysis.
4267 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004268 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004269 for (const auto &Arg : Args)
4270 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004271
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004272 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004273 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004274 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004275 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004276 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004277 }
4278 CmdArgs.push_back("-dwarf-debug-flags");
4279 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4280 }
4281
Eric Christopherd3804002013-02-22 20:12:52 +00004282 // Add the split debug info name to the command lines here so we
4283 // can propagate it to the backend.
4284 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004285 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004286 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004287 const char *SplitDwarfOut;
4288 if (SplitDwarf) {
4289 CmdArgs.push_back("-split-dwarf-file");
4290 SplitDwarfOut = SplitDebugName(Args, Inputs);
4291 CmdArgs.push_back(SplitDwarfOut);
4292 }
4293
4294 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004295 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004296 Output.getType() == types::TY_Object &&
4297 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg1da044a2014-06-26 19:59:02 +00004298 Command *CLCommand = getCLFallback()->GetCommand(C, JA, Output, Inputs,
4299 Args, LinkingOutput);
David Majnemerf6072342014-07-01 22:24:56 +00004300 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004301 } else {
4302 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4303 }
4304
Daniel Dunbar17731772009-03-23 19:03:36 +00004305
Eric Christopherf1545832013-02-22 23:50:16 +00004306 // Handle the debug info splitting at object creation time if we're
4307 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004308 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004309 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004310 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004311
Roman Divacky178e01602011-02-10 16:52:03 +00004312 if (Arg *A = Args.getLastArg(options::OPT_pg))
4313 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004314 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004315 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004316
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004317 // Claim some arguments which clang supports automatically.
4318
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004319 // -fpch-preprocess is used with gcc to add a special marker in the output to
4320 // include the PCH file. Clang's PTH solution is completely transparent, so we
4321 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004322 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004323
Daniel Dunbar17731772009-03-23 19:03:36 +00004324 // Claim some arguments which clang doesn't support, but we don't
4325 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004326 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4327 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004328
Rafael Espindolab0092d72013-09-04 19:37:35 +00004329 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004330 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004331}
4332
John McCall5fb5df92012-06-20 06:18:46 +00004333/// Add options related to the Objective-C runtime/ABI.
4334///
4335/// Returns true if the runtime is non-fragile.
4336ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4337 ArgStringList &cmdArgs,
4338 RewriteKind rewriteKind) const {
4339 // Look for the controlling runtime option.
4340 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4341 options::OPT_fgnu_runtime,
4342 options::OPT_fobjc_runtime_EQ);
4343
4344 // Just forward -fobjc-runtime= to the frontend. This supercedes
4345 // options about fragility.
4346 if (runtimeArg &&
4347 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4348 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004349 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004350 if (runtime.tryParse(value)) {
4351 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4352 << value;
4353 }
4354
4355 runtimeArg->render(args, cmdArgs);
4356 return runtime;
4357 }
4358
4359 // Otherwise, we'll need the ABI "version". Version numbers are
4360 // slightly confusing for historical reasons:
4361 // 1 - Traditional "fragile" ABI
4362 // 2 - Non-fragile ABI, version 1
4363 // 3 - Non-fragile ABI, version 2
4364 unsigned objcABIVersion = 1;
4365 // If -fobjc-abi-version= is present, use that to set the version.
4366 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004367 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004368 if (value == "1")
4369 objcABIVersion = 1;
4370 else if (value == "2")
4371 objcABIVersion = 2;
4372 else if (value == "3")
4373 objcABIVersion = 3;
4374 else
4375 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4376 << value;
4377 } else {
4378 // Otherwise, determine if we are using the non-fragile ABI.
4379 bool nonFragileABIIsDefault =
4380 (rewriteKind == RK_NonFragile ||
4381 (rewriteKind == RK_None &&
4382 getToolChain().IsObjCNonFragileABIDefault()));
4383 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4384 options::OPT_fno_objc_nonfragile_abi,
4385 nonFragileABIIsDefault)) {
4386 // Determine the non-fragile ABI version to use.
4387#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4388 unsigned nonFragileABIVersion = 1;
4389#else
4390 unsigned nonFragileABIVersion = 2;
4391#endif
4392
4393 if (Arg *abiArg = args.getLastArg(
4394 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004395 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004396 if (value == "1")
4397 nonFragileABIVersion = 1;
4398 else if (value == "2")
4399 nonFragileABIVersion = 2;
4400 else
4401 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4402 << value;
4403 }
4404
4405 objcABIVersion = 1 + nonFragileABIVersion;
4406 } else {
4407 objcABIVersion = 1;
4408 }
4409 }
4410
4411 // We don't actually care about the ABI version other than whether
4412 // it's non-fragile.
4413 bool isNonFragile = objcABIVersion != 1;
4414
4415 // If we have no runtime argument, ask the toolchain for its default runtime.
4416 // However, the rewriter only really supports the Mac runtime, so assume that.
4417 ObjCRuntime runtime;
4418 if (!runtimeArg) {
4419 switch (rewriteKind) {
4420 case RK_None:
4421 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4422 break;
4423 case RK_Fragile:
4424 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4425 break;
4426 case RK_NonFragile:
4427 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4428 break;
4429 }
4430
4431 // -fnext-runtime
4432 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4433 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004434 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004435 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4436
4437 // Otherwise, build for a generic macosx port.
4438 } else {
4439 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4440 }
4441
4442 // -fgnu-runtime
4443 } else {
4444 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004445 // Legacy behaviour is to target the gnustep runtime if we are i
4446 // non-fragile mode or the GCC runtime in fragile mode.
4447 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004448 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004449 else
4450 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004451 }
4452
4453 cmdArgs.push_back(args.MakeArgString(
4454 "-fobjc-runtime=" + runtime.getAsString()));
4455 return runtime;
4456}
4457
Reid Klecknerc542d372014-06-27 17:02:02 +00004458static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4459 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4460 I += HaveDash;
4461 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004462}
Reid Klecknerc542d372014-06-27 17:02:02 +00004463
4464struct EHFlags {
4465 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4466 bool Synch;
4467 bool Asynch;
4468 bool NoExceptC;
4469};
4470
4471/// /EH controls whether to run destructor cleanups when exceptions are
4472/// thrown. There are three modifiers:
4473/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4474/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4475/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4476/// - c: Assume that extern "C" functions are implicitly noexcept. This
4477/// modifier is an optimization, so we ignore it for now.
4478/// The default is /EHs-c-, meaning cleanups are disabled.
4479static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4480 EHFlags EH;
4481 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4482 for (auto EHVal : EHArgs) {
4483 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4484 switch (EHVal[I]) {
4485 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4486 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4487 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4488 default: break;
4489 }
4490 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4491 break;
4492 }
4493 }
4494 return EH;
4495}
4496
Hans Wennborg75958c42013-08-08 00:17:41 +00004497void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4498 unsigned RTOptionID = options::OPT__SLASH_MT;
4499
Hans Wennborgf1a74252013-09-10 20:18:04 +00004500 if (Args.hasArg(options::OPT__SLASH_LDd))
4501 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4502 // but defining _DEBUG is sticky.
4503 RTOptionID = options::OPT__SLASH_MTd;
4504
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004505 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004506 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004507
Hans Wennborg75958c42013-08-08 00:17:41 +00004508 switch(RTOptionID) {
4509 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004510 if (Args.hasArg(options::OPT__SLASH_LDd))
4511 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004512 CmdArgs.push_back("-D_MT");
4513 CmdArgs.push_back("-D_DLL");
4514 CmdArgs.push_back("--dependent-lib=msvcrt");
4515 break;
4516 case options::OPT__SLASH_MDd:
4517 CmdArgs.push_back("-D_DEBUG");
4518 CmdArgs.push_back("-D_MT");
4519 CmdArgs.push_back("-D_DLL");
4520 CmdArgs.push_back("--dependent-lib=msvcrtd");
4521 break;
4522 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004523 if (Args.hasArg(options::OPT__SLASH_LDd))
4524 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004525 CmdArgs.push_back("-D_MT");
4526 CmdArgs.push_back("--dependent-lib=libcmt");
4527 break;
4528 case options::OPT__SLASH_MTd:
4529 CmdArgs.push_back("-D_DEBUG");
4530 CmdArgs.push_back("-D_MT");
4531 CmdArgs.push_back("--dependent-lib=libcmtd");
4532 break;
4533 default:
4534 llvm_unreachable("Unexpected option ID.");
4535 }
4536
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004537 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4538 // users want. The /Za flag to cl.exe turns this off, but it's not
4539 // implemented in clang.
4540 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004541
Hans Wennborg0fd62072013-08-09 00:32:23 +00004542 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4543 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004544
David Majnemerf6072342014-07-01 22:24:56 +00004545 // This controls whether or not we emit RTTI data for polymorphic types.
4546 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4547 /*default=*/false))
4548 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004549
Reid Klecknerc542d372014-06-27 17:02:02 +00004550 const Driver &D = getToolChain().getDriver();
4551 EHFlags EH = parseClangCLEHFlags(D, Args);
4552 // FIXME: Do something with NoExceptC.
4553 if (EH.Synch || EH.Asynch) {
4554 CmdArgs.push_back("-fexceptions");
4555 CmdArgs.push_back("-fcxx-exceptions");
4556 }
4557
Hans Wennborge50cec32014-06-13 20:59:54 +00004558 // /EP should expand to -E -P.
4559 if (Args.hasArg(options::OPT__SLASH_EP)) {
4560 CmdArgs.push_back("-E");
4561 CmdArgs.push_back("-P");
4562 }
4563
David Majnemer86c318f2014-02-11 21:05:00 +00004564 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4565 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4566 if (MostGeneralArg && BestCaseArg)
4567 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4568 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4569
4570 if (MostGeneralArg) {
4571 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4572 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4573 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4574
4575 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4576 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4577 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4578 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4579 << FirstConflict->getAsString(Args)
4580 << SecondConflict->getAsString(Args);
4581
4582 if (SingleArg)
4583 CmdArgs.push_back("-fms-memptr-rep=single");
4584 else if (MultipleArg)
4585 CmdArgs.push_back("-fms-memptr-rep=multiple");
4586 else
4587 CmdArgs.push_back("-fms-memptr-rep=virtual");
4588 }
4589
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004590 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4591 A->render(Args, CmdArgs);
4592
Hans Wennborg81f74482013-09-10 01:07:07 +00004593 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4594 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004595 if (Args.hasArg(options::OPT__SLASH_fallback))
4596 CmdArgs.push_back("msvc-fallback");
4597 else
4598 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004599 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004600}
4601
Hans Wennborg1da044a2014-06-26 19:59:02 +00004602visualstudio::Compile *Clang::getCLFallback() const {
4603 if (!CLFallback)
4604 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4605 return CLFallback.get();
4606}
4607
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004608void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004609 const InputInfo &Output,
4610 const InputInfoList &Inputs,
4611 const ArgList &Args,
4612 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004613 ArgStringList CmdArgs;
4614
4615 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4616 const InputInfo &Input = Inputs[0];
4617
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004618 // Don't warn about "clang -w -c foo.s"
4619 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004620 // and "clang -emit-llvm -c foo.s"
4621 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004622
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004623 // Invoke ourselves in -cc1as mode.
4624 //
4625 // FIXME: Implement custom jobs for internal actions.
4626 CmdArgs.push_back("-cc1as");
4627
4628 // Add the "effective" target triple.
4629 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004630 std::string TripleStr =
4631 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004632 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4633
4634 // Set the output mode, we currently only expect to be used as a real
4635 // assembler.
4636 CmdArgs.push_back("-filetype");
4637 CmdArgs.push_back("obj");
4638
Eric Christopher45f2e712012-12-18 00:31:10 +00004639 // Set the main file name, so that debug info works even with
4640 // -save-temps or preprocessed assembly.
4641 CmdArgs.push_back("-main-file-name");
4642 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4643
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004644 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004645 const llvm::Triple &Triple = getToolChain().getTriple();
4646 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004647 if (!CPU.empty()) {
4648 CmdArgs.push_back("-target-cpu");
4649 CmdArgs.push_back(Args.MakeArgString(CPU));
4650 }
4651
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004652 // Add the target features
4653 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004654 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004655
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004656 // Ignore explicit -force_cpusubtype_ALL option.
4657 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004658
Eric Christopherfc3ee562012-01-10 00:38:01 +00004659 // Determine the original source input.
4660 const Action *SourceAction = &JA;
4661 while (SourceAction->getKind() != Action::InputClass) {
4662 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4663 SourceAction = SourceAction->getInputs()[0];
4664 }
4665
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004666 // Forward -g and handle debug info related flags, assuming we are dealing
4667 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004668 if (SourceAction->getType() == types::TY_Asm ||
4669 SourceAction->getType() == types::TY_PP_Asm) {
4670 Args.ClaimAllArgs(options::OPT_g_Group);
4671 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4672 if (!A->getOption().matches(options::OPT_g0))
4673 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004674
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004675 if (Args.hasArg(options::OPT_gdwarf_2))
4676 CmdArgs.push_back("-gdwarf-2");
4677 if (Args.hasArg(options::OPT_gdwarf_3))
4678 CmdArgs.push_back("-gdwarf-3");
4679 if (Args.hasArg(options::OPT_gdwarf_4))
4680 CmdArgs.push_back("-gdwarf-4");
4681
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004682 // Add the -fdebug-compilation-dir flag if needed.
4683 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004684
4685 // Set the AT_producer to the clang version when using the integrated
4686 // assembler on assembly source files.
4687 CmdArgs.push_back("-dwarf-debug-producer");
4688 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004689 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004690
4691 // Optionally embed the -cc1as level arguments into the debug info, for build
4692 // analysis.
4693 if (getToolChain().UseDwarfDebugFlags()) {
4694 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004695 for (const auto &Arg : Args)
4696 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004697
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004698 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004699 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4700 Flags += Exec;
4701 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4702 Flags += " ";
4703 Flags += OriginalArgs[i];
4704 }
4705 CmdArgs.push_back("-dwarf-debug-flags");
4706 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4707 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004708
4709 // FIXME: Add -static support, once we have it.
4710
David Blaikie372d9502014-01-17 03:17:40 +00004711 // Consume all the warning flags. Usually this would be handled more
4712 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4713 // doesn't handle that so rather than warning about unused flags that are
4714 // actually used, we'll lie by omission instead.
4715 // FIXME: Stop lying and consume only the appropriate driver flags
4716 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4717 ie = Args.filtered_end();
4718 it != ie; ++it)
4719 (*it)->claim();
4720
David Blaikie9260ed62013-07-25 21:19:01 +00004721 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4722 getToolChain().getDriver());
4723
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004724 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004725
4726 assert(Output.isFilename() && "Unexpected lipo output.");
4727 CmdArgs.push_back("-o");
4728 CmdArgs.push_back(Output.getFilename());
4729
Daniel Dunbarb440f562010-08-02 02:38:21 +00004730 assert(Input.isFilename() && "Invalid input.");
4731 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004732
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004733 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004734 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004735
4736 // Handle the debug info splitting at object creation time if we're
4737 // creating an object.
4738 // TODO: Currently only works on linux with newer objcopy.
4739 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004740 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004741 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4742 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004743}
4744
Daniel Dunbara3246a02009-03-18 08:07:30 +00004745void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004746 const InputInfo &Output,
4747 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004748 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004749 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004750 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004751 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004752
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004753 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004754 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004755 // Don't forward any -g arguments to assembly steps.
4756 if (isa<AssembleJobAction>(JA) &&
4757 A->getOption().matches(options::OPT_g_Group))
4758 continue;
4759
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004760 // Don't forward any -W arguments to assembly and link steps.
4761 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4762 A->getOption().matches(options::OPT_W_Group))
4763 continue;
4764
Daniel Dunbar2da02722009-03-19 07:55:12 +00004765 // It is unfortunate that we have to claim here, as this means
4766 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004767 // platforms using a generic gcc, even if we are just using gcc
4768 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004769 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004770 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004771 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004772 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004773
Daniel Dunbar4e295052010-01-25 22:35:08 +00004774 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004775
4776 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004777 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004778 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004779 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004780
4781 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004782 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004783 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004784 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004785 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004786 else if (Arch == llvm::Triple::ppc64le)
4787 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004788 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004789 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004790 }
4791
Daniel Dunbar5716d872009-05-02 21:41:52 +00004792 // Try to force gcc to match the tool chain we want, if we recognize
4793 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004794 //
4795 // FIXME: The triple class should directly provide the information we want
4796 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004797 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004798 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004799 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4800 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004801 CmdArgs.push_back("-m64");
4802
Daniel Dunbarb440f562010-08-02 02:38:21 +00004803 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004804 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004805 CmdArgs.push_back(Output.getFilename());
4806 } else {
4807 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004808 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004809 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004810
Tony Linthicum76329bf2011-12-12 21:14:55 +00004811 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4812 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004813
4814 // Only pass -x if gcc will understand it; otherwise hope gcc
4815 // understands the suffix correctly. The main use case this would go
4816 // wrong in is for linker inputs if they happened to have an odd
4817 // suffix; really the only way to get this to happen is a command
4818 // like '-x foobar a.c' which will treat a.c like a linker input.
4819 //
4820 // FIXME: For the linker case specifically, can we safely convert
4821 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004822 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004823 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004824 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4825 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004826 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004827 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004828 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004829 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004830 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004831 else if (II.getType() == types::TY_ModuleFile)
4832 D.Diag(diag::err_drv_no_module_support)
4833 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004834
Daniel Dunbara3246a02009-03-18 08:07:30 +00004835 if (types::canTypeBeUserSpecified(II.getType())) {
4836 CmdArgs.push_back("-x");
4837 CmdArgs.push_back(types::getTypeName(II.getType()));
4838 }
4839
Daniel Dunbarb440f562010-08-02 02:38:21 +00004840 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004841 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004842 else {
4843 const Arg &A = II.getInputArg();
4844
4845 // Reverse translate some rewritten options.
4846 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4847 CmdArgs.push_back("-lstdc++");
4848 continue;
4849 }
4850
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004851 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004852 A.render(Args, CmdArgs);
4853 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004854 }
4855
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004856 const std::string customGCCName = D.getCCCGenericGCCName();
4857 const char *GCCName;
4858 if (!customGCCName.empty())
4859 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004860 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004861 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004862 } else
4863 GCCName = "gcc";
4864
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004865 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004866 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004867 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004868}
4869
Daniel Dunbar4e295052010-01-25 22:35:08 +00004870void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4871 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004872 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004873}
4874
Daniel Dunbar4e295052010-01-25 22:35:08 +00004875void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4876 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004877 const Driver &D = getToolChain().getDriver();
4878
Daniel Dunbar4e295052010-01-25 22:35:08 +00004879 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004880 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4881 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004882 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004883 else {
4884 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004885 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004886 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004887
Daniel Dunbar4e295052010-01-25 22:35:08 +00004888 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004889 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004890}
4891
Daniel Dunbar4e295052010-01-25 22:35:08 +00004892void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4893 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004894 // The types are (hopefully) good enough.
4895}
4896
Tony Linthicum76329bf2011-12-12 21:14:55 +00004897// Hexagon tools start.
4898void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4899 ArgStringList &CmdArgs) const {
4900
4901}
4902void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4903 const InputInfo &Output,
4904 const InputInfoList &Inputs,
4905 const ArgList &Args,
4906 const char *LinkingOutput) const {
4907
4908 const Driver &D = getToolChain().getDriver();
4909 ArgStringList CmdArgs;
4910
4911 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004912 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004913 CmdArgs.push_back(Args.MakeArgString(MarchString));
4914
4915 RenderExtraToolArgs(JA, CmdArgs);
4916
4917 if (Output.isFilename()) {
4918 CmdArgs.push_back("-o");
4919 CmdArgs.push_back(Output.getFilename());
4920 } else {
4921 assert(Output.isNothing() && "Unexpected output");
4922 CmdArgs.push_back("-fsyntax-only");
4923 }
4924
Matthew Curtise8f80a12012-12-06 17:49:03 +00004925 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4926 if (!SmallDataThreshold.empty())
4927 CmdArgs.push_back(
4928 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004929
Matthew Curtise5df3812012-12-07 17:23:04 +00004930 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4931 options::OPT_Xassembler);
4932
Tony Linthicum76329bf2011-12-12 21:14:55 +00004933 // Only pass -x if gcc will understand it; otherwise hope gcc
4934 // understands the suffix correctly. The main use case this would go
4935 // wrong in is for linker inputs if they happened to have an odd
4936 // suffix; really the only way to get this to happen is a command
4937 // like '-x foobar a.c' which will treat a.c like a linker input.
4938 //
4939 // FIXME: For the linker case specifically, can we safely convert
4940 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004941 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004942 // Don't try to pass LLVM or AST inputs to a generic gcc.
4943 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4944 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4945 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4946 << getToolChain().getTripleString();
4947 else if (II.getType() == types::TY_AST)
4948 D.Diag(clang::diag::err_drv_no_ast_support)
4949 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004950 else if (II.getType() == types::TY_ModuleFile)
4951 D.Diag(diag::err_drv_no_module_support)
4952 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004953
4954 if (II.isFilename())
4955 CmdArgs.push_back(II.getFilename());
4956 else
4957 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4958 II.getInputArg().render(Args, CmdArgs);
4959 }
4960
4961 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004962 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004963 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004964}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004965
Tony Linthicum76329bf2011-12-12 21:14:55 +00004966void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4967 ArgStringList &CmdArgs) const {
4968 // The types are (hopefully) good enough.
4969}
4970
4971void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4972 const InputInfo &Output,
4973 const InputInfoList &Inputs,
4974 const ArgList &Args,
4975 const char *LinkingOutput) const {
4976
Matthew Curtise689b052012-12-06 15:46:07 +00004977 const toolchains::Hexagon_TC& ToolChain =
4978 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4979 const Driver &D = ToolChain.getDriver();
4980
Tony Linthicum76329bf2011-12-12 21:14:55 +00004981 ArgStringList CmdArgs;
4982
Matthew Curtise689b052012-12-06 15:46:07 +00004983 //----------------------------------------------------------------------------
4984 //
4985 //----------------------------------------------------------------------------
4986 bool hasStaticArg = Args.hasArg(options::OPT_static);
4987 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004988 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004989 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4990 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4991 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4992 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004993
Matthew Curtise689b052012-12-06 15:46:07 +00004994 //----------------------------------------------------------------------------
4995 // Silence warnings for various options
4996 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004997
Matthew Curtise689b052012-12-06 15:46:07 +00004998 Args.ClaimAllArgs(options::OPT_g_Group);
4999 Args.ClaimAllArgs(options::OPT_emit_llvm);
5000 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5001 // handled somewhere else.
5002 Args.ClaimAllArgs(options::OPT_static_libgcc);
5003
5004 //----------------------------------------------------------------------------
5005 //
5006 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005007 for (const auto &Opt : ToolChain.ExtraOpts)
5008 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005009
Matthew Curtisf10a5952012-12-06 14:16:43 +00005010 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5011 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005012
Matthew Curtise689b052012-12-06 15:46:07 +00005013 if (buildingLib) {
5014 CmdArgs.push_back("-shared");
5015 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5016 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005017 }
5018
Matthew Curtise689b052012-12-06 15:46:07 +00005019 if (hasStaticArg)
5020 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005021
Matthew Curtise8f80a12012-12-06 17:49:03 +00005022 if (buildPIE && !buildingLib)
5023 CmdArgs.push_back("-pie");
5024
5025 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5026 if (!SmallDataThreshold.empty()) {
5027 CmdArgs.push_back(
5028 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5029 }
5030
Matthew Curtise689b052012-12-06 15:46:07 +00005031 //----------------------------------------------------------------------------
5032 //
5033 //----------------------------------------------------------------------------
5034 CmdArgs.push_back("-o");
5035 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005036
Matthew Curtise689b052012-12-06 15:46:07 +00005037 const std::string MarchSuffix = "/" + MarchString;
5038 const std::string G0Suffix = "/G0";
5039 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
5040 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
5041 + "/";
5042 const std::string StartFilesDir = RootDir
5043 + "hexagon/lib"
5044 + (buildingLib
5045 ? MarchG0Suffix : MarchSuffix);
5046
5047 //----------------------------------------------------------------------------
5048 // moslib
5049 //----------------------------------------------------------------------------
5050 std::vector<std::string> oslibs;
5051 bool hasStandalone= false;
5052
5053 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5054 ie = Args.filtered_end(); it != ie; ++it) {
5055 (*it)->claim();
5056 oslibs.push_back((*it)->getValue());
5057 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005058 }
Matthew Curtise689b052012-12-06 15:46:07 +00005059 if (oslibs.empty()) {
5060 oslibs.push_back("standalone");
5061 hasStandalone = true;
5062 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005063
Matthew Curtise689b052012-12-06 15:46:07 +00005064 //----------------------------------------------------------------------------
5065 // Start Files
5066 //----------------------------------------------------------------------------
5067 if (incStdLib && incStartFiles) {
5068
5069 if (!buildingLib) {
5070 if (hasStandalone) {
5071 CmdArgs.push_back(
5072 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5073 }
5074 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5075 }
5076 std::string initObj = useShared ? "/initS.o" : "/init.o";
5077 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5078 }
5079
5080 //----------------------------------------------------------------------------
5081 // Library Search Paths
5082 //----------------------------------------------------------------------------
5083 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005084 for (const auto &LibPath : LibPaths)
5085 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005086
5087 //----------------------------------------------------------------------------
5088 //
5089 //----------------------------------------------------------------------------
5090 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5091 Args.AddAllArgs(CmdArgs, options::OPT_e);
5092 Args.AddAllArgs(CmdArgs, options::OPT_s);
5093 Args.AddAllArgs(CmdArgs, options::OPT_t);
5094 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5095
5096 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5097
5098 //----------------------------------------------------------------------------
5099 // Libraries
5100 //----------------------------------------------------------------------------
5101 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005102 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005103 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5104 CmdArgs.push_back("-lm");
5105 }
5106
5107 CmdArgs.push_back("--start-group");
5108
5109 if (!buildingLib) {
5110 for(std::vector<std::string>::iterator i = oslibs.begin(),
5111 e = oslibs.end(); i != e; ++i)
5112 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5113 CmdArgs.push_back("-lc");
5114 }
5115 CmdArgs.push_back("-lgcc");
5116
5117 CmdArgs.push_back("--end-group");
5118 }
5119
5120 //----------------------------------------------------------------------------
5121 // End files
5122 //----------------------------------------------------------------------------
5123 if (incStdLib && incStartFiles) {
5124 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5125 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5126 }
5127
5128 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005129 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005130}
5131// Hexagon tools end.
5132
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005133/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005134const char *arm::getARMCPUForMArch(const ArgList &Args,
5135 const llvm::Triple &Triple) {
5136 StringRef MArch;
5137 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5138 // Otherwise, if we have -march= choose the base CPU for that arch.
5139 MArch = A->getValue();
5140 } else {
5141 // Otherwise, use the Arch from the triple.
5142 MArch = Triple.getArchName();
5143 }
5144
5145 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005146 if (MArch == "native") {
5147 std::string CPU = llvm::sys::getHostCPUName();
5148 if (CPU != "generic") {
5149 // Translate the native cpu into the architecture. The switch below will
5150 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005151 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005152 }
5153 }
5154
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005155 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005156}
5157
5158/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005159StringRef arm::getARMTargetCPU(const ArgList &Args,
5160 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005161 // FIXME: Warn on inconsistent use of -mcpu and -march.
5162 // If we have -mcpu=, use that.
5163 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5164 StringRef MCPU = A->getValue();
5165 // Handle -mcpu=native.
5166 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005167 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005168 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005169 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005170 }
5171
5172 return getARMCPUForMArch(Args, Triple);
5173}
5174
5175/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5176/// CPU.
5177//
5178// FIXME: This is redundant with -mcpu, why does LLVM use this.
5179// FIXME: tblgen this, or kill it!
5180const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5181 return llvm::StringSwitch<const char *>(CPU)
5182 .Case("strongarm", "v4")
5183 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5184 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5185 .Cases("arm920", "arm920t", "arm922t", "v4t")
5186 .Cases("arm940t", "ep9312","v4t")
5187 .Cases("arm10tdmi", "arm1020t", "v5")
5188 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5189 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5190 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5191 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5192 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5193 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005194 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005195 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5196 .Cases("cortex-r4", "cortex-r5", "v7r")
5197 .Case("cortex-m0", "v6m")
5198 .Case("cortex-m3", "v7m")
5199 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005200 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005201 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005202 .Cases("cortex-a53", "cortex-a57", "v8")
5203 .Default("");
5204}
5205
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005206bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5207 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5208 return A && (A->getValue() == StringRef(Value));
5209}
5210
Daniel Sanders2bf13662014-07-10 14:40:57 +00005211bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005212 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5213 return llvm::StringSwitch<bool>(NaNArg->getValue())
5214 .Case("2008", true)
5215 .Case("legacy", false)
5216 .Default(false);
5217
5218 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005219 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5220 .Cases("mips32r6", "mips64r6", true)
5221 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005222
5223 return false;
5224}
5225
Daniel Sanders379d44b2014-07-16 11:52:23 +00005226bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5227 StringRef ABIName) {
5228 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
5229 Triple.getVendorName() != "mti")
5230 return false;
5231
5232 if (ABIName != "32")
5233 return false;
5234
5235 return llvm::StringSwitch<bool>(CPUName)
5236 .Cases("mips2", "mips3", "mips4", "mips5", true)
5237 .Cases("mips32", "mips32r2", true)
5238 .Cases("mips64", "mips64r2", true)
5239 .Default(false);
5240}
5241
Tim Northover157d9112014-01-16 08:48:16 +00005242llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005243 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5244 // archs which Darwin doesn't use.
5245
5246 // The matching this routine does is fairly pointless, since it is neither the
5247 // complete architecture list, nor a reasonable subset. The problem is that
5248 // historically the driver driver accepts this and also ties its -march=
5249 // handling to the architecture name, so we need to be careful before removing
5250 // support for it.
5251
5252 // This code must be kept in sync with Clang's Darwin specific argument
5253 // translation.
5254
5255 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5256 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5257 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5258 .Case("ppc64", llvm::Triple::ppc64)
5259 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5260 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5261 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005262 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005263 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005264 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005265 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005266 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005267 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005268 .Case("r600", llvm::Triple::r600)
5269 .Case("nvptx", llvm::Triple::nvptx)
5270 .Case("nvptx64", llvm::Triple::nvptx64)
5271 .Case("amdil", llvm::Triple::amdil)
5272 .Case("spir", llvm::Triple::spir)
5273 .Default(llvm::Triple::UnknownArch);
5274}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005275
Tim Northover157d9112014-01-16 08:48:16 +00005276void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5277 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5278 T.setArch(Arch);
5279
5280 if (Str == "x86_64h")
5281 T.setArchName(Str);
5282 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5283 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005284 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005285 }
5286}
5287
Bob Wilsondecc03e2012-11-23 06:14:39 +00005288const char *Clang::getBaseInputName(const ArgList &Args,
5289 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005290 return Args.MakeArgString(
5291 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005292}
5293
Bob Wilsondecc03e2012-11-23 06:14:39 +00005294const char *Clang::getBaseInputStem(const ArgList &Args,
5295 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005296 const char *Str = getBaseInputName(Args, Inputs);
5297
Chris Lattner906bb902011-01-16 08:14:11 +00005298 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005299 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005300
5301 return Str;
5302}
5303
Bob Wilsondecc03e2012-11-23 06:14:39 +00005304const char *Clang::getDependencyFileName(const ArgList &Args,
5305 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005306 // FIXME: Think about this more.
5307 std::string Res;
5308
5309 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005310 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005311 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005312 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005313 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005314 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005315 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005316}
5317
Daniel Dunbarbe220842009-03-20 16:06:39 +00005318void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005319 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005320 const InputInfoList &Inputs,
5321 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005322 const char *LinkingOutput) const {
5323 ArgStringList CmdArgs;
5324
5325 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5326 const InputInfo &Input = Inputs[0];
5327
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005328 // Determine the original source input.
5329 const Action *SourceAction = &JA;
5330 while (SourceAction->getKind() != Action::InputClass) {
5331 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5332 SourceAction = SourceAction->getInputs()[0];
5333 }
5334
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005335 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005336 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005337 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5338 // FIXME: at run-time detect assembler capabilities or rely on version
5339 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005340 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005341 const llvm::Triple &T(getToolChain().getTriple());
5342 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005343 CmdArgs.push_back("-Q");
5344 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005345
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005346 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005347 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005348 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005349 if (Args.hasArg(options::OPT_gstabs))
5350 CmdArgs.push_back("--gstabs");
5351 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005352 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005353 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005354
Daniel Dunbarbe220842009-03-20 16:06:39 +00005355 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005356 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005357
Daniel Dunbar6d484762010-07-22 01:47:22 +00005358 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005359 if (getToolChain().getArch() == llvm::Triple::x86 ||
5360 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005361 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5362 CmdArgs.push_back("-force_cpusubtype_ALL");
5363
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005364 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005365 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005366 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005367 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005368 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005369 CmdArgs.push_back("-static");
5370
Daniel Dunbarbe220842009-03-20 16:06:39 +00005371 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5372 options::OPT_Xassembler);
5373
5374 assert(Output.isFilename() && "Unexpected lipo output.");
5375 CmdArgs.push_back("-o");
5376 CmdArgs.push_back(Output.getFilename());
5377
Daniel Dunbarb440f562010-08-02 02:38:21 +00005378 assert(Input.isFilename() && "Invalid input.");
5379 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005380
5381 // asm_final spec is empty.
5382
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005383 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005384 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005385 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005386}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005387
Tim Northover157d9112014-01-16 08:48:16 +00005388void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005389
Tim Northover157d9112014-01-16 08:48:16 +00005390void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5391 ArgStringList &CmdArgs) const {
5392 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005393
Daniel Dunbarc1964212009-03-26 16:23:12 +00005394 // Derived from darwin_arch spec.
5395 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005396 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005397
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005398 // FIXME: Is this needed anymore?
5399 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005400 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005401}
5402
Bill Wendling3b2000f2012-10-02 18:02:50 +00005403bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5404 // We only need to generate a temp path for LTO if we aren't compiling object
5405 // files. When compiling source files, we run 'dsymutil' after linking. We
5406 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005407 for (const auto &Input : Inputs)
5408 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005409 return true;
5410
5411 return false;
5412}
5413
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005414void darwin::Link::AddLinkArgs(Compilation &C,
5415 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005416 ArgStringList &CmdArgs,
5417 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005418 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005419 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005420
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005421 unsigned Version[3] = { 0, 0, 0 };
5422 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5423 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005424 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005425 Version[1], Version[2], HadExtra) ||
5426 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005427 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005428 << A->getAsString(Args);
5429 }
5430
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005431 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005432 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005433 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5434 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005435
Bob Wilson3d27dad2013-08-02 22:25:34 +00005436 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5437 CmdArgs.push_back("-export_dynamic");
5438
Bill Wendling313b6bf2012-11-16 23:03:00 +00005439 // If we are using LTO, then automatically create a temporary file path for
5440 // the linker to use, so that it's lifetime will extend past a possible
5441 // dsymutil step.
5442 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5443 const char *TmpPath = C.getArgs().MakeArgString(
5444 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5445 C.addTempFile(TmpPath);
5446 CmdArgs.push_back("-object_path_lto");
5447 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005448 }
5449
Daniel Dunbarc1964212009-03-26 16:23:12 +00005450 // Derived from the "link" spec.
5451 Args.AddAllArgs(CmdArgs, options::OPT_static);
5452 if (!Args.hasArg(options::OPT_static))
5453 CmdArgs.push_back("-dynamic");
5454 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5455 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5456 // here. How do we wish to handle such things?
5457 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005458
Daniel Dunbarc1964212009-03-26 16:23:12 +00005459 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005460 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005461 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005462 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005463
5464 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5465 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5466 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5467
5468 Arg *A;
5469 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5470 (A = Args.getLastArg(options::OPT_current__version)) ||
5471 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005472 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005473 << A->getAsString(Args) << "-dynamiclib";
5474
5475 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5476 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5477 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5478 } else {
5479 CmdArgs.push_back("-dylib");
5480
5481 Arg *A;
5482 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5483 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5484 (A = Args.getLastArg(options::OPT_client__name)) ||
5485 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5486 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5487 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005488 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005489 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005490
Daniel Dunbarc1964212009-03-26 16:23:12 +00005491 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5492 "-dylib_compatibility_version");
5493 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5494 "-dylib_current_version");
5495
Tim Northover157d9112014-01-16 08:48:16 +00005496 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005497
5498 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5499 "-dylib_install_name");
5500 }
5501
5502 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5503 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5504 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005505 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005506 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005507 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5508 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5509 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5510 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5511 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5512 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005513 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005514 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5515 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5516 Args.AddAllArgs(CmdArgs, options::OPT_init);
5517
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005518 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005519 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005520
Daniel Dunbarc1964212009-03-26 16:23:12 +00005521 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5522 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5523 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5524 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5525 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005526
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005527 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5528 options::OPT_fno_pie,
5529 options::OPT_fno_PIE)) {
5530 if (A->getOption().matches(options::OPT_fpie) ||
5531 A->getOption().matches(options::OPT_fPIE))
5532 CmdArgs.push_back("-pie");
5533 else
5534 CmdArgs.push_back("-no_pie");
5535 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005536
5537 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5538 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5539 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5540 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5541 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5542 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5543 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5544 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5545 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5546 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5547 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5548 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5549 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5550 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5551 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5552 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005553
Daniel Dunbar84384642011-05-02 21:03:47 +00005554 // Give --sysroot= preference, over the Apple specific behavior to also use
5555 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005556 StringRef sysroot = C.getSysRoot();
5557 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005558 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005559 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005560 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5561 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005562 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005563 }
5564
Daniel Dunbarc1964212009-03-26 16:23:12 +00005565 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5566 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5567 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5568 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5569 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005570 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005571 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5572 Args.AddAllArgs(CmdArgs, options::OPT_y);
5573 Args.AddLastArg(CmdArgs, options::OPT_w);
5574 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5575 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5576 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5577 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5578 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5579 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5580 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5581 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5582 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5583 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5584 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5585 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5586}
5587
Alexey Bataev186b28a2014-03-06 05:43:53 +00005588enum LibOpenMP {
5589 LibUnknown,
5590 LibGOMP,
5591 LibIOMP5
5592};
5593
Daniel Dunbarc1964212009-03-26 16:23:12 +00005594void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005595 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005596 const InputInfoList &Inputs,
5597 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005598 const char *LinkingOutput) const {
5599 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005600
Daniel Dunbarc1964212009-03-26 16:23:12 +00005601 // The logic here is derived from gcc's behavior; most of which
5602 // comes from specs (starting with link_command). Consult gcc for
5603 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005604 ArgStringList CmdArgs;
5605
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005606 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5607 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5608 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005609 for (const auto &Arg : Args)
5610 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005611 const char *Exec =
5612 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5613 CmdArgs.push_back(Output.getFilename());
5614 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5615 return;
5616 }
5617
Daniel Dunbarc1964212009-03-26 16:23:12 +00005618 // I'm not sure why this particular decomposition exists in gcc, but
5619 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005620 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005621
Daniel Dunbarc1964212009-03-26 16:23:12 +00005622 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5623 Args.AddAllArgs(CmdArgs, options::OPT_s);
5624 Args.AddAllArgs(CmdArgs, options::OPT_t);
5625 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5626 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005627 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005628 Args.AddAllArgs(CmdArgs, options::OPT_r);
5629
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005630 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5631 // members of static archive libraries which implement Objective-C classes or
5632 // categories.
5633 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5634 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005635
Daniel Dunbarc1964212009-03-26 16:23:12 +00005636 CmdArgs.push_back("-o");
5637 CmdArgs.push_back(Output.getFilename());
5638
Chad Rosier06fd3c62012-05-16 23:45:12 +00005639 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005640 !Args.hasArg(options::OPT_nostartfiles))
5641 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005642
5643 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005644
Alexey Bataev186b28a2014-03-06 05:43:53 +00005645 LibOpenMP UsedOpenMPLib = LibUnknown;
5646 if (Args.hasArg(options::OPT_fopenmp)) {
5647 UsedOpenMPLib = LibGOMP;
5648 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5649 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5650 .Case("libgomp", LibGOMP)
5651 .Case("libiomp5", LibIOMP5)
5652 .Default(LibUnknown);
5653 if (UsedOpenMPLib == LibUnknown)
5654 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5655 << A->getOption().getName() << A->getValue();
5656 }
5657 switch (UsedOpenMPLib) {
5658 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005659 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005660 break;
5661 case LibIOMP5:
5662 CmdArgs.push_back("-liomp5");
5663 break;
5664 case LibUnknown:
5665 break;
5666 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005667
Douglas Gregor9295df02012-05-15 21:00:27 +00005668 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5669
Bob Wilson16d93952012-05-15 18:57:39 +00005670 if (isObjCRuntimeLinked(Args) &&
5671 !Args.hasArg(options::OPT_nostdlib) &&
5672 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005673 // We use arclite library for both ARC and subscripting support.
5674 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5675
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005676 CmdArgs.push_back("-framework");
5677 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005678 // Link libobj.
5679 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005680 }
John McCall31168b02011-06-15 23:02:42 +00005681
Daniel Dunbarc1964212009-03-26 16:23:12 +00005682 if (LinkingOutput) {
5683 CmdArgs.push_back("-arch_multiple");
5684 CmdArgs.push_back("-final_output");
5685 CmdArgs.push_back(LinkingOutput);
5686 }
5687
Daniel Dunbarc1964212009-03-26 16:23:12 +00005688 if (Args.hasArg(options::OPT_fnested_functions))
5689 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005690
Daniel Dunbarc1964212009-03-26 16:23:12 +00005691 if (!Args.hasArg(options::OPT_nostdlib) &&
5692 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005693 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005694 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005695
Daniel Dunbarc1964212009-03-26 16:23:12 +00005696 // link_ssp spec is empty.
5697
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005698 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005699 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005700 }
5701
Chad Rosier06fd3c62012-05-16 23:45:12 +00005702 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005703 !Args.hasArg(options::OPT_nostartfiles)) {
5704 // endfile_spec is empty.
5705 }
5706
5707 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5708 Args.AddAllArgs(CmdArgs, options::OPT_F);
5709
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005710 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005711 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005712 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005713}
5714
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005715void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005716 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005717 const InputInfoList &Inputs,
5718 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005719 const char *LinkingOutput) const {
5720 ArgStringList CmdArgs;
5721
5722 CmdArgs.push_back("-create");
5723 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005724
5725 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005726 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005727
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005728 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005729 assert(II.isFilename() && "Unexpected lipo input.");
5730 CmdArgs.push_back(II.getFilename());
5731 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005732
5733 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005734 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005735}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005736
Daniel Dunbar88299622010-06-04 18:28:36 +00005737void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005738 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005739 const InputInfoList &Inputs,
5740 const ArgList &Args,
5741 const char *LinkingOutput) const {
5742 ArgStringList CmdArgs;
5743
Daniel Dunbareb86b042011-05-09 17:23:16 +00005744 CmdArgs.push_back("-o");
5745 CmdArgs.push_back(Output.getFilename());
5746
Daniel Dunbar88299622010-06-04 18:28:36 +00005747 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5748 const InputInfo &Input = Inputs[0];
5749 assert(Input.isFilename() && "Unexpected dsymutil input.");
5750 CmdArgs.push_back(Input.getFilename());
5751
Daniel Dunbar88299622010-06-04 18:28:36 +00005752 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005753 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005754 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005755}
5756
Eric Christopher551ef452011-08-23 17:56:55 +00005757void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005758 const InputInfo &Output,
5759 const InputInfoList &Inputs,
5760 const ArgList &Args,
5761 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005762 ArgStringList CmdArgs;
5763 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005764 CmdArgs.push_back("--debug-info");
5765 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005766 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005767
5768 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5769 const InputInfo &Input = Inputs[0];
5770 assert(Input.isFilename() && "Unexpected verify input");
5771
5772 // Grabbing the output of the earlier dsymutil run.
5773 CmdArgs.push_back(Input.getFilename());
5774
5775 const char *Exec =
5776 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5777 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5778}
5779
David Chisnallf571cde2012-02-15 13:39:01 +00005780void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5781 const InputInfo &Output,
5782 const InputInfoList &Inputs,
5783 const ArgList &Args,
5784 const char *LinkingOutput) const {
5785 ArgStringList CmdArgs;
5786
5787 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5788 options::OPT_Xassembler);
5789
5790 CmdArgs.push_back("-o");
5791 CmdArgs.push_back(Output.getFilename());
5792
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005793 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005794 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005795
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005796 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Chisnallf571cde2012-02-15 13:39:01 +00005797 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5798}
5799
David Chisnallf571cde2012-02-15 13:39:01 +00005800void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5801 const InputInfo &Output,
5802 const InputInfoList &Inputs,
5803 const ArgList &Args,
5804 const char *LinkingOutput) const {
5805 // FIXME: Find a real GCC, don't hard-code versions here
5806 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5807 const llvm::Triple &T = getToolChain().getTriple();
5808 std::string LibPath = "/usr/lib/";
5809 llvm::Triple::ArchType Arch = T.getArch();
5810 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005811 case llvm::Triple::x86:
5812 GCCLibPath +=
5813 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5814 break;
5815 case llvm::Triple::x86_64:
5816 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5817 GCCLibPath += "/4.5.2/amd64/";
5818 LibPath += "amd64/";
5819 break;
5820 default:
5821 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005822 }
5823
5824 ArgStringList CmdArgs;
5825
David Chisnall272a0712012-02-29 15:06:12 +00005826 // Demangle C++ names in errors
5827 CmdArgs.push_back("-C");
5828
David Chisnallf571cde2012-02-15 13:39:01 +00005829 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5830 (!Args.hasArg(options::OPT_shared))) {
5831 CmdArgs.push_back("-e");
5832 CmdArgs.push_back("_start");
5833 }
5834
5835 if (Args.hasArg(options::OPT_static)) {
5836 CmdArgs.push_back("-Bstatic");
5837 CmdArgs.push_back("-dn");
5838 } else {
5839 CmdArgs.push_back("-Bdynamic");
5840 if (Args.hasArg(options::OPT_shared)) {
5841 CmdArgs.push_back("-shared");
5842 } else {
5843 CmdArgs.push_back("--dynamic-linker");
5844 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5845 }
5846 }
5847
5848 if (Output.isFilename()) {
5849 CmdArgs.push_back("-o");
5850 CmdArgs.push_back(Output.getFilename());
5851 } else {
5852 assert(Output.isNothing() && "Invalid output.");
5853 }
5854
5855 if (!Args.hasArg(options::OPT_nostdlib) &&
5856 !Args.hasArg(options::OPT_nostartfiles)) {
5857 if (!Args.hasArg(options::OPT_shared)) {
5858 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5859 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005860 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005861 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5862 } else {
5863 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005864 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5865 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005866 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005867 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005868 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005869 }
5870
5871 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5872
5873 Args.AddAllArgs(CmdArgs, options::OPT_L);
5874 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5875 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005876 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005877
5878 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5879
5880 if (!Args.hasArg(options::OPT_nostdlib) &&
5881 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005882 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005883 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005884 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005885 if (!Args.hasArg(options::OPT_shared)) {
5886 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005887 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005888 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005889 }
David Chisnallf571cde2012-02-15 13:39:01 +00005890 }
5891
5892 if (!Args.hasArg(options::OPT_nostdlib) &&
5893 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005894 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005895 }
David Chisnall96de9932012-02-16 16:00:47 +00005896 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005897
Alexey Samsonov7811d192014-02-20 13:57:37 +00005898 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005899
5900 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005901 Args.MakeArgString(getToolChain().GetLinkerPath());
David Chisnallf571cde2012-02-15 13:39:01 +00005902 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5903}
5904
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005905void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005906 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005907 const InputInfoList &Inputs,
5908 const ArgList &Args,
5909 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005910 ArgStringList CmdArgs;
5911
5912 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5913 options::OPT_Xassembler);
5914
5915 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005916 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005917
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005918 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00005919 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005920
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005921 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005922 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005923}
5924
5925void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005926 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005927 const InputInfoList &Inputs,
5928 const ArgList &Args,
5929 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005930 ArgStringList CmdArgs;
5931
5932 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005933 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005934 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005935 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005936 }
5937
5938 if (Args.hasArg(options::OPT_static)) {
5939 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005940 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005941 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005942// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005943 CmdArgs.push_back("-Bdynamic");
5944 if (Args.hasArg(options::OPT_shared)) {
5945 CmdArgs.push_back("-shared");
5946 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005947 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005948 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5949 }
5950 }
5951
Daniel Dunbarb440f562010-08-02 02:38:21 +00005952 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005953 CmdArgs.push_back("-o");
5954 CmdArgs.push_back(Output.getFilename());
5955 } else {
5956 assert(Output.isNothing() && "Invalid output.");
5957 }
5958
5959 if (!Args.hasArg(options::OPT_nostdlib) &&
5960 !Args.hasArg(options::OPT_nostartfiles)) {
5961 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005962 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005963 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005964 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005965 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005966 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005967 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005968 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005969 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005970 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005971 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005972 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005973 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005974 }
5975
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005976 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5977 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005978 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005979
5980 Args.AddAllArgs(CmdArgs, options::OPT_L);
5981 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5982 Args.AddAllArgs(CmdArgs, options::OPT_e);
5983
Daniel Dunbar54423b22010-09-17 00:24:54 +00005984 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005985
5986 if (!Args.hasArg(options::OPT_nostdlib) &&
5987 !Args.hasArg(options::OPT_nodefaultlibs)) {
5988 // FIXME: For some reason GCC passes -lgcc before adding
5989 // the default system libraries. Just mimic this for now.
5990 CmdArgs.push_back("-lgcc");
5991
5992 if (Args.hasArg(options::OPT_pthread))
5993 CmdArgs.push_back("-pthread");
5994 if (!Args.hasArg(options::OPT_shared))
5995 CmdArgs.push_back("-lc");
5996 CmdArgs.push_back("-lgcc");
5997 }
5998
5999 if (!Args.hasArg(options::OPT_nostdlib) &&
6000 !Args.hasArg(options::OPT_nostartfiles)) {
6001 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006002 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006003 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006004 }
6005
Alexey Samsonov7811d192014-02-20 13:57:37 +00006006 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006007
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006008 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006009 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006010 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00006011}
6012
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006013void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006014 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006015 const InputInfoList &Inputs,
6016 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006017 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006018 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006019 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006020
Rafael Espindolacc126272014-02-28 01:55:21 +00006021 switch (getToolChain().getArch()) {
6022 case llvm::Triple::x86:
6023 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6024 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006025 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006026 break;
6027
6028 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006029 CmdArgs.push_back("-mppc");
6030 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006031 break;
6032
6033 case llvm::Triple::sparc:
6034 CmdArgs.push_back("-32");
6035 NeedsKPIC = true;
6036 break;
6037
6038 case llvm::Triple::sparcv9:
6039 CmdArgs.push_back("-64");
6040 CmdArgs.push_back("-Av9a");
6041 NeedsKPIC = true;
6042 break;
6043
6044 case llvm::Triple::mips64:
6045 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006046 StringRef CPUName;
6047 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006048 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006049
6050 CmdArgs.push_back("-mabi");
6051 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6052
6053 if (getToolChain().getArch() == llvm::Triple::mips64)
6054 CmdArgs.push_back("-EB");
6055 else
6056 CmdArgs.push_back("-EL");
6057
Rafael Espindolacc126272014-02-28 01:55:21 +00006058 NeedsKPIC = true;
6059 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006060 }
6061
Rafael Espindolacc126272014-02-28 01:55:21 +00006062 default:
6063 break;
6064 }
6065
6066 if (NeedsKPIC)
6067 addAssemblerKPIC(Args, CmdArgs);
6068
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006069 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6070 options::OPT_Xassembler);
6071
6072 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006073 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006074
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006075 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006076 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006077
6078 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006079 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006080 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006081}
6082
6083void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006084 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006085 const InputInfoList &Inputs,
6086 const ArgList &Args,
6087 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006088 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006089 ArgStringList CmdArgs;
6090
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006091 // Silence warning for "clang -g foo.o -o foo"
6092 Args.ClaimAllArgs(options::OPT_g_Group);
6093 // and "clang -emit-llvm foo.o -o foo"
6094 Args.ClaimAllArgs(options::OPT_emit_llvm);
6095 // and for "clang -w foo.o -o foo". Other warning options are already
6096 // handled somewhere else.
6097 Args.ClaimAllArgs(options::OPT_w);
6098
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006099 if (getToolChain().getArch() == llvm::Triple::mips64)
6100 CmdArgs.push_back("-EB");
6101 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6102 CmdArgs.push_back("-EL");
6103
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006104 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006105 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006106 CmdArgs.push_back("-e");
6107 CmdArgs.push_back("__start");
6108 }
6109
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006110 if (Args.hasArg(options::OPT_static)) {
6111 CmdArgs.push_back("-Bstatic");
6112 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006113 if (Args.hasArg(options::OPT_rdynamic))
6114 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006115 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006116 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006117 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006118 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006119 } else {
6120 CmdArgs.push_back("-dynamic-linker");
6121 CmdArgs.push_back("/usr/libexec/ld.so");
6122 }
6123 }
6124
Rafael Espindola044f7832013-06-05 04:28:55 +00006125 if (Args.hasArg(options::OPT_nopie))
6126 CmdArgs.push_back("-nopie");
6127
Daniel Dunbarb440f562010-08-02 02:38:21 +00006128 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006129 CmdArgs.push_back("-o");
6130 CmdArgs.push_back(Output.getFilename());
6131 } else {
6132 assert(Output.isNothing() && "Invalid output.");
6133 }
6134
6135 if (!Args.hasArg(options::OPT_nostdlib) &&
6136 !Args.hasArg(options::OPT_nostartfiles)) {
6137 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006138 if (Args.hasArg(options::OPT_pg))
6139 CmdArgs.push_back(Args.MakeArgString(
6140 getToolChain().GetFilePath("gcrt0.o")));
6141 else
6142 CmdArgs.push_back(Args.MakeArgString(
6143 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006144 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006145 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006146 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006147 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006148 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006149 }
6150 }
6151
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006152 std::string Triple = getToolChain().getTripleString();
6153 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006154 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006155 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006156 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006157
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006158 Args.AddAllArgs(CmdArgs, options::OPT_L);
6159 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6160 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006161 Args.AddAllArgs(CmdArgs, options::OPT_s);
6162 Args.AddAllArgs(CmdArgs, options::OPT_t);
6163 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6164 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006165
Daniel Dunbar54423b22010-09-17 00:24:54 +00006166 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006167
6168 if (!Args.hasArg(options::OPT_nostdlib) &&
6169 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006170 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006171 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006172 if (Args.hasArg(options::OPT_pg))
6173 CmdArgs.push_back("-lm_p");
6174 else
6175 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006176 }
6177
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006178 // FIXME: For some reason GCC passes -lgcc before adding
6179 // the default system libraries. Just mimic this for now.
6180 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006181
Eric Christopher17674ec2012-09-13 06:32:34 +00006182 if (Args.hasArg(options::OPT_pthread)) {
6183 if (!Args.hasArg(options::OPT_shared) &&
6184 Args.hasArg(options::OPT_pg))
6185 CmdArgs.push_back("-lpthread_p");
6186 else
6187 CmdArgs.push_back("-lpthread");
6188 }
6189
Chandler Carruth45661652011-12-17 22:32:42 +00006190 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006191 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006192 CmdArgs.push_back("-lc_p");
6193 else
6194 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006195 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006196
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006197 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006198 }
6199
6200 if (!Args.hasArg(options::OPT_nostdlib) &&
6201 !Args.hasArg(options::OPT_nostartfiles)) {
6202 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006203 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006204 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006205 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006206 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006207 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006208 }
6209
6210 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006211 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006212 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006213}
Ed Schoutene33194b2009-04-02 19:13:12 +00006214
Eli Friedman9fa28852012-08-08 23:57:20 +00006215void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6216 const InputInfo &Output,
6217 const InputInfoList &Inputs,
6218 const ArgList &Args,
6219 const char *LinkingOutput) const {
6220 ArgStringList CmdArgs;
6221
6222 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6223 options::OPT_Xassembler);
6224
6225 CmdArgs.push_back("-o");
6226 CmdArgs.push_back(Output.getFilename());
6227
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006228 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006229 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006230
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006231 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Eli Friedman9fa28852012-08-08 23:57:20 +00006232 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6233}
6234
6235void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6236 const InputInfo &Output,
6237 const InputInfoList &Inputs,
6238 const ArgList &Args,
6239 const char *LinkingOutput) const {
6240 const Driver &D = getToolChain().getDriver();
6241 ArgStringList CmdArgs;
6242
6243 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6244 (!Args.hasArg(options::OPT_shared))) {
6245 CmdArgs.push_back("-e");
6246 CmdArgs.push_back("__start");
6247 }
6248
6249 if (Args.hasArg(options::OPT_static)) {
6250 CmdArgs.push_back("-Bstatic");
6251 } else {
6252 if (Args.hasArg(options::OPT_rdynamic))
6253 CmdArgs.push_back("-export-dynamic");
6254 CmdArgs.push_back("--eh-frame-hdr");
6255 CmdArgs.push_back("-Bdynamic");
6256 if (Args.hasArg(options::OPT_shared)) {
6257 CmdArgs.push_back("-shared");
6258 } else {
6259 CmdArgs.push_back("-dynamic-linker");
6260 CmdArgs.push_back("/usr/libexec/ld.so");
6261 }
6262 }
6263
6264 if (Output.isFilename()) {
6265 CmdArgs.push_back("-o");
6266 CmdArgs.push_back(Output.getFilename());
6267 } else {
6268 assert(Output.isNothing() && "Invalid output.");
6269 }
6270
6271 if (!Args.hasArg(options::OPT_nostdlib) &&
6272 !Args.hasArg(options::OPT_nostartfiles)) {
6273 if (!Args.hasArg(options::OPT_shared)) {
6274 if (Args.hasArg(options::OPT_pg))
6275 CmdArgs.push_back(Args.MakeArgString(
6276 getToolChain().GetFilePath("gcrt0.o")));
6277 else
6278 CmdArgs.push_back(Args.MakeArgString(
6279 getToolChain().GetFilePath("crt0.o")));
6280 CmdArgs.push_back(Args.MakeArgString(
6281 getToolChain().GetFilePath("crtbegin.o")));
6282 } else {
6283 CmdArgs.push_back(Args.MakeArgString(
6284 getToolChain().GetFilePath("crtbeginS.o")));
6285 }
6286 }
6287
6288 Args.AddAllArgs(CmdArgs, options::OPT_L);
6289 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6290 Args.AddAllArgs(CmdArgs, options::OPT_e);
6291
6292 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6293
6294 if (!Args.hasArg(options::OPT_nostdlib) &&
6295 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006296 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006297 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6298 if (Args.hasArg(options::OPT_pg))
6299 CmdArgs.push_back("-lm_p");
6300 else
6301 CmdArgs.push_back("-lm");
6302 }
6303
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006304 if (Args.hasArg(options::OPT_pthread)) {
6305 if (!Args.hasArg(options::OPT_shared) &&
6306 Args.hasArg(options::OPT_pg))
6307 CmdArgs.push_back("-lpthread_p");
6308 else
6309 CmdArgs.push_back("-lpthread");
6310 }
6311
Eli Friedman9fa28852012-08-08 23:57:20 +00006312 if (!Args.hasArg(options::OPT_shared)) {
6313 if (Args.hasArg(options::OPT_pg))
6314 CmdArgs.push_back("-lc_p");
6315 else
6316 CmdArgs.push_back("-lc");
6317 }
6318
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006319 StringRef MyArch;
6320 switch (getToolChain().getTriple().getArch()) {
6321 case llvm::Triple::arm:
6322 MyArch = "arm";
6323 break;
6324 case llvm::Triple::x86:
6325 MyArch = "i386";
6326 break;
6327 case llvm::Triple::x86_64:
6328 MyArch = "amd64";
6329 break;
6330 default:
6331 llvm_unreachable("Unsupported architecture");
6332 }
6333 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006334 }
6335
6336 if (!Args.hasArg(options::OPT_nostdlib) &&
6337 !Args.hasArg(options::OPT_nostartfiles)) {
6338 if (!Args.hasArg(options::OPT_shared))
6339 CmdArgs.push_back(Args.MakeArgString(
6340 getToolChain().GetFilePath("crtend.o")));
6341 else
6342 CmdArgs.push_back(Args.MakeArgString(
6343 getToolChain().GetFilePath("crtendS.o")));
6344 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006345
6346 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006347 Args.MakeArgString(getToolChain().GetLinkerPath());
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006348 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006349}
6350
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006351void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006352 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006353 const InputInfoList &Inputs,
6354 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006355 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006356 ArgStringList CmdArgs;
6357
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006358 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6359 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006360 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006361 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006362 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006363 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006364 else if (getToolChain().getArch() == llvm::Triple::mips ||
6365 getToolChain().getArch() == llvm::Triple::mipsel ||
6366 getToolChain().getArch() == llvm::Triple::mips64 ||
6367 getToolChain().getArch() == llvm::Triple::mips64el) {
6368 StringRef CPUName;
6369 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006370 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006371
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006372 CmdArgs.push_back("-march");
6373 CmdArgs.push_back(CPUName.data());
6374
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006375 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006376 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006377
6378 if (getToolChain().getArch() == llvm::Triple::mips ||
6379 getToolChain().getArch() == llvm::Triple::mips64)
6380 CmdArgs.push_back("-EB");
6381 else
6382 CmdArgs.push_back("-EL");
6383
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006384 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006385 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006386 getToolChain().getArch() == llvm::Triple::armeb ||
6387 getToolChain().getArch() == llvm::Triple::thumb ||
6388 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006389 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006390 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006391 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6392
6393 if (FloatABI == "hard") {
6394 CmdArgs.push_back("-mfpu=vfp");
6395 } else {
6396 CmdArgs.push_back("-mfpu=softvfp");
6397 }
6398
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006399 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006400 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006401 case llvm::Triple::GNUEABI:
6402 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006403 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006404 break;
6405
6406 default:
6407 CmdArgs.push_back("-matpcs");
6408 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006409 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006410 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006411 if (getToolChain().getArch() == llvm::Triple::sparc)
6412 CmdArgs.push_back("-Av8plusa");
6413 else
6414 CmdArgs.push_back("-Av9a");
6415
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006416 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006417 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006418
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006419 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6420 options::OPT_Xassembler);
6421
6422 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006423 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006424
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006425 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006426 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006427
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006428 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006429 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006430}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006431
6432void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006433 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006434 const InputInfoList &Inputs,
6435 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006436 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006437 const toolchains::FreeBSD& ToolChain =
6438 static_cast<const toolchains::FreeBSD&>(getToolChain());
6439 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006440 const bool IsPIE =
6441 !Args.hasArg(options::OPT_shared) &&
6442 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006443 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006444
6445 // Silence warning for "clang -g foo.o -o foo"
6446 Args.ClaimAllArgs(options::OPT_g_Group);
6447 // and "clang -emit-llvm foo.o -o foo"
6448 Args.ClaimAllArgs(options::OPT_emit_llvm);
6449 // and for "clang -w foo.o -o foo". Other warning options are already
6450 // handled somewhere else.
6451 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006452
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006453 if (!D.SysRoot.empty())
6454 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6455
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006456 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006457 CmdArgs.push_back("-pie");
6458
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006459 if (Args.hasArg(options::OPT_static)) {
6460 CmdArgs.push_back("-Bstatic");
6461 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006462 if (Args.hasArg(options::OPT_rdynamic))
6463 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006464 CmdArgs.push_back("--eh-frame-hdr");
6465 if (Args.hasArg(options::OPT_shared)) {
6466 CmdArgs.push_back("-Bshareable");
6467 } else {
6468 CmdArgs.push_back("-dynamic-linker");
6469 CmdArgs.push_back("/libexec/ld-elf.so.1");
6470 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006471 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6472 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006473 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6474 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6475 CmdArgs.push_back("--hash-style=both");
6476 }
6477 }
6478 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006479 }
6480
6481 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6482 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006483 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006484 CmdArgs.push_back("-m");
6485 CmdArgs.push_back("elf_i386_fbsd");
6486 }
6487
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006488 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006489 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006490 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006491 }
6492
Daniel Dunbarb440f562010-08-02 02:38:21 +00006493 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006494 CmdArgs.push_back("-o");
6495 CmdArgs.push_back(Output.getFilename());
6496 } else {
6497 assert(Output.isNothing() && "Invalid output.");
6498 }
6499
6500 if (!Args.hasArg(options::OPT_nostdlib) &&
6501 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006502 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006503 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006504 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006505 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006506 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006507 crt1 = "Scrt1.o";
6508 else
6509 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006510 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006511 if (crt1)
6512 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6513
6514 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6515
Craig Topper92fc2df2014-05-17 16:56:41 +00006516 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006517 if (Args.hasArg(options::OPT_static))
6518 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006519 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006520 crtbegin = "crtbeginS.o";
6521 else
6522 crtbegin = "crtbegin.o";
6523
6524 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006525 }
6526
6527 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006528 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006529 for (const auto &Path : Paths)
6530 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006531 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6532 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006533 Args.AddAllArgs(CmdArgs, options::OPT_s);
6534 Args.AddAllArgs(CmdArgs, options::OPT_t);
6535 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6536 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006537
Alp Tokerce365ca2013-12-02 12:43:03 +00006538 if (D.IsUsingLTO(Args))
6539 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006540
Roman Divackyafe2f232012-08-28 15:09:03 +00006541 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006542
6543 if (!Args.hasArg(options::OPT_nostdlib) &&
6544 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006545 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006546 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006547 if (Args.hasArg(options::OPT_pg))
6548 CmdArgs.push_back("-lm_p");
6549 else
6550 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006551 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006552 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6553 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006554 if (Args.hasArg(options::OPT_pg))
6555 CmdArgs.push_back("-lgcc_p");
6556 else
6557 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006558 if (Args.hasArg(options::OPT_static)) {
6559 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006560 } else if (Args.hasArg(options::OPT_pg)) {
6561 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006562 } else {
6563 CmdArgs.push_back("--as-needed");
6564 CmdArgs.push_back("-lgcc_s");
6565 CmdArgs.push_back("--no-as-needed");
6566 }
6567
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006568 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006569 if (Args.hasArg(options::OPT_pg))
6570 CmdArgs.push_back("-lpthread_p");
6571 else
6572 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006573 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006574
Roman Divacky66f22762011-02-10 16:59:40 +00006575 if (Args.hasArg(options::OPT_pg)) {
6576 if (Args.hasArg(options::OPT_shared))
6577 CmdArgs.push_back("-lc");
6578 else
6579 CmdArgs.push_back("-lc_p");
6580 CmdArgs.push_back("-lgcc_p");
6581 } else {
6582 CmdArgs.push_back("-lc");
6583 CmdArgs.push_back("-lgcc");
6584 }
6585
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006586 if (Args.hasArg(options::OPT_static)) {
6587 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006588 } else if (Args.hasArg(options::OPT_pg)) {
6589 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006590 } else {
6591 CmdArgs.push_back("--as-needed");
6592 CmdArgs.push_back("-lgcc_s");
6593 CmdArgs.push_back("--no-as-needed");
6594 }
6595 }
6596
6597 if (!Args.hasArg(options::OPT_nostdlib) &&
6598 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006599 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006600 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006601 else
6602 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006603 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006604 }
6605
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006606 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6607
Alexey Samsonov7811d192014-02-20 13:57:37 +00006608 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006609
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006610 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006611 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006612 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006613}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006614
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006615void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6616 const InputInfo &Output,
6617 const InputInfoList &Inputs,
6618 const ArgList &Args,
6619 const char *LinkingOutput) const {
6620 ArgStringList CmdArgs;
6621
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006622 // GNU as needs different flags for creating the correct output format
6623 // on architectures with different ABIs or optional feature sets.
6624 switch (getToolChain().getArch()) {
6625 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006626 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006627 break;
6628 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006629 case llvm::Triple::armeb:
6630 case llvm::Triple::thumb:
6631 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006632 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006633 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006634 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006635 }
6636
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006637 case llvm::Triple::mips:
6638 case llvm::Triple::mipsel:
6639 case llvm::Triple::mips64:
6640 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006641 StringRef CPUName;
6642 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006643 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006644
6645 CmdArgs.push_back("-march");
6646 CmdArgs.push_back(CPUName.data());
6647
6648 CmdArgs.push_back("-mabi");
6649 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6650
6651 if (getToolChain().getArch() == llvm::Triple::mips ||
6652 getToolChain().getArch() == llvm::Triple::mips64)
6653 CmdArgs.push_back("-EB");
6654 else
6655 CmdArgs.push_back("-EL");
6656
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006657 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006658 break;
6659 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006660
6661 case llvm::Triple::sparc:
6662 CmdArgs.push_back("-32");
6663 addAssemblerKPIC(Args, CmdArgs);
6664 break;
6665
6666 case llvm::Triple::sparcv9:
6667 CmdArgs.push_back("-64");
6668 CmdArgs.push_back("-Av9");
6669 addAssemblerKPIC(Args, CmdArgs);
6670 break;
6671
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006672 default:
6673 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006674 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006675
6676 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6677 options::OPT_Xassembler);
6678
6679 CmdArgs.push_back("-o");
6680 CmdArgs.push_back(Output.getFilename());
6681
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006682 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006683 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006684
David Chisnallddbd68f2011-09-27 22:03:18 +00006685 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006686 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6687}
6688
6689void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6690 const InputInfo &Output,
6691 const InputInfoList &Inputs,
6692 const ArgList &Args,
6693 const char *LinkingOutput) const {
6694 const Driver &D = getToolChain().getDriver();
6695 ArgStringList CmdArgs;
6696
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006697 if (!D.SysRoot.empty())
6698 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6699
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006700 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006701 if (Args.hasArg(options::OPT_static)) {
6702 CmdArgs.push_back("-Bstatic");
6703 } else {
6704 if (Args.hasArg(options::OPT_rdynamic))
6705 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006706 if (Args.hasArg(options::OPT_shared)) {
6707 CmdArgs.push_back("-Bshareable");
6708 } else {
6709 CmdArgs.push_back("-dynamic-linker");
6710 CmdArgs.push_back("/libexec/ld.elf_so");
6711 }
6712 }
6713
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006714 // Many NetBSD architectures support more than one ABI.
6715 // Determine the correct emulation for ld.
6716 switch (getToolChain().getArch()) {
6717 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006718 CmdArgs.push_back("-m");
6719 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006720 break;
6721 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006722 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006723 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006724 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006725 CmdArgs.push_back("-m");
6726 switch (getToolChain().getTriple().getEnvironment()) {
6727 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006728 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006729 CmdArgs.push_back("armelf_nbsd_eabi");
6730 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006731 case llvm::Triple::EABIHF:
6732 case llvm::Triple::GNUEABIHF:
6733 CmdArgs.push_back("armelf_nbsd_eabihf");
6734 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006735 default:
6736 CmdArgs.push_back("armelf_nbsd");
6737 break;
6738 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006739 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006740 case llvm::Triple::mips64:
6741 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006742 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006743 CmdArgs.push_back("-m");
6744 if (getToolChain().getArch() == llvm::Triple::mips64)
6745 CmdArgs.push_back("elf32btsmip");
6746 else
6747 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006748 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006749 CmdArgs.push_back("-m");
6750 if (getToolChain().getArch() == llvm::Triple::mips64)
6751 CmdArgs.push_back("elf64btsmip");
6752 else
6753 CmdArgs.push_back("elf64ltsmip");
6754 }
6755 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006756
6757 case llvm::Triple::sparc:
6758 CmdArgs.push_back("-m");
6759 CmdArgs.push_back("elf32_sparc");
6760 break;
6761
6762 case llvm::Triple::sparcv9:
6763 CmdArgs.push_back("-m");
6764 CmdArgs.push_back("elf64_sparc");
6765 break;
6766
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006767 default:
6768 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006769 }
6770
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006771 if (Output.isFilename()) {
6772 CmdArgs.push_back("-o");
6773 CmdArgs.push_back(Output.getFilename());
6774 } else {
6775 assert(Output.isNothing() && "Invalid output.");
6776 }
6777
6778 if (!Args.hasArg(options::OPT_nostdlib) &&
6779 !Args.hasArg(options::OPT_nostartfiles)) {
6780 if (!Args.hasArg(options::OPT_shared)) {
6781 CmdArgs.push_back(Args.MakeArgString(
6782 getToolChain().GetFilePath("crt0.o")));
6783 CmdArgs.push_back(Args.MakeArgString(
6784 getToolChain().GetFilePath("crti.o")));
6785 CmdArgs.push_back(Args.MakeArgString(
6786 getToolChain().GetFilePath("crtbegin.o")));
6787 } else {
6788 CmdArgs.push_back(Args.MakeArgString(
6789 getToolChain().GetFilePath("crti.o")));
6790 CmdArgs.push_back(Args.MakeArgString(
6791 getToolChain().GetFilePath("crtbeginS.o")));
6792 }
6793 }
6794
6795 Args.AddAllArgs(CmdArgs, options::OPT_L);
6796 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6797 Args.AddAllArgs(CmdArgs, options::OPT_e);
6798 Args.AddAllArgs(CmdArgs, options::OPT_s);
6799 Args.AddAllArgs(CmdArgs, options::OPT_t);
6800 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6801 Args.AddAllArgs(CmdArgs, options::OPT_r);
6802
6803 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6804
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006805 unsigned Major, Minor, Micro;
6806 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6807 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006808 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006809 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006810 case llvm::Triple::arm:
6811 case llvm::Triple::armeb:
6812 case llvm::Triple::thumb:
6813 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006814 case llvm::Triple::x86:
6815 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006816 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006817 break;
6818 default:
6819 break;
6820 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006821 }
6822
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006823 if (!Args.hasArg(options::OPT_nostdlib) &&
6824 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006825 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006826 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6827 CmdArgs.push_back("-lm");
6828 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006829 if (Args.hasArg(options::OPT_pthread))
6830 CmdArgs.push_back("-lpthread");
6831 CmdArgs.push_back("-lc");
6832
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006833 if (useLibgcc) {
6834 if (Args.hasArg(options::OPT_static)) {
6835 // libgcc_eh depends on libc, so resolve as much as possible,
6836 // pull in any new requirements from libc and then get the rest
6837 // of libgcc.
6838 CmdArgs.push_back("-lgcc_eh");
6839 CmdArgs.push_back("-lc");
6840 CmdArgs.push_back("-lgcc");
6841 } else {
6842 CmdArgs.push_back("-lgcc");
6843 CmdArgs.push_back("--as-needed");
6844 CmdArgs.push_back("-lgcc_s");
6845 CmdArgs.push_back("--no-as-needed");
6846 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006847 }
6848 }
6849
6850 if (!Args.hasArg(options::OPT_nostdlib) &&
6851 !Args.hasArg(options::OPT_nostartfiles)) {
6852 if (!Args.hasArg(options::OPT_shared))
6853 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6854 "crtend.o")));
6855 else
6856 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6857 "crtendS.o")));
6858 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6859 "crtn.o")));
6860 }
6861
Alexey Samsonov7811d192014-02-20 13:57:37 +00006862 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006863
Logan Chieneb9162f2014-06-26 14:23:45 +00006864 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006865 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6866}
6867
Thomas Schwinge4e555262013-03-28 19:04:25 +00006868void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6869 const InputInfo &Output,
6870 const InputInfoList &Inputs,
6871 const ArgList &Args,
6872 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006873 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006874 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006875
6876 // Add --32/--64 to make sure we get the format we want.
6877 // This is incomplete
6878 if (getToolChain().getArch() == llvm::Triple::x86) {
6879 CmdArgs.push_back("--32");
6880 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00006881 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
6882 CmdArgs.push_back("--x32");
6883 else
6884 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006885 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6886 CmdArgs.push_back("-a32");
6887 CmdArgs.push_back("-mppc");
6888 CmdArgs.push_back("-many");
6889 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6890 CmdArgs.push_back("-a64");
6891 CmdArgs.push_back("-mppc64");
6892 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006893 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6894 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006895 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006896 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006897 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006898 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6899 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006900 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006901 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006902 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6903 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006904 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006905 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006906 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6907 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006908 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006909 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6910 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006911 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6912 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006913 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006914
Tim Northover9c7e0352013-12-12 11:55:52 +00006915 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6916 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006917 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006918
6919 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006920
6921 // FIXME: remove krait check when GNU tools support krait cpu
6922 // for now replace it with -march=armv7-a to avoid a lower
6923 // march from being picked in the absence of a cpu flag.
6924 Arg *A;
6925 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6926 StringRef(A->getValue()) == "krait")
6927 CmdArgs.push_back("-march=armv7-a");
6928 else
6929 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006930 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006931 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6932 getToolChain().getArch() == llvm::Triple::mipsel ||
6933 getToolChain().getArch() == llvm::Triple::mips64 ||
6934 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006935 StringRef CPUName;
6936 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006937 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00006938 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006939
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006940 CmdArgs.push_back("-march");
6941 CmdArgs.push_back(CPUName.data());
6942
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006943 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00006944 CmdArgs.push_back(ABIName.data());
6945
6946 // LLVM doesn't support -mabicalls yet and acts as if it is always given.
6947 CmdArgs.push_back("-mno-shared");
6948 // LLVM doesn't support -mplt yet and acts as if it is always given.
6949 // However, -mplt has no effect with the N64 ABI.
6950 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006951
6952 if (getToolChain().getArch() == llvm::Triple::mips ||
6953 getToolChain().getArch() == llvm::Triple::mips64)
6954 CmdArgs.push_back("-EB");
6955 else
6956 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006957
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006958 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6959 if (StringRef(A->getValue()) == "2008")
6960 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6961 }
6962
Daniel Sanders379d44b2014-07-16 11:52:23 +00006963 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
6964 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
6965 options::OPT_mfp64)) {
6966 A->claim();
6967 A->render(Args, CmdArgs);
6968 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
6969 ABIName))
6970 CmdArgs.push_back("-mfpxx");
6971
6972 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
6973 // -mno-mips16 is actually -no-mips16.
6974 if (Arg *A = Args.getLastArg(options::OPT_mips16,
6975 options::OPT_mno_mips16)) {
6976 if (A->getOption().matches(options::OPT_mips16)) {
6977 A->claim();
6978 A->render(Args, CmdArgs);
6979 } else {
6980 A->claim();
6981 CmdArgs.push_back("-no-mips16");
6982 }
6983 }
6984
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006985 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6986 options::OPT_mno_micromips);
6987 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6988 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6989
Simon Atanasyanbd986632013-11-26 11:58:04 +00006990 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6991 // Do not use AddLastArg because not all versions of MIPS assembler
6992 // support -mmsa / -mno-msa options.
6993 if (A->getOption().matches(options::OPT_mmsa))
6994 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6995 }
6996
Daniel Sanders379d44b2014-07-16 11:52:23 +00006997 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
6998 options::OPT_msoft_float);
6999
7000 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7001 options::OPT_mno_odd_spreg);
7002
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007003 NeedsKPIC = true;
7004 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7005 // Always pass an -march option, since our default of z10 is later
7006 // than the GNU assembler's default.
7007 StringRef CPUName = getSystemZTargetCPU(Args);
7008 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7009 }
7010
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007011 if (NeedsKPIC)
7012 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007013
7014 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7015 options::OPT_Xassembler);
7016
7017 CmdArgs.push_back("-o");
7018 CmdArgs.push_back(Output.getFilename());
7019
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007020 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007021 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007022
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007023 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Rafael Espindola92b00932010-08-10 00:25:48 +00007024 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007025
7026 // Handle the debug info splitting at object creation time if we're
7027 // creating an object.
7028 // TODO: Currently only works on linux with newer objcopy.
7029 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007030 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007031 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7032 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007033}
7034
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007035static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007036 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007037 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007038 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7039 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007040 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007041 CmdArgs.push_back("-lgcc");
7042
Logan Chien3d3373c2012-11-19 12:04:11 +00007043 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007044 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007045 CmdArgs.push_back("-lgcc");
7046 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007047 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007048 CmdArgs.push_back("--as-needed");
7049 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007050 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007051 CmdArgs.push_back("--no-as-needed");
7052 }
7053
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007054 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007055 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007056 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007057 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007058
7059 // According to Android ABI, we have to link with libdl if we are
7060 // linking with non-static libgcc.
7061 //
7062 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7063 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7064 if (isAndroid && !StaticLibgcc)
7065 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007066}
7067
Simon Atanasyan14ce18d2014-06-25 05:00:59 +00007068static StringRef getLinuxDynamicLinker(const ArgList &Args,
7069 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007070 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7071 if (ToolChain.getTriple().isArch64Bit())
7072 return "/system/bin/linker64";
7073 else
7074 return "/system/bin/linker";
7075 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7076 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007077 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00007078 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7079 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007080 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00007081 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7082 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007083 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007084 else if (ToolChain.getArch() == llvm::Triple::arm ||
7085 ToolChain.getArch() == llvm::Triple::thumb) {
7086 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7087 return "/lib/ld-linux-armhf.so.3";
7088 else
7089 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007090 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7091 ToolChain.getArch() == llvm::Triple::thumbeb) {
7092 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7093 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7094 else
7095 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007096 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007097 ToolChain.getArch() == llvm::Triple::mipsel) {
Daniel Sanders2bf13662014-07-10 14:40:57 +00007098 if (mips::isNaN2008(Args, ToolChain.getTriple()))
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007099 return "/lib/ld-linux-mipsn8.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007100 return "/lib/ld.so.1";
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007101 } else if (ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007102 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007103 if (mips::hasMipsAbiArg(Args, "n32"))
Daniel Sanders2bf13662014-07-10 14:40:57 +00007104 return mips::isNaN2008(Args, ToolChain.getTriple())
7105 ? "/lib32/ld-linux-mipsn8.so.1" : "/lib32/ld.so.1";
7106 return mips::isNaN2008(Args, ToolChain.getTriple())
7107 ? "/lib64/ld-linux-mipsn8.so.1" : "/lib64/ld.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007108 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7109 return "/lib/ld.so.1";
7110 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
7111 ToolChain.getArch() == llvm::Triple::systemz)
7112 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007113 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7114 return "/lib64/ld64.so.2";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007115 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7116 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007117 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7118 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7119 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007120 else
7121 return "/lib64/ld-linux-x86-64.so.2";
7122}
7123
Renato Golinc4b49242014-02-13 10:01:16 +00007124static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7125 ArgStringList &CmdArgs, const ArgList &Args) {
7126 // Make use of compiler-rt if --rtlib option is used
7127 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7128
7129 switch(RLT) {
7130 case ToolChain::RLT_CompilerRT:
7131 addClangRTLinux(TC, Args, CmdArgs);
7132 break;
7133 case ToolChain::RLT_Libgcc:
7134 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7135 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007136 }
7137}
7138
Thomas Schwinge4e555262013-03-28 19:04:25 +00007139void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7140 const InputInfo &Output,
7141 const InputInfoList &Inputs,
7142 const ArgList &Args,
7143 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007144 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007145 static_cast<const toolchains::Linux&>(getToolChain());
7146 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007147 const bool isAndroid =
7148 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007149 const bool IsPIE =
7150 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007151 !Args.hasArg(options::OPT_static) &&
7152 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7153 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007154 // Cannot use isPIEDefault here since otherwise
7155 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007156 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007157
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007158 ArgStringList CmdArgs;
7159
Rafael Espindolad1002f62010-11-15 18:28:16 +00007160 // Silence warning for "clang -g foo.o -o foo"
7161 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007162 // and "clang -emit-llvm foo.o -o foo"
7163 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007164 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007165 // handled somewhere else.
7166 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007167
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007168 if (!D.SysRoot.empty())
7169 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007170
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007171 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007172 CmdArgs.push_back("-pie");
7173
Rafael Espindola1c76c592010-11-07 22:57:16 +00007174 if (Args.hasArg(options::OPT_rdynamic))
7175 CmdArgs.push_back("-export-dynamic");
7176
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007177 if (Args.hasArg(options::OPT_s))
7178 CmdArgs.push_back("-s");
7179
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007180 for (const auto &Opt : ToolChain.ExtraOpts)
7181 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007182
7183 if (!Args.hasArg(options::OPT_static)) {
7184 CmdArgs.push_back("--eh-frame-hdr");
7185 }
7186
7187 CmdArgs.push_back("-m");
7188 if (ToolChain.getArch() == llvm::Triple::x86)
7189 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007190 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7191 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007192 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007193 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7194 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007195 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007196 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007197 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007198 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007199 else if (ToolChain.getArch() == llvm::Triple::armeb
7200 || ToolChain.getArch() == llvm::Triple::thumbeb)
7201 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007202 else if (ToolChain.getArch() == llvm::Triple::ppc)
7203 CmdArgs.push_back("elf32ppclinux");
7204 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7205 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007206 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7207 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007208 else if (ToolChain.getArch() == llvm::Triple::sparc)
7209 CmdArgs.push_back("elf32_sparc");
7210 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7211 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007212 else if (ToolChain.getArch() == llvm::Triple::mips)
7213 CmdArgs.push_back("elf32btsmip");
7214 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7215 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007216 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007217 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007218 CmdArgs.push_back("elf32btsmipn32");
7219 else
7220 CmdArgs.push_back("elf64btsmip");
7221 }
7222 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007223 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007224 CmdArgs.push_back("elf32ltsmipn32");
7225 else
7226 CmdArgs.push_back("elf64ltsmip");
7227 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007228 else if (ToolChain.getArch() == llvm::Triple::systemz)
7229 CmdArgs.push_back("elf64_s390");
Zinovy Nis1db95732014-07-10 15:27:19 +00007230 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7231 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7232 CmdArgs.push_back("elf32_x86_64");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007233 else
7234 CmdArgs.push_back("elf_x86_64");
7235
7236 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007237 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007238 ToolChain.getArch() == llvm::Triple::armeb ||
7239 ToolChain.getArch() == llvm::Triple::thumb ||
7240 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007241 CmdArgs.push_back("-Bstatic");
7242 else
7243 CmdArgs.push_back("-static");
7244 } else if (Args.hasArg(options::OPT_shared)) {
7245 CmdArgs.push_back("-shared");
7246 }
7247
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007248 if (ToolChain.getArch() == llvm::Triple::arm ||
7249 ToolChain.getArch() == llvm::Triple::armeb ||
7250 ToolChain.getArch() == llvm::Triple::thumb ||
7251 ToolChain.getArch() == llvm::Triple::thumbeb ||
7252 (!Args.hasArg(options::OPT_static) &&
7253 !Args.hasArg(options::OPT_shared))) {
7254 CmdArgs.push_back("-dynamic-linker");
7255 CmdArgs.push_back(Args.MakeArgString(
7256 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7257 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007258
7259 CmdArgs.push_back("-o");
7260 CmdArgs.push_back(Output.getFilename());
7261
Rafael Espindola81937ec2010-12-01 01:52:43 +00007262 if (!Args.hasArg(options::OPT_nostdlib) &&
7263 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007264 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007265 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007266 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007267 if (Args.hasArg(options::OPT_pg))
7268 crt1 = "gcrt1.o";
7269 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007270 crt1 = "Scrt1.o";
7271 else
7272 crt1 = "crt1.o";
7273 }
7274 if (crt1)
7275 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007276
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007277 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7278 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007279
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007280 const char *crtbegin;
7281 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007282 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007283 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007284 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007285 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007286 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007287 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007288 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007289 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007290
7291 // Add crtfastmath.o if available and fast math is enabled.
7292 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007293 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007294
7295 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007296 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007297
7298 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7299
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007300 for (const auto &Path : Paths)
7301 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007302
Alp Tokerce365ca2013-12-02 12:43:03 +00007303 if (D.IsUsingLTO(Args))
7304 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007305
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007306 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7307 CmdArgs.push_back("--no-demangle");
7308
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007309 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7310
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007311 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007312 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007313 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007314
Hans Wennborg70850d82013-07-18 20:29:38 +00007315 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007316 !Args.hasArg(options::OPT_nostdlib) &&
7317 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007318 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7319 !Args.hasArg(options::OPT_static);
7320 if (OnlyLibstdcxxStatic)
7321 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007322 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007323 if (OnlyLibstdcxxStatic)
7324 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007325 CmdArgs.push_back("-lm");
7326 }
7327
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007328 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007329 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7330 if (Args.hasArg(options::OPT_static))
7331 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007332
Alexey Bataev186b28a2014-03-06 05:43:53 +00007333 LibOpenMP UsedOpenMPLib = LibUnknown;
7334 if (Args.hasArg(options::OPT_fopenmp)) {
7335 UsedOpenMPLib = LibGOMP;
7336 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7337 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7338 .Case("libgomp", LibGOMP)
7339 .Case("libiomp5", LibIOMP5)
7340 .Default(LibUnknown);
7341 if (UsedOpenMPLib == LibUnknown)
7342 D.Diag(diag::err_drv_unsupported_option_argument)
7343 << A->getOption().getName() << A->getValue();
7344 }
7345 switch (UsedOpenMPLib) {
7346 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007347 CmdArgs.push_back("-lgomp");
7348
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007349 // FIXME: Exclude this for platforms with libgomp that don't require
7350 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007351 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007352 break;
7353 case LibIOMP5:
7354 CmdArgs.push_back("-liomp5");
7355 break;
7356 case LibUnknown:
7357 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007358 }
Renato Golinc4b49242014-02-13 10:01:16 +00007359 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007360
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007361 if ((Args.hasArg(options::OPT_pthread) ||
7362 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7363 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007364 CmdArgs.push_back("-lpthread");
7365
7366 CmdArgs.push_back("-lc");
7367
7368 if (Args.hasArg(options::OPT_static))
7369 CmdArgs.push_back("--end-group");
7370 else
Renato Golinc4b49242014-02-13 10:01:16 +00007371 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007372 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007373
Rafael Espindola81937ec2010-12-01 01:52:43 +00007374 if (!Args.hasArg(options::OPT_nostartfiles)) {
7375 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007376 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007377 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007378 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007379 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007380 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007381 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007382
Rafael Espindola81937ec2010-12-01 01:52:43 +00007383 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007384 if (!isAndroid)
7385 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007386 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007387 }
7388
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007389 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007390}
7391
Chris Lattner3e2ee142010-07-07 16:01:42 +00007392void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007393 const InputInfo &Output,
7394 const InputInfoList &Inputs,
7395 const ArgList &Args,
7396 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007397 ArgStringList CmdArgs;
7398
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007399 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007400
7401 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007402 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007403
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007404 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007405 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007406
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007407 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007408 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007409}
7410
7411void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007412 const InputInfo &Output,
7413 const InputInfoList &Inputs,
7414 const ArgList &Args,
7415 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007416 const Driver &D = getToolChain().getDriver();
7417 ArgStringList CmdArgs;
7418
Daniel Dunbarb440f562010-08-02 02:38:21 +00007419 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007420 CmdArgs.push_back("-o");
7421 CmdArgs.push_back(Output.getFilename());
7422 } else {
7423 assert(Output.isNothing() && "Invalid output.");
7424 }
7425
7426 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007427 !Args.hasArg(options::OPT_nostartfiles)) {
7428 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7429 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7430 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7431 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7432 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007433
7434 Args.AddAllArgs(CmdArgs, options::OPT_L);
7435 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7436 Args.AddAllArgs(CmdArgs, options::OPT_e);
7437
Daniel Dunbar54423b22010-09-17 00:24:54 +00007438 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007439
Alexey Samsonov7811d192014-02-20 13:57:37 +00007440 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007441
Chris Lattner3e2ee142010-07-07 16:01:42 +00007442 if (!Args.hasArg(options::OPT_nostdlib) &&
7443 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007444 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007445 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007446 CmdArgs.push_back("-lm");
7447 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007448 }
7449
7450 if (!Args.hasArg(options::OPT_nostdlib) &&
7451 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007452 if (Args.hasArg(options::OPT_pthread))
7453 CmdArgs.push_back("-lpthread");
7454 CmdArgs.push_back("-lc");
7455 CmdArgs.push_back("-lCompilerRT-Generic");
7456 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7457 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007458 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007459 }
7460
Logan Chieneb9162f2014-06-26 14:23:45 +00007461 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007462 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007463}
7464
Daniel Dunbarcc912342009-05-02 18:28:39 +00007465/// DragonFly Tools
7466
7467// For now, DragonFly Assemble does just about the same as for
7468// FreeBSD, but this may change soon.
7469void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007470 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007471 const InputInfoList &Inputs,
7472 const ArgList &Args,
7473 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007474 ArgStringList CmdArgs;
7475
7476 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7477 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007478 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007479 CmdArgs.push_back("--32");
7480
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007481 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007482
7483 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007484 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007485
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007486 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007487 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007488
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007489 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007490 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007491}
7492
7493void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007494 const InputInfo &Output,
7495 const InputInfoList &Inputs,
7496 const ArgList &Args,
7497 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007498 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007499 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007500 ArgStringList CmdArgs;
7501
John McCall65b8da02013-04-11 22:55:55 +00007502 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7503 UseGCC47 = false;
7504
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007505 if (!D.SysRoot.empty())
7506 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7507
John McCall65b8da02013-04-11 22:55:55 +00007508 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007509 if (Args.hasArg(options::OPT_static)) {
7510 CmdArgs.push_back("-Bstatic");
7511 } else {
John McCall65b8da02013-04-11 22:55:55 +00007512 if (Args.hasArg(options::OPT_rdynamic))
7513 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007514 if (Args.hasArg(options::OPT_shared))
7515 CmdArgs.push_back("-Bshareable");
7516 else {
7517 CmdArgs.push_back("-dynamic-linker");
7518 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7519 }
John McCall65b8da02013-04-11 22:55:55 +00007520 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007521 }
7522
7523 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7524 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007525 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007526 CmdArgs.push_back("-m");
7527 CmdArgs.push_back("elf_i386");
7528 }
7529
Daniel Dunbarb440f562010-08-02 02:38:21 +00007530 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007531 CmdArgs.push_back("-o");
7532 CmdArgs.push_back(Output.getFilename());
7533 } else {
7534 assert(Output.isNothing() && "Invalid output.");
7535 }
7536
7537 if (!Args.hasArg(options::OPT_nostdlib) &&
7538 !Args.hasArg(options::OPT_nostartfiles)) {
7539 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007540 if (Args.hasArg(options::OPT_pg))
7541 CmdArgs.push_back(Args.MakeArgString(
7542 getToolChain().GetFilePath("gcrt1.o")));
7543 else {
7544 if (Args.hasArg(options::OPT_pie))
7545 CmdArgs.push_back(Args.MakeArgString(
7546 getToolChain().GetFilePath("Scrt1.o")));
7547 else
7548 CmdArgs.push_back(Args.MakeArgString(
7549 getToolChain().GetFilePath("crt1.o")));
7550 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007551 }
John McCall65b8da02013-04-11 22:55:55 +00007552 CmdArgs.push_back(Args.MakeArgString(
7553 getToolChain().GetFilePath("crti.o")));
7554 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7555 CmdArgs.push_back(Args.MakeArgString(
7556 getToolChain().GetFilePath("crtbeginS.o")));
7557 else
7558 CmdArgs.push_back(Args.MakeArgString(
7559 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007560 }
7561
7562 Args.AddAllArgs(CmdArgs, options::OPT_L);
7563 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7564 Args.AddAllArgs(CmdArgs, options::OPT_e);
7565
Daniel Dunbar54423b22010-09-17 00:24:54 +00007566 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007567
7568 if (!Args.hasArg(options::OPT_nostdlib) &&
7569 !Args.hasArg(options::OPT_nodefaultlibs)) {
7570 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7571 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007572 if (UseGCC47)
7573 CmdArgs.push_back("-L/usr/lib/gcc47");
7574 else
7575 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007576
7577 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007578 if (UseGCC47) {
7579 CmdArgs.push_back("-rpath");
7580 CmdArgs.push_back("/usr/lib/gcc47");
7581 } else {
7582 CmdArgs.push_back("-rpath");
7583 CmdArgs.push_back("/usr/lib/gcc44");
7584 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007585 }
7586
Hans Wennborg70850d82013-07-18 20:29:38 +00007587 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007588 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007589 CmdArgs.push_back("-lm");
7590 }
7591
Daniel Dunbarcc912342009-05-02 18:28:39 +00007592 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007593 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007594
7595 if (!Args.hasArg(options::OPT_nolibc)) {
7596 CmdArgs.push_back("-lc");
7597 }
7598
John McCall65b8da02013-04-11 22:55:55 +00007599 if (UseGCC47) {
7600 if (Args.hasArg(options::OPT_static) ||
7601 Args.hasArg(options::OPT_static_libgcc)) {
7602 CmdArgs.push_back("-lgcc");
7603 CmdArgs.push_back("-lgcc_eh");
7604 } else {
7605 if (Args.hasArg(options::OPT_shared_libgcc)) {
7606 CmdArgs.push_back("-lgcc_pic");
7607 if (!Args.hasArg(options::OPT_shared))
7608 CmdArgs.push_back("-lgcc");
7609 } else {
7610 CmdArgs.push_back("-lgcc");
7611 CmdArgs.push_back("--as-needed");
7612 CmdArgs.push_back("-lgcc_pic");
7613 CmdArgs.push_back("--no-as-needed");
7614 }
7615 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007616 } else {
John McCall65b8da02013-04-11 22:55:55 +00007617 if (Args.hasArg(options::OPT_shared)) {
7618 CmdArgs.push_back("-lgcc_pic");
7619 } else {
7620 CmdArgs.push_back("-lgcc");
7621 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007622 }
7623 }
7624
7625 if (!Args.hasArg(options::OPT_nostdlib) &&
7626 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007627 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007628 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007629 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007630 else
7631 CmdArgs.push_back(Args.MakeArgString(
7632 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007633 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007634 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007635 }
7636
Alexey Samsonov7811d192014-02-20 13:57:37 +00007637 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007638
Logan Chieneb9162f2014-06-26 14:23:45 +00007639 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007640 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007641}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007642
Alexey Samsonov6424e022014-05-12 20:20:20 +00007643static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7644 ArgStringList &CmdArgs,
7645 const StringRef RTName) {
7646 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7647 llvm::sys::path::append(LibSanitizer,
7648 Twine("clang_rt.") + RTName + ".lib");
7649 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7650}
7651
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007652void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7653 const InputInfo &Output,
7654 const InputInfoList &Inputs,
7655 const ArgList &Args,
7656 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007657 ArgStringList CmdArgs;
7658
7659 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007660 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7661 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007662 } else {
7663 assert(Output.isNothing() && "Invalid output.");
7664 }
7665
7666 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007667 !Args.hasArg(options::OPT_nostartfiles) &&
7668 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007669 CmdArgs.push_back("-defaultlib:libcmt");
7670 }
7671
7672 CmdArgs.push_back("-nologo");
7673
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007674 if (Args.hasArg(options::OPT_g_Group)) {
7675 CmdArgs.push_back("-debug");
7676 }
7677
Hans Wennborgf1a74252013-09-10 20:18:04 +00007678 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7679
7680 if (DLL) {
7681 CmdArgs.push_back(Args.MakeArgString("-dll"));
7682
7683 SmallString<128> ImplibName(Output.getFilename());
7684 llvm::sys::path::replace_extension(ImplibName, "lib");
7685 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7686 ImplibName.str()));
7687 }
7688
Peter Collingbourne32701642013-11-01 18:16:25 +00007689 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007690 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007691 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007692 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007693 if (DLL) {
7694 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7695 "asan_dll_thunk-i386");
7696 } else {
7697 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7698 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7699 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007700 }
7701
Michael J. Spencere2f49362012-06-18 16:56:04 +00007702 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007703 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007704
7705 // Add filenames immediately.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007706 for (const auto &Input : Inputs)
7707 if (Input.isFilename())
7708 CmdArgs.push_back(Input.getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007709 else
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007710 Input.getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007711
7712 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007713 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007714 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7715}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007716
7717void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7718 const InputInfo &Output,
7719 const InputInfoList &Inputs,
7720 const ArgList &Args,
7721 const char *LinkingOutput) const {
7722 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7723}
7724
Hans Wennborg188382e2013-09-20 18:16:35 +00007725// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7726// If one cannot be found, return FallbackName.
7727// We do this special search to prevent clang-cl from falling back onto itself
7728// if it's available as cl.exe on the path.
7729static std::string FindFallback(const char *FallbackName,
7730 const char *ClangProgramPath) {
7731 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7732 if (!OptPath.hasValue())
7733 return FallbackName;
7734
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007735 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
Hans Wennborg188382e2013-09-20 18:16:35 +00007736 SmallVector<StringRef, 8> PathSegments;
Ehsan Akhgaride8c93b2014-06-30 19:56:37 +00007737 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
Hans Wennborg188382e2013-09-20 18:16:35 +00007738
7739 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7740 const StringRef &PathSegment = PathSegments[i];
7741 if (PathSegment.empty())
7742 continue;
7743
7744 SmallString<128> FilePath(PathSegment);
7745 llvm::sys::path::append(FilePath, FallbackName);
7746 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7747 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7748 return FilePath.str();
7749 }
7750
7751 return FallbackName;
7752}
7753
Hans Wennborg87cfa712013-09-19 20:32:16 +00007754Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7755 const InputInfo &Output,
7756 const InputInfoList &Inputs,
7757 const ArgList &Args,
7758 const char *LinkingOutput) const {
7759 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007760 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007761 CmdArgs.push_back("/c"); // Compile only.
7762 CmdArgs.push_back("/W0"); // No warnings.
7763
7764 // The goal is to be able to invoke this tool correctly based on
7765 // any flag accepted by clang-cl.
7766
7767 // These are spelled the same way in clang and cl.exe,.
7768 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7769 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007770
7771 // Optimization level.
7772 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7773 if (A->getOption().getID() == options::OPT_O0) {
7774 CmdArgs.push_back("/Od");
7775 } else {
7776 StringRef OptLevel = A->getValue();
7777 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7778 A->render(Args, CmdArgs);
7779 else if (OptLevel == "3")
7780 CmdArgs.push_back("/Ox");
7781 }
7782 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007783
7784 // Flags for which clang-cl have an alias.
7785 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7786
David Majnemerf6072342014-07-01 22:24:56 +00007787 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
7788 /*default=*/false))
7789 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007790 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7791 options::OPT_fno_function_sections))
7792 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7793 ? "/Gy"
7794 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007795 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7796 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007797 CmdArgs.push_back(
7798 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007799 if (Args.hasArg(options::OPT_fsyntax_only))
7800 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007801 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7802 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007803
Hans Wennborg260ff402013-09-27 17:54:18 +00007804 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007805 for (const auto &Include : Includes)
7806 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007807
Hans Wennborg87cfa712013-09-19 20:32:16 +00007808 // Flags that can simply be passed through.
7809 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7810 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00007811 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007812
7813 // The order of these flags is relevant, so pick the last one.
7814 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7815 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7816 A->render(Args, CmdArgs);
7817
7818
7819 // Input filename.
7820 assert(Inputs.size() == 1);
7821 const InputInfo &II = Inputs[0];
7822 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7823 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7824 if (II.isFilename())
7825 CmdArgs.push_back(II.getFilename());
7826 else
7827 II.getInputArg().renderAsInput(Args, CmdArgs);
7828
7829 // Output filename.
7830 assert(Output.getType() == types::TY_Object);
7831 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7832 Output.getFilename());
7833 CmdArgs.push_back(Fo);
7834
Hans Wennborg188382e2013-09-20 18:16:35 +00007835 const Driver &D = getToolChain().getDriver();
7836 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg188382e2013-09-20 18:16:35 +00007837 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007838}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007839
7840
7841/// XCore Tools
7842// We pass assemble and link construction to the xcc tool.
7843
7844void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7845 const InputInfo &Output,
7846 const InputInfoList &Inputs,
7847 const ArgList &Args,
7848 const char *LinkingOutput) const {
7849 ArgStringList CmdArgs;
7850
7851 CmdArgs.push_back("-o");
7852 CmdArgs.push_back(Output.getFilename());
7853
7854 CmdArgs.push_back("-c");
7855
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007856 if (Args.hasArg(options::OPT_v))
7857 CmdArgs.push_back("-v");
7858
Robert Lytton894d25c2014-05-02 09:33:25 +00007859 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7860 if (!A->getOption().matches(options::OPT_g0))
7861 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007862
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007863 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7864 false))
7865 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007866
7867 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7868 options::OPT_Xassembler);
7869
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007870 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007871 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007872
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007873 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007874 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7875}
7876
7877void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7878 const InputInfo &Output,
7879 const InputInfoList &Inputs,
7880 const ArgList &Args,
7881 const char *LinkingOutput) const {
7882 ArgStringList CmdArgs;
7883
7884 if (Output.isFilename()) {
7885 CmdArgs.push_back("-o");
7886 CmdArgs.push_back(Output.getFilename());
7887 } else {
7888 assert(Output.isNothing() && "Invalid output.");
7889 }
7890
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007891 if (Args.hasArg(options::OPT_v))
7892 CmdArgs.push_back("-v");
7893
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007894 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7895 if (EH.ShouldUseExceptionTables)
7896 CmdArgs.push_back("-fexceptions");
7897
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007898 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7899
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007900 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007901 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7902}