blob: d625c0e3e2f674afb3fd49143366810c4b6aa928 [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
Bob Wilsond5aad2a2014-11-04 22:28:48 +000086// Add backslashes to escape spaces and other backslashes.
87// This is used for the space-separated argument list specified with
88// the -dwarf-debug-flags option.
89static void EscapeSpacesAndBackslashes(const char *Arg,
90 SmallVectorImpl<char> &Res) {
91 for ( ; *Arg; ++Arg) {
92 switch (*Arg) {
93 default: break;
94 case ' ':
95 case '\\':
96 Res.push_back('\\');
97 break;
98 }
99 Res.push_back(*Arg);
100 }
101}
102
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000103// Quote target names for inclusion in GNU Make dependency files.
104// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000105static void QuoteTarget(StringRef Target,
106 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000107 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
108 switch (Target[i]) {
109 case ' ':
110 case '\t':
111 // Escape the preceding backslashes
112 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
113 Res.push_back('\\');
114
115 // Escape the space/tab
116 Res.push_back('\\');
117 break;
118 case '$':
119 Res.push_back('$');
120 break;
121 case '#':
122 Res.push_back('\\');
123 break;
124 default:
125 break;
126 }
127
128 Res.push_back(Target[i]);
129 }
130}
131
Bill Wendlingc0938f32012-03-12 22:10:06 +0000132static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000133 ArgStringList &CmdArgs,
134 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000135 const char *EnvVar) {
136 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000137 bool CombinedArg = false;
138
Bill Wendling281ca292012-03-12 21:22:35 +0000139 if (!DirList)
140 return; // Nothing to do.
141
Chad Rosier616e8a52012-10-30 21:42:09 +0000142 StringRef Name(ArgName);
143 if (Name.equals("-I") || Name.equals("-L"))
144 CombinedArg = true;
145
Bill Wendling281ca292012-03-12 21:22:35 +0000146 StringRef Dirs(DirList);
147 if (Dirs.empty()) // Empty string should not add '.'.
148 return;
149
150 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000151 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000152 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000153 if (CombinedArg) {
154 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
155 } else {
156 CmdArgs.push_back(ArgName);
157 CmdArgs.push_back(".");
158 }
Bill Wendling281ca292012-03-12 21:22:35 +0000159 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000160 if (CombinedArg) {
161 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
162 } else {
163 CmdArgs.push_back(ArgName);
164 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
165 }
Bill Wendling281ca292012-03-12 21:22:35 +0000166 }
Nico Weber89355782012-03-19 15:00:03 +0000167 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000168 }
169
170 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000171 if (CombinedArg) {
172 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
173 } else {
174 CmdArgs.push_back(ArgName);
175 CmdArgs.push_back(".");
176 }
Bill Wendling281ca292012-03-12 21:22:35 +0000177 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000178 if (CombinedArg) {
179 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
180 } else {
181 CmdArgs.push_back(ArgName);
182 CmdArgs.push_back(Args.MakeArgString(Dirs));
183 }
Bill Wendling281ca292012-03-12 21:22:35 +0000184 }
185}
186
Daniel Dunbar54423b22010-09-17 00:24:54 +0000187static void AddLinkerInputs(const ToolChain &TC,
188 const InputInfoList &Inputs, const ArgList &Args,
189 ArgStringList &CmdArgs) {
190 const Driver &D = TC.getDriver();
191
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000192 // Add extra linker input arguments which are not treated as inputs
193 // (constructed via -Xarch_).
194 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
195
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000196 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000197 if (!TC.HasNativeLLVMSupport()) {
198 // Don't try to pass LLVM inputs unless we have native support.
199 if (II.getType() == types::TY_LLVM_IR ||
200 II.getType() == types::TY_LTO_IR ||
201 II.getType() == types::TY_LLVM_BC ||
202 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000203 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000204 << TC.getTripleString();
205 }
206
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000207 // Add filenames immediately.
208 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000209 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000210 continue;
211 }
212
213 // Otherwise, this is a linker input argument.
214 const Arg &A = II.getInputArg();
215
216 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000217 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000218 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000219 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000220 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000221 else if (A.getOption().matches(options::OPT_z)) {
222 // Pass -z prefix for gcc linker compatibility.
223 A.claim();
224 A.render(Args, CmdArgs);
225 } else {
226 A.renderAsInput(Args, CmdArgs);
227 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000228 }
Bill Wendling281ca292012-03-12 21:22:35 +0000229
230 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000231 // and only supported on native toolchains.
232 if (!TC.isCrossCompiling())
233 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000234}
235
John McCall31168b02011-06-15 23:02:42 +0000236/// \brief Determine whether Objective-C automated reference counting is
237/// enabled.
238static bool isObjCAutoRefCount(const ArgList &Args) {
239 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
240}
241
Ted Kremeneke65b0862012-03-06 20:05:56 +0000242/// \brief Determine whether we are linking the ObjC runtime.
243static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000244 if (isObjCAutoRefCount(Args)) {
245 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000246 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000247 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000248 return Args.hasArg(options::OPT_fobjc_link_runtime);
249}
250
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000251static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000252 // Don't forward inputs from the original command line. They are added from
253 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000254 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000255 !O.hasFlag(options::DriverOption) &&
256 !O.hasFlag(options::LinkerInput);
257}
258
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000259void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000260 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000261 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000262 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000263 ArgStringList &CmdArgs,
264 const InputInfo &Output,
265 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000266 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000267
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000268 CheckPreprocessingOptions(D, Args);
269
270 Args.AddLastArg(CmdArgs, options::OPT_C);
271 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000272
273 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000274 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000275 (A = Args.getLastArg(options::OPT_MD)) ||
276 (A = Args.getLastArg(options::OPT_MMD))) {
277 // Determine the output location.
278 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000279 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000280 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000281 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000282 } else if (Output.getType() == types::TY_Dependencies) {
283 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000284 } else if (A->getOption().matches(options::OPT_M) ||
285 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000286 DepFile = "-";
287 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000288 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000289 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000290 }
291 CmdArgs.push_back("-dependency-file");
292 CmdArgs.push_back(DepFile);
293
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000294 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000295 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
296 const char *DepTarget;
297
298 // If user provided -o, that is the dependency target, except
299 // when we are only generating a dependency file.
300 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
301 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000302 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000303 } else {
304 // Otherwise derive from the base input.
305 //
306 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000307 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000308 llvm::sys::path::replace_extension(P, "o");
309 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000310 }
311
312 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000313 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000314 QuoteTarget(DepTarget, Quoted);
315 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000316 }
317
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000318 if (A->getOption().matches(options::OPT_M) ||
319 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000320 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000321
322 if (isa<PrecompileJobAction>(JA))
323 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000324 }
325
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000326 if (Args.hasArg(options::OPT_MG)) {
327 if (!A || A->getOption().matches(options::OPT_MD) ||
328 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000329 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000330 CmdArgs.push_back("-MG");
331 }
332
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000333 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000334
335 // Convert all -MQ <target> args to -MT <quoted target>
336 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
337 options::OPT_MQ),
338 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000339 const Arg *A = *it;
340 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000341
Daniel Dunbara442fd52010-06-11 22:00:13 +0000342 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000343 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000344 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000345 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000346 CmdArgs.push_back(Args.MakeArgString(Quoted));
347
348 // -MT flag - no change
349 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000350 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000351 }
352 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000353
Douglas Gregor111af7d2009-04-18 00:34:01 +0000354 // Add -i* options, and automatically translate to
355 // -include-pch/-include-pth for transparent PCH support. It's
356 // wonky, but we include looking for .gch so we can support seamless
357 // replacement into a build system already set up to be generating
358 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000359 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000360 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
361 ie = Args.filtered_end(); it != ie; ++it) {
362 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000363
364 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000365 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
366 RenderedImplicitInclude = true;
367
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000368 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000369 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000370
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000371 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000372 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000373 SmallString<128> P(A->getValue());
374 // We want the files to have a name like foo.h.pch. Add a dummy extension
375 // so that replace_extension does the right thing.
376 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000377 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000378 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000379 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000380 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000381 }
382
Douglas Gregor111af7d2009-04-18 00:34:01 +0000383 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000384 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000385 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000386 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000387 }
388
Douglas Gregor111af7d2009-04-18 00:34:01 +0000389 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000390 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000391 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000392 FoundPCH = UsePCH;
393 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000394 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000395 }
396
397 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000398 if (IsFirstImplicitInclude) {
399 A->claim();
400 if (UsePCH)
401 CmdArgs.push_back("-include-pch");
402 else
403 CmdArgs.push_back("-include-pth");
404 CmdArgs.push_back(Args.MakeArgString(P.str()));
405 continue;
406 } else {
407 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000408 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000409 << P.str() << A->getAsString(Args);
410 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000411 }
412 }
413
414 // Not translated, render as usual.
415 A->claim();
416 A->render(Args, CmdArgs);
417 }
418
419 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000420 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
421 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000422
423 // Add -Wp, and -Xassembler if using the preprocessor.
424
425 // FIXME: There is a very unfortunate problem here, some troubled
426 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
427 // really support that we would have to parse and then translate
428 // those options. :(
429 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
430 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000431
432 // -I- is a deprecated GCC feature, reject it.
433 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000434 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000435
436 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
437 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000438 StringRef sysroot = C.getSysRoot();
439 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000440 if (!Args.hasArg(options::OPT_isysroot)) {
441 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000442 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000443 }
444 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000445
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000446 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000447 // FIXME: We should probably sink the logic for handling these from the
448 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000449 // CPATH - included following the user specified includes (but prior to
450 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000451 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000452 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000453 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000454 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000455 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000456 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000457 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000458 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000459 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000460
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000461 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000462 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000463 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000464
465 // Add system include arguments.
466 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000467}
468
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000469// FIXME: Move to target hook.
470static bool isSignedCharDefault(const llvm::Triple &Triple) {
471 switch (Triple.getArch()) {
472 default:
473 return true;
474
Tim Northover9bb857a2013-01-31 12:13:10 +0000475 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000476 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000477 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000478 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000479 case llvm::Triple::thumb:
480 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000481 if (Triple.isOSDarwin() || Triple.isOSWindows())
482 return true;
483 return false;
484
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000485 case llvm::Triple::ppc:
486 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000487 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000488 return true;
489 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000490
Bill Schmidt778d3872013-07-26 01:36:11 +0000491 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000492 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000493 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000494 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000495 }
496}
497
Robert Lytton0e076492013-08-13 09:43:10 +0000498static bool isNoCommonDefault(const llvm::Triple &Triple) {
499 switch (Triple.getArch()) {
500 default:
501 return false;
502
503 case llvm::Triple::xcore:
504 return true;
505 }
506}
507
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000508// Handle -mhwdiv=.
509static void getARMHWDivFeatures(const Driver &D, const Arg *A,
510 const ArgList &Args,
511 std::vector<const char *> &Features) {
512 StringRef HWDiv = A->getValue();
513 if (HWDiv == "arm") {
514 Features.push_back("+hwdiv-arm");
515 Features.push_back("-hwdiv");
516 } else if (HWDiv == "thumb") {
517 Features.push_back("-hwdiv-arm");
518 Features.push_back("+hwdiv");
519 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
520 Features.push_back("+hwdiv-arm");
521 Features.push_back("+hwdiv");
522 } else if (HWDiv == "none") {
523 Features.push_back("-hwdiv-arm");
524 Features.push_back("-hwdiv");
525 } else
526 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
527}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000528
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000529// Handle -mfpu=.
530//
531// FIXME: Centralize feature selection, defaulting shouldn't be also in the
532// frontend target.
533static void getARMFPUFeatures(const Driver &D, const Arg *A,
534 const ArgList &Args,
535 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000536 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000537
538 // Set the target features based on the FPU.
539 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
540 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000541 Features.push_back("-vfp2");
542 Features.push_back("-vfp3");
543 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000544 } else if (FPU == "vfp") {
545 Features.push_back("+vfp2");
546 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000547 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000548 Features.push_back("+vfp3");
549 Features.push_back("+d16");
550 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000551 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000552 Features.push_back("+vfp3");
553 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000554 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
555 Features.push_back("+vfp4");
556 Features.push_back("+d16");
557 Features.push_back("-neon");
558 } else if (FPU == "vfp4" || FPU == "vfpv4") {
559 Features.push_back("+vfp4");
560 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000561 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
562 Features.push_back("+vfp4");
563 Features.push_back("+d16");
564 Features.push_back("+fp-only-sp");
565 Features.push_back("-neon");
Oliver Stannardbfd3ea32014-10-01 09:03:02 +0000566 } else if (FPU == "fp5-sp-d16" || FPU == "fpv5-sp-d16") {
567 Features.push_back("+fp-armv8");
568 Features.push_back("+fp-only-sp");
569 Features.push_back("+d16");
570 Features.push_back("-neon");
571 Features.push_back("-crypto");
572 } else if (FPU == "fp5-dp-d16" || FPU == "fpv5-dp-d16" ||
573 FPU == "fp5-d16" || FPU == "fpv5-d16") {
574 Features.push_back("+fp-armv8");
575 Features.push_back("+d16");
576 Features.push_back("-neon");
577 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000578 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000579 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000580 Features.push_back("-neon");
581 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000582 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000583 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000584 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000585 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000586 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000587 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000588 Features.push_back("+neon");
589 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000590 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000591 Features.push_back("+neon");
Richard Barton3b0dcc12014-11-28 20:39:59 +0000592 } else if (FPU == "neon-vfpv3") {
Richard Barton2c5a8972014-12-18 16:31:18 +0000593 Features.push_back("+vfp3");
Richard Barton3b0dcc12014-11-28 20:39:59 +0000594 Features.push_back("+neon");
Richard Barton09b60b22014-11-28 20:39:54 +0000595 } else if (FPU == "neon-vfpv4") {
596 Features.push_back("+neon");
Richard Barton2c5a8972014-12-18 16:31:18 +0000597 Features.push_back("+vfp4");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000598 } else if (FPU == "none") {
599 Features.push_back("-vfp2");
600 Features.push_back("-vfp3");
601 Features.push_back("-vfp4");
602 Features.push_back("-fp-armv8");
603 Features.push_back("-crypto");
604 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000605 } else
606 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
607}
608
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000609// Select the float ABI as determined by -msoft-float, -mhard-float, and
610// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000611StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000612 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000613 StringRef FloatABI;
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000614 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
615 options::OPT_mhard_float,
616 options::OPT_mfloat_abi_EQ)) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000617 if (A->getOption().matches(options::OPT_msoft_float))
618 FloatABI = "soft";
619 else if (A->getOption().matches(options::OPT_mhard_float))
620 FloatABI = "hard";
621 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000622 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000623 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000624 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000625 << A->getAsString(Args);
626 FloatABI = "soft";
627 }
628 }
629 }
630
631 // If unspecified, choose the default based on the platform.
632 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000633 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000634 case llvm::Triple::Darwin:
635 case llvm::Triple::MacOSX:
636 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000637 // Darwin defaults to "softfp" for v6 and v7.
638 //
639 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000640 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000641 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000642 if (StringRef(ArchName).startswith("v6") ||
643 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000644 FloatABI = "softfp";
645 else
646 FloatABI = "soft";
647 break;
648 }
649
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000650 // FIXME: this is invalid for WindowsCE
651 case llvm::Triple::Win32:
652 FloatABI = "hard";
653 break;
654
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000655 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000656 switch(Triple.getEnvironment()) {
657 case llvm::Triple::GNUEABIHF:
658 FloatABI = "hard";
659 break;
660 default:
661 // FreeBSD defaults to soft float
662 FloatABI = "soft";
663 break;
664 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000665 break;
666
Daniel Dunbar78485922009-09-10 23:00:09 +0000667 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000668 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000669 case llvm::Triple::GNUEABIHF:
670 FloatABI = "hard";
671 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000672 case llvm::Triple::GNUEABI:
673 FloatABI = "softfp";
674 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000675 case llvm::Triple::EABIHF:
676 FloatABI = "hard";
677 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000678 case llvm::Triple::EABI:
679 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
680 FloatABI = "softfp";
681 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000682 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000683 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000684 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000685 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000686 FloatABI = "softfp";
687 else
688 FloatABI = "soft";
689 break;
690 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000691 default:
692 // Assume "soft", but warn the user we are guessing.
693 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000694 if (Triple.getOS() != llvm::Triple::UnknownOS ||
695 !Triple.isOSBinFormatMachO())
696 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000697 break;
698 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000699 }
700 }
701
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000702 return FloatABI;
703}
704
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000705static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
706 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000707 std::vector<const char *> &Features,
708 bool ForAS) {
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000709 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000710 if (!ForAS) {
711 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
712 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
713 // stripped out by the ARM target. We should probably pass this a new
714 // -target-option, which is handled by the -cc1/-cc1as invocation.
715 //
716 // FIXME2: For consistency, it would be ideal if we set up the target
717 // machine state the same when using the frontend or the assembler. We don't
718 // currently do that for the assembler, we pass the options directly to the
719 // backend and never even instantiate the frontend TargetInfo. If we did,
720 // and used its handleTargetFeatures hook, then we could ensure the
721 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000722
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000723 // Use software floating point operations?
724 if (FloatABI == "soft")
725 Features.push_back("+soft-float");
726
727 // Use software floating point argument passing?
728 if (FloatABI != "hard")
729 Features.push_back("+soft-float-abi");
730 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000731
732 // Honor -mfpu=.
733 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000734 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000735 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
736 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000737
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000738 // Setting -msoft-float effectively disables NEON because of the GCC
739 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000740 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000741 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000742 // Also need to explicitly disable features which imply NEON.
743 Features.push_back("-crypto");
744 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000745
746 // En/disable crc
747 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
748 options::OPT_mnocrc)) {
749 if (A->getOption().matches(options::OPT_mcrc))
750 Features.push_back("+crc");
751 else
752 Features.push_back("-crc");
753 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000754}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000755
756void Clang::AddARMTargetArgs(const ArgList &Args,
757 ArgStringList &CmdArgs,
758 bool KernelOrKext) const {
759 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000760 // Get the effective triple, which takes into account the deployment target.
761 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
762 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000763 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000764
765 // Select the ABI to use.
766 //
767 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +0000768 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +0000769 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000770 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000771 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000772 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000773 // The backend is hardwired to assume AAPCS for M-class processors, ensure
774 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000775 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Eric Christopher610952e2014-12-05 00:22:48 +0000776 Triple.getOS() == llvm::Triple::UnknownOS ||
Tim Northovere66c9462013-10-03 14:23:28 +0000777 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000778 ABIName = "aapcs";
779 } else {
780 ABIName = "apcs-gnu";
781 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000782 } else if (Triple.isOSWindows()) {
783 // FIXME: this is invalid for WindowsCE
784 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000785 } else {
786 // Select the default based on the platform.
787 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000788 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000789 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000790 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000791 ABIName = "aapcs-linux";
792 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000793 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000794 case llvm::Triple::EABI:
795 ABIName = "aapcs";
796 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000797 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +0000798 if (Triple.getOS() == llvm::Triple::NetBSD)
799 ABIName = "apcs-gnu";
800 else
801 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000802 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000803 }
804 }
805 CmdArgs.push_back("-target-abi");
806 CmdArgs.push_back(ABIName);
807
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000808 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000809 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000810 if (FloatABI == "soft") {
811 // Floating point operations and argument passing are soft.
812 //
813 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000814 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000815 CmdArgs.push_back("-mfloat-abi");
816 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000817 } else if (FloatABI == "softfp") {
818 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000819 CmdArgs.push_back("-mfloat-abi");
820 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000821 } else {
822 // Floating point operations and argument passing are hard.
823 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000824 CmdArgs.push_back("-mfloat-abi");
825 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000826 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000827
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000828 // Kernel code has more strict alignment requirements.
829 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000830 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000831 CmdArgs.push_back("-backend-option");
832 CmdArgs.push_back("-arm-long-calls");
833 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000834
Daniel Dunbar12100e22011-03-22 16:48:17 +0000835 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000836 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000837
838 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000839 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000840 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000841 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000842
Bob Wilson0874e532014-07-29 00:23:18 +0000843 // -mkernel implies -mstrict-align; don't add the redundant option.
844 if (!KernelOrKext) {
845 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
846 options::OPT_munaligned_access)) {
847 CmdArgs.push_back("-backend-option");
848 if (A->getOption().matches(options::OPT_mno_unaligned_access))
849 CmdArgs.push_back("-arm-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000850 else {
Jonathan Roelofs2b00d542014-10-07 15:11:32 +0000851 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
Oliver Stannard76244be2014-08-13 09:18:12 +0000852 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
Bob Wilson0874e532014-07-29 00:23:18 +0000853 CmdArgs.push_back("-arm-no-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000854 }
Bob Wilson0874e532014-07-29 00:23:18 +0000855 }
856 }
857
Chad Rosierba3df1d2011-08-26 00:26:29 +0000858 // Setting -mno-global-merge disables the codegen global merge pass. Setting
859 // -mglobal-merge has no effect as the pass is enabled by default.
860 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
861 options::OPT_mno_global_merge)) {
862 if (A->getOption().matches(options::OPT_mno_global_merge))
863 CmdArgs.push_back("-mno-global-merge");
864 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000865
Bob Wilson9c8af452013-04-11 18:53:25 +0000866 if (!Args.hasFlag(options::OPT_mimplicit_float,
867 options::OPT_mno_implicit_float,
868 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000869 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000870
Logan Chien749763e2014-04-03 13:12:44 +0000871 // llvm does not support reserving registers in general. There is support
872 // for reserving r9 on ARM though (defined as a platform-specific register
873 // in ARM EABI).
874 if (Args.hasArg(options::OPT_ffixed_r9)) {
875 CmdArgs.push_back("-backend-option");
876 CmdArgs.push_back("-arm-reserve-r9");
877 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000878}
879
Tim Northover573cbee2014-05-24 12:52:07 +0000880/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
881/// targeting.
882static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000883 Arg *A;
884 std::string CPU;
885 // If we have -mtune or -mcpu, use that.
886 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
887 CPU = A->getValue();
888 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
889 StringRef Mcpu = A->getValue();
890 CPU = Mcpu.split("+").first;
Tim Northovera2ee4332014-03-29 15:09:45 +0000891 }
892
Kevin Qin110db6f2014-07-18 07:03:22 +0000893 // Handle CPU name is 'native'.
894 if (CPU == "native")
895 return llvm::sys::getHostCPUName();
896 else if (CPU.size())
897 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000898
James Molloy9b1586b2014-04-17 12:51:17 +0000899 // Make sure we pick "cyclone" if -arch is used.
900 // FIXME: Should this be picked by checking the target triple instead?
901 if (Args.getLastArg(options::OPT_arch))
902 return "cyclone";
903
904 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000905}
906
Tim Northover573cbee2014-05-24 12:52:07 +0000907void Clang::AddAArch64TargetArgs(const ArgList &Args,
908 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000909 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
910 llvm::Triple Triple(TripleStr);
911
912 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
913 Args.hasArg(options::OPT_mkernel) ||
914 Args.hasArg(options::OPT_fapple_kext))
915 CmdArgs.push_back("-disable-red-zone");
916
917 if (!Args.hasFlag(options::OPT_mimplicit_float,
918 options::OPT_mno_implicit_float, true))
919 CmdArgs.push_back("-no-implicit-float");
920
Craig Topper92fc2df2014-05-17 16:56:41 +0000921 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000922 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
923 ABIName = A->getValue();
924 else if (Triple.isOSDarwin())
925 ABIName = "darwinpcs";
926 else
927 ABIName = "aapcs";
928
929 CmdArgs.push_back("-target-abi");
930 CmdArgs.push_back(ABIName);
931
Bob Wilson0874e532014-07-29 00:23:18 +0000932 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
933 options::OPT_munaligned_access)) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000934 CmdArgs.push_back("-backend-option");
Bob Wilson0874e532014-07-29 00:23:18 +0000935 if (A->getOption().matches(options::OPT_mno_unaligned_access))
936 CmdArgs.push_back("-aarch64-strict-align");
937 else
938 CmdArgs.push_back("-aarch64-no-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000939 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000940
Bradley Smith9ff64332014-10-13 10:16:06 +0000941 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
942 options::OPT_mno_fix_cortex_a53_835769)) {
943 CmdArgs.push_back("-backend-option");
944 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
945 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
946 else
947 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Bradley Smith04ee8aa2014-10-16 16:35:14 +0000948 } else if (Triple.getEnvironment() == llvm::Triple::Android) {
949 // Enabled A53 errata (835769) workaround by default on android
950 CmdArgs.push_back("-backend-option");
951 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +0000952 }
953
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000954 // Setting -mno-global-merge disables the codegen global merge pass. Setting
955 // -mglobal-merge has no effect as the pass is enabled by default.
956 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
957 options::OPT_mno_global_merge)) {
958 if (A->getOption().matches(options::OPT_mno_global_merge))
959 CmdArgs.push_back("-mno-global-merge");
960 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000961}
962
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000963// Get CPU and ABI names. They are not independent
964// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000965void mips::getMipsCPUAndABI(const ArgList &Args,
966 const llvm::Triple &Triple,
967 StringRef &CPUName,
968 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000969 const char *DefMips32CPU = "mips32r2";
970 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000971
Daniel Sanders2bf13662014-07-10 14:40:57 +0000972 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
973 // default for mips64(el)?-img-linux-gnu.
974 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
975 Triple.getEnvironment() == llvm::Triple::GNU) {
976 DefMips32CPU = "mips32r6";
977 DefMips64CPU = "mips64r6";
978 }
979
Brad Smithba26f582015-01-06 02:53:17 +0000980 // MIPS3 is the default for mips64*-unknown-openbsd.
981 if (Triple.getOS() == llvm::Triple::OpenBSD)
982 DefMips64CPU = "mips3";
983
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000984 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000985 options::OPT_mcpu_EQ))
986 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000987
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000988 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000989 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000990 // Convert a GNU style Mips ABI name to the name
991 // accepted by LLVM Mips backend.
992 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
993 .Case("32", "o32")
994 .Case("64", "n64")
995 .Default(ABIName);
996 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000997
998 // Setup default CPU and ABI names.
999 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001000 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001001 default:
1002 llvm_unreachable("Unexpected triple arch name");
1003 case llvm::Triple::mips:
1004 case llvm::Triple::mipsel:
1005 CPUName = DefMips32CPU;
1006 break;
1007 case llvm::Triple::mips64:
1008 case llvm::Triple::mips64el:
1009 CPUName = DefMips64CPU;
1010 break;
1011 }
1012 }
1013
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001014 if (ABIName.empty()) {
1015 // Deduce ABI name from the target triple.
1016 if (Triple.getArch() == llvm::Triple::mips ||
1017 Triple.getArch() == llvm::Triple::mipsel)
1018 ABIName = "o32";
1019 else
1020 ABIName = "n64";
1021 }
1022
1023 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001024 // Deduce CPU name from ABI name.
1025 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +00001026 .Cases("o32", "eabi", DefMips32CPU)
1027 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001028 .Default("");
1029 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001030
1031 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001032}
1033
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001034// Convert ABI name to the GNU tools acceptable variant.
1035static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1036 return llvm::StringSwitch<llvm::StringRef>(ABI)
1037 .Case("o32", "32")
1038 .Case("n64", "64")
1039 .Default(ABI);
1040}
1041
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001042// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1043// and -mfloat-abi=.
1044static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001045 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001046 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001047 options::OPT_mhard_float,
1048 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001049 if (A->getOption().matches(options::OPT_msoft_float))
1050 FloatABI = "soft";
1051 else if (A->getOption().matches(options::OPT_mhard_float))
1052 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001053 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001054 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001055 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001056 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001057 FloatABI = "hard";
1058 }
1059 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001060 }
1061
1062 // If unspecified, choose the default based on the platform.
1063 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001064 // Assume "hard", because it's a default value used by gcc.
1065 // When we start to recognize specific target MIPS processors,
1066 // we will be able to select the default more correctly.
1067 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001068 }
1069
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001070 return FloatABI;
1071}
1072
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001073static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001074 std::vector<const char *> &Features,
1075 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001076 StringRef FeatureName) {
1077 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001078 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001079 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001080 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001081 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001082 }
1083}
1084
Daniel Sanders379d44b2014-07-16 11:52:23 +00001085static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1086 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001087 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001088 StringRef CPUName;
1089 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001090 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001091 ABIName = getGnuCompatibleMipsABIName(ABIName);
1092
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001093 // Always override the backend's default ABI.
Aaron Ballman9eef74232014-07-17 13:28:50 +00001094 std::string ABIFeature = llvm::StringSwitch<StringRef>(ABIName)
1095 .Case("32", "+o32")
1096 .Case("n32", "+n32")
1097 .Case("64", "+n64")
1098 .Case("eabi", "+eabi")
1099 .Default(("+" + ABIName).str());
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001100 Features.push_back("-o32");
1101 Features.push_back("-n64");
1102 Features.push_back(Args.MakeArgString(ABIFeature));
1103
Daniel Sandersfeb61302014-08-08 15:47:17 +00001104 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1105 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001106
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001107 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001108 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001109 // FIXME: Note, this is a hack. We need to pass the selected float
1110 // mode to the MipsTargetInfoBase to define appropriate macros there.
1111 // Now it is the only method.
1112 Features.push_back("+soft-float");
1113 }
1114
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001115 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001116 StringRef Val = StringRef(A->getValue());
1117 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001118 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001119 else if (Val == "legacy")
1120 Features.push_back("-nan2008");
1121 else
1122 D.Diag(diag::err_drv_unsupported_option_argument)
1123 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001124 }
1125
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001126 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1127 options::OPT_mdouble_float, "single-float");
1128 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1129 "mips16");
1130 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1131 options::OPT_mno_micromips, "micromips");
1132 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1133 "dsp");
1134 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1135 "dspr2");
1136 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1137 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001138
1139 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1140 // pass -mfpxx
1141 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1142 options::OPT_mfp64)) {
1143 if (A->getOption().matches(options::OPT_mfp32))
1144 Features.push_back(Args.MakeArgString("-fp64"));
1145 else if (A->getOption().matches(options::OPT_mfpxx)) {
1146 Features.push_back(Args.MakeArgString("+fpxx"));
1147 Features.push_back(Args.MakeArgString("+nooddspreg"));
1148 } else
1149 Features.push_back(Args.MakeArgString("+fp64"));
1150 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001151 Features.push_back(Args.MakeArgString("+fpxx"));
1152 Features.push_back(Args.MakeArgString("+nooddspreg"));
1153 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001154
Daniel Sanders28e5d392014-07-10 10:39:51 +00001155 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1156 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001157}
1158
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001159void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001160 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001161 const Driver &D = getToolChain().getDriver();
1162 StringRef CPUName;
1163 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001164 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001165 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001166
1167 CmdArgs.push_back("-target-abi");
1168 CmdArgs.push_back(ABIName.data());
1169
1170 StringRef FloatABI = getMipsFloatABI(D, Args);
1171
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001172 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001173 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001174 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001175 CmdArgs.push_back("-mfloat-abi");
1176 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001177 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001178 else {
1179 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001180 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001181 CmdArgs.push_back("-mfloat-abi");
1182 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001183 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001184
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001185 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1186 if (A->getOption().matches(options::OPT_mxgot)) {
1187 CmdArgs.push_back("-mllvm");
1188 CmdArgs.push_back("-mxgot");
1189 }
1190 }
1191
Simon Atanasyanc580b322013-05-11 06:33:44 +00001192 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1193 options::OPT_mno_ldc1_sdc1)) {
1194 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1195 CmdArgs.push_back("-mllvm");
1196 CmdArgs.push_back("-mno-ldc1-sdc1");
1197 }
1198 }
1199
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001200 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1201 options::OPT_mno_check_zero_division)) {
1202 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1203 CmdArgs.push_back("-mllvm");
1204 CmdArgs.push_back("-mno-check-zero-division");
1205 }
1206 }
1207
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001208 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001209 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001210 CmdArgs.push_back("-mllvm");
1211 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1212 A->claim();
1213 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001214}
1215
Hal Finkel8eb59282012-06-11 22:35:19 +00001216/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1217static std::string getPPCTargetCPU(const ArgList &Args) {
1218 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001219 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001220
1221 if (CPUName == "native") {
1222 std::string CPU = llvm::sys::getHostCPUName();
1223 if (!CPU.empty() && CPU != "generic")
1224 return CPU;
1225 else
1226 return "";
1227 }
1228
1229 return llvm::StringSwitch<const char *>(CPUName)
1230 .Case("common", "generic")
1231 .Case("440", "440")
1232 .Case("440fp", "440")
1233 .Case("450", "450")
1234 .Case("601", "601")
1235 .Case("602", "602")
1236 .Case("603", "603")
1237 .Case("603e", "603e")
1238 .Case("603ev", "603ev")
1239 .Case("604", "604")
1240 .Case("604e", "604e")
1241 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001242 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001243 .Case("G3", "g3")
1244 .Case("7400", "7400")
1245 .Case("G4", "g4")
1246 .Case("7450", "7450")
1247 .Case("G4+", "g4+")
1248 .Case("750", "750")
1249 .Case("970", "970")
1250 .Case("G5", "g5")
1251 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001252 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001253 .Case("e500mc", "e500mc")
1254 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001255 .Case("power3", "pwr3")
1256 .Case("power4", "pwr4")
1257 .Case("power5", "pwr5")
1258 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001259 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001260 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001261 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001262 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001263 .Case("pwr3", "pwr3")
1264 .Case("pwr4", "pwr4")
1265 .Case("pwr5", "pwr5")
1266 .Case("pwr5x", "pwr5x")
1267 .Case("pwr6", "pwr6")
1268 .Case("pwr6x", "pwr6x")
1269 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001270 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001271 .Case("powerpc", "ppc")
1272 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001273 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001274 .Default("");
1275 }
1276
1277 return "";
1278}
1279
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001280static void getPPCTargetFeatures(const ArgList &Args,
1281 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001282 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1283 ie = Args.filtered_end();
1284 it != ie; ++it) {
1285 StringRef Name = (*it)->getOption().getName();
1286 (*it)->claim();
1287
1288 // Skip over "-m".
1289 assert(Name.startswith("m") && "Invalid feature name.");
1290 Name = Name.substr(1);
1291
1292 bool IsNegative = Name.startswith("no-");
1293 if (IsNegative)
1294 Name = Name.substr(3);
1295
1296 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1297 // pass the correct option to the backend while calling the frontend
1298 // option the same.
1299 // TODO: Change the LLVM backend option maybe?
1300 if (Name == "mfcrf")
1301 Name = "mfocrf";
1302
1303 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1304 }
1305
1306 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001307 AddTargetFeature(Args, Features, options::OPT_faltivec,
1308 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001309}
1310
Ulrich Weigand8afad612014-07-28 13:17:52 +00001311void Clang::AddPPCTargetArgs(const ArgList &Args,
1312 ArgStringList &CmdArgs) const {
1313 // Select the ABI to use.
1314 const char *ABIName = nullptr;
1315 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1316 ABIName = A->getValue();
1317 } else if (getToolChain().getTriple().isOSLinux())
1318 switch(getToolChain().getArch()) {
1319 case llvm::Triple::ppc64:
1320 ABIName = "elfv1";
1321 break;
1322 case llvm::Triple::ppc64le:
1323 ABIName = "elfv2";
1324 break;
1325 default:
1326 break;
1327 }
1328
1329 if (ABIName) {
1330 CmdArgs.push_back("-target-abi");
1331 CmdArgs.push_back(ABIName);
1332 }
1333}
1334
1335bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1336 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1337 return A && (A->getValue() == StringRef(Value));
1338}
1339
Tom Stellard6674c702013-04-01 20:56:53 +00001340/// Get the (LLVM) name of the R600 gpu we are targeting.
1341static std::string getR600TargetGPU(const ArgList &Args) {
1342 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001343 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001344 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001345 .Cases("rv630", "rv635", "r600")
1346 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001347 .Case("rv740", "rv770")
1348 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001349 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001350 .Case("hemlock", "cypress")
1351 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001352 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001353 }
1354 return "";
1355}
1356
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001357static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001358 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001359 bool SoftFloatABI = true;
1360 if (Arg *A =
1361 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1362 if (A->getOption().matches(options::OPT_mhard_float))
1363 SoftFloatABI = false;
1364 }
1365 if (SoftFloatABI)
1366 Features.push_back("+soft-float");
1367}
1368
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001369void Clang::AddSparcTargetArgs(const ArgList &Args,
1370 ArgStringList &CmdArgs) const {
1371 const Driver &D = getToolChain().getDriver();
1372
Brad Smith10cd0f42014-07-11 20:12:08 +00001373 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001374 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001375 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1376 options::OPT_mhard_float)) {
1377 if (A->getOption().matches(options::OPT_msoft_float))
1378 FloatABI = "soft";
1379 else if (A->getOption().matches(options::OPT_mhard_float))
1380 FloatABI = "hard";
1381 }
1382
1383 // If unspecified, choose the default based on the platform.
1384 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001385 // Assume "soft", but warn the user we are guessing.
1386 FloatABI = "soft";
1387 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001388 }
1389
1390 if (FloatABI == "soft") {
1391 // Floating point operations and argument passing are soft.
1392 //
1393 // FIXME: This changes CPP defines, we need -target-soft-float.
1394 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001395 } else {
1396 assert(FloatABI == "hard" && "Invalid float abi!");
1397 CmdArgs.push_back("-mhard-float");
1398 }
1399}
1400
Richard Sandiford4652d892013-07-19 16:51:51 +00001401static const char *getSystemZTargetCPU(const ArgList &Args) {
1402 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1403 return A->getValue();
1404 return "z10";
1405}
1406
Chandler Carruth953fb082013-01-13 11:46:33 +00001407static const char *getX86TargetCPU(const ArgList &Args,
1408 const llvm::Triple &Triple) {
1409 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001410 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001411 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001412 return "core-avx2";
1413
Chandler Carruth953fb082013-01-13 11:46:33 +00001414 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001415 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001416
1417 // FIXME: Reject attempts to use -march=native unless the target matches
1418 // the host.
1419 //
1420 // FIXME: We should also incorporate the detected target features for use
1421 // with -native.
1422 std::string CPU = llvm::sys::getHostCPUName();
1423 if (!CPU.empty() && CPU != "generic")
1424 return Args.MakeArgString(CPU);
1425 }
1426
1427 // Select the default CPU if none was given (or detection failed).
1428
1429 if (Triple.getArch() != llvm::Triple::x86_64 &&
1430 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001431 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001432
1433 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1434
1435 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001436 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001437 if (Triple.getArchName() == "x86_64h")
1438 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001439 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001440 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001441
Alexey Bataev286d1b92014-01-31 04:07:13 +00001442 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001443 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001444 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001445
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001446 // Everything else goes to x86-64 in 64-bit mode.
1447 if (Is64Bit)
1448 return "x86-64";
1449
1450 switch (Triple.getOS()) {
1451 case llvm::Triple::FreeBSD:
1452 case llvm::Triple::NetBSD:
1453 case llvm::Triple::OpenBSD:
1454 return "i486";
1455 case llvm::Triple::Haiku:
1456 return "i586";
1457 case llvm::Triple::Bitrig:
1458 return "i686";
1459 default:
1460 // Fallback to p4.
1461 return "pentium4";
1462 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001463}
1464
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001465static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1466 switch(T.getArch()) {
1467 default:
1468 return "";
1469
Amara Emerson703da2e2013-10-31 09:32:33 +00001470 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001471 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001472 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001473
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001474 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001475 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001476 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001477 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001478 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001479
1480 case llvm::Triple::mips:
1481 case llvm::Triple::mipsel:
1482 case llvm::Triple::mips64:
1483 case llvm::Triple::mips64el: {
1484 StringRef CPUName;
1485 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001486 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001487 return CPUName;
1488 }
1489
1490 case llvm::Triple::ppc:
1491 case llvm::Triple::ppc64:
1492 case llvm::Triple::ppc64le: {
1493 std::string TargetCPUName = getPPCTargetCPU(Args);
1494 // LLVM may default to generating code for the native CPU,
1495 // but, like gcc, we default to a more generic option for
1496 // each architecture. (except on Darwin)
1497 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1498 if (T.getArch() == llvm::Triple::ppc64)
1499 TargetCPUName = "ppc64";
1500 else if (T.getArch() == llvm::Triple::ppc64le)
1501 TargetCPUName = "ppc64le";
1502 else
1503 TargetCPUName = "ppc";
1504 }
1505 return TargetCPUName;
1506 }
1507
1508 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001509 case llvm::Triple::sparcv9:
1510 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001511 return A->getValue();
1512 return "";
1513
1514 case llvm::Triple::x86:
1515 case llvm::Triple::x86_64:
1516 return getX86TargetCPU(Args, T);
1517
1518 case llvm::Triple::hexagon:
1519 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1520
1521 case llvm::Triple::systemz:
1522 return getSystemZTargetCPU(Args);
1523
1524 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001525 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001526 return getR600TargetGPU(Args);
1527 }
1528}
1529
Alp Tokerce365ca2013-12-02 12:43:03 +00001530static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1531 ArgStringList &CmdArgs) {
1532 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1533 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1534 // forward.
1535 CmdArgs.push_back("-plugin");
1536 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1537 CmdArgs.push_back(Args.MakeArgString(Plugin));
1538
1539 // Try to pass driver level flags relevant to LTO code generation down to
1540 // the plugin.
1541
1542 // Handle flags for selecting CPU variants.
1543 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1544 if (!CPU.empty())
1545 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1546}
1547
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001548static void getX86TargetFeatures(const Driver & D,
1549 const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001550 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001551 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001552 if (Triple.getArchName() == "x86_64h") {
1553 // x86_64h implies quite a few of the more modern subtarget features
1554 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1555 Features.push_back("-rdrnd");
1556 Features.push_back("-aes");
1557 Features.push_back("-pclmul");
1558 Features.push_back("-rtm");
1559 Features.push_back("-hle");
1560 Features.push_back("-fsgsbase");
1561 }
1562
Alexey Volkov54ff0802014-06-25 12:15:36 +00001563 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001564 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001565 if (Triple.getArch() == llvm::Triple::x86_64) {
1566 Features.push_back("+sse4.2");
1567 Features.push_back("+popcnt");
1568 } else
1569 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001570 }
1571
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001572 // Set features according to the -arch flag on MSVC
1573 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1574 StringRef Arch = A->getValue();
1575 bool ArchUsed = false;
1576 // First, look for flags that are shared in x86 and x86-64.
1577 if (Triple.getArch() == llvm::Triple::x86_64 ||
1578 Triple.getArch() == llvm::Triple::x86) {
1579 if (Arch == "AVX" || Arch == "AVX2") {
1580 ArchUsed = true;
1581 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1582 }
1583 }
1584 // Then, look for x86-specific flags.
1585 if (Triple.getArch() == llvm::Triple::x86) {
1586 if (Arch == "IA32") {
1587 ArchUsed = true;
1588 } else if (Arch == "SSE" || Arch == "SSE2") {
1589 ArchUsed = true;
1590 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1591 }
1592 }
1593 if (!ArchUsed)
1594 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1595 }
1596
Jim Grosbach82eee262013-11-16 00:53:35 +00001597 // Now add any that the user explicitly requested on the command line,
1598 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001599 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1600 ie = Args.filtered_end();
1601 it != ie; ++it) {
1602 StringRef Name = (*it)->getOption().getName();
1603 (*it)->claim();
1604
1605 // Skip over "-m".
1606 assert(Name.startswith("m") && "Invalid feature name.");
1607 Name = Name.substr(1);
1608
1609 bool IsNegative = Name.startswith("no-");
1610 if (IsNegative)
1611 Name = Name.substr(3);
1612
1613 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1614 }
1615}
1616
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001617void Clang::AddX86TargetArgs(const ArgList &Args,
1618 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001619 if (!Args.hasFlag(options::OPT_mred_zone,
1620 options::OPT_mno_red_zone,
1621 true) ||
1622 Args.hasArg(options::OPT_mkernel) ||
1623 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001624 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001625
Bob Wilson2616e2e2013-02-10 16:01:41 +00001626 // Default to avoid implicit floating-point for kernel/kext code, but allow
1627 // that to be overridden with -mno-soft-float.
1628 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1629 Args.hasArg(options::OPT_fapple_kext));
1630 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1631 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001632 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001633 options::OPT_mno_implicit_float)) {
1634 const Option &O = A->getOption();
1635 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1636 O.matches(options::OPT_msoft_float));
1637 }
1638 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001639 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001640
1641 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1642 StringRef Value = A->getValue();
1643 if (Value == "intel" || Value == "att") {
1644 CmdArgs.push_back("-mllvm");
1645 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1646 } else {
1647 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1648 << A->getOption().getName() << Value;
1649 }
1650 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001651}
1652
Matthew Curtise8f80a12012-12-06 17:49:03 +00001653static inline bool HasPICArg(const ArgList &Args) {
1654 return Args.hasArg(options::OPT_fPIC)
1655 || Args.hasArg(options::OPT_fpic);
1656}
1657
1658static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1659 return Args.getLastArg(options::OPT_G,
1660 options::OPT_G_EQ,
1661 options::OPT_msmall_data_threshold_EQ);
1662}
1663
1664static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1665 std::string value;
1666 if (HasPICArg(Args))
1667 value = "0";
1668 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1669 value = A->getValue();
1670 A->claim();
1671 }
1672 return value;
1673}
1674
Tony Linthicum76329bf2011-12-12 21:14:55 +00001675void Clang::AddHexagonTargetArgs(const ArgList &Args,
1676 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001677 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001678 CmdArgs.push_back("-mqdsp6-compat");
1679 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001680
Matthew Curtise8f80a12012-12-06 17:49:03 +00001681 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1682 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001683 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001684 CmdArgs.push_back(Args.MakeArgString(
1685 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001686 }
1687
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001688 if (!Args.hasArg(options::OPT_fno_short_enums))
1689 CmdArgs.push_back("-fshort-enums");
1690 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1691 CmdArgs.push_back ("-mllvm");
1692 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1693 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001694 CmdArgs.push_back ("-mllvm");
1695 CmdArgs.push_back ("-machine-sink-split=0");
1696}
1697
Kevin Qin110db6f2014-07-18 07:03:22 +00001698// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001699static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001700 std::vector<const char *> &Features) {
1701 SmallVector<StringRef, 8> Split;
1702 text.split(Split, StringRef("+"), -1, false);
1703
1704 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1705 const char *result = llvm::StringSwitch<const char *>(Split[I])
1706 .Case("fp", "+fp-armv8")
1707 .Case("simd", "+neon")
1708 .Case("crc", "+crc")
1709 .Case("crypto", "+crypto")
1710 .Case("nofp", "-fp-armv8")
1711 .Case("nosimd", "-neon")
1712 .Case("nocrc", "-crc")
1713 .Case("nocrypto", "-crypto")
1714 .Default(nullptr);
1715 if (result)
1716 Features.push_back(result);
1717 else if (Split[I] == "neon" || Split[I] == "noneon")
1718 D.Diag(diag::err_drv_no_neon_modifier);
1719 else
1720 return false;
1721 }
1722 return true;
1723}
1724
1725// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1726// decode CPU and feature.
1727static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1728 std::vector<const char *> &Features) {
1729 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1730 CPU = Split.first;
1731 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57") {
1732 Features.push_back("+neon");
1733 Features.push_back("+crc");
1734 Features.push_back("+crypto");
1735 } else if (CPU == "generic") {
1736 Features.push_back("+neon");
1737 } else {
1738 return false;
1739 }
1740
1741 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1742 return false;
1743
1744 return true;
1745}
1746
1747static bool
1748getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1749 const ArgList &Args,
1750 std::vector<const char *> &Features) {
1751 std::pair<StringRef, StringRef> Split = March.split("+");
1752 if (Split.first != "armv8-a")
1753 return false;
1754
1755 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1756 return false;
1757
1758 return true;
1759}
1760
1761static bool
1762getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1763 const ArgList &Args,
1764 std::vector<const char *> &Features) {
1765 StringRef CPU;
1766 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1767 return false;
1768
1769 return true;
1770}
1771
1772static bool
1773getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1774 const ArgList &Args,
1775 std::vector<const char *> &Features) {
1776 // Handle CPU name is 'native'.
1777 if (Mtune == "native")
1778 Mtune = llvm::sys::getHostCPUName();
1779 if (Mtune == "cyclone") {
1780 Features.push_back("+zcm");
1781 Features.push_back("+zcz");
1782 }
1783 return true;
1784}
1785
1786static bool
1787getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1788 const ArgList &Args,
1789 std::vector<const char *> &Features) {
1790 StringRef CPU;
1791 std::vector<const char *> DecodedFeature;
1792 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1793 return false;
1794
1795 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1796}
1797
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001798static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1799 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001800 Arg *A;
1801 bool success = true;
1802 // Enable NEON by default.
1803 Features.push_back("+neon");
1804 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1805 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1806 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1807 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001808 else if (Args.hasArg(options::OPT_arch))
1809 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1810 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001811
1812 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1813 success =
1814 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1815 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1816 success =
1817 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001818 else if (Args.hasArg(options::OPT_arch))
1819 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1820 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001821
1822 if (!success)
1823 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001824
1825 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1826 Features.push_back("-fp-armv8");
1827 Features.push_back("-crypto");
1828 Features.push_back("-neon");
1829 }
Bradley Smith418c5932014-05-02 15:17:51 +00001830
1831 // En/disable crc
1832 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1833 options::OPT_mnocrc)) {
1834 if (A->getOption().matches(options::OPT_mcrc))
1835 Features.push_back("+crc");
1836 else
1837 Features.push_back("-crc");
1838 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001839}
1840
1841static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001842 const ArgList &Args, ArgStringList &CmdArgs,
1843 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001844 std::vector<const char *> Features;
1845 switch (Triple.getArch()) {
1846 default:
1847 break;
1848 case llvm::Triple::mips:
1849 case llvm::Triple::mipsel:
1850 case llvm::Triple::mips64:
1851 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001852 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001853 break;
1854
1855 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001856 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001857 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001858 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001859 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001860 break;
1861
1862 case llvm::Triple::ppc:
1863 case llvm::Triple::ppc64:
1864 case llvm::Triple::ppc64le:
1865 getPPCTargetFeatures(Args, Features);
1866 break;
1867 case llvm::Triple::sparc:
Brad Smithf436e9e2014-08-19 21:50:15 +00001868 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001869 getSparcTargetFeatures(Args, Features);
1870 break;
1871 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001872 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001873 getAArch64TargetFeatures(D, Args, Features);
1874 break;
1875 case llvm::Triple::x86:
1876 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001877 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001878 break;
1879 }
Rafael Espindola43964802013-08-21 17:34:32 +00001880
1881 // Find the last of each feature.
1882 llvm::StringMap<unsigned> LastOpt;
1883 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1884 const char *Name = Features[I];
1885 assert(Name[0] == '-' || Name[0] == '+');
1886 LastOpt[Name + 1] = I;
1887 }
1888
1889 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1890 // If this feature was overridden, ignore it.
1891 const char *Name = Features[I];
1892 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1893 assert(LastI != LastOpt.end());
1894 unsigned Last = LastI->second;
1895 if (Last != I)
1896 continue;
1897
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001898 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001899 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001900 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001901}
1902
David Majnemerae394812014-12-09 00:12:30 +00001903static bool
1904shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1905 const llvm::Triple &Triple) {
1906 // We use the zero-cost exception tables for Objective-C if the non-fragile
1907 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1908 // later.
1909 if (runtime.isNonFragile())
1910 return true;
1911
1912 if (!Triple.isMacOSX())
1913 return false;
1914
1915 return (!Triple.isMacOSXVersionLT(10,5) &&
1916 (Triple.getArch() == llvm::Triple::x86_64 ||
1917 Triple.getArch() == llvm::Triple::arm));
1918}
1919
Nico Webere8e53112014-05-11 01:04:02 +00001920// exceptionSettings() exists to share the logic between -cc1 and linker
1921// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00001922static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001923 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001924 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001925 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00001926 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001927
David Majnemer8de68642014-12-05 08:11:58 +00001928 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001929}
1930
Anders Carlssone96ab552011-02-28 02:27:16 +00001931/// addExceptionArgs - Adds exception related arguments to the driver command
1932/// arguments. There's a master flag, -fexceptions and also language specific
1933/// flags to enable/disable C++ and Objective-C exceptions.
1934/// This makes it possible to for example disable C++ exceptions but enable
1935/// Objective-C exceptions.
1936static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1937 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001938 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001939 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001940 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001941 if (KernelOrKext) {
1942 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1943 // arguments now to avoid warnings about unused arguments.
1944 Args.ClaimAllArgs(options::OPT_fexceptions);
1945 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1946 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1947 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1948 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1949 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001950 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001951 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001952
David Majnemer8de68642014-12-05 08:11:58 +00001953 // Gather the exception settings from the command line arguments.
1954 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001955
David Majnemerae394812014-12-09 00:12:30 +00001956 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1957 // is not necessarily sensible, but follows GCC.
1958 if (types::isObjC(InputType) &&
1959 Args.hasFlag(options::OPT_fobjc_exceptions,
1960 options::OPT_fno_objc_exceptions,
1961 true)) {
1962 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001963
David Majnemerae394812014-12-09 00:12:30 +00001964 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001965 }
1966
1967 if (types::isCXX(InputType)) {
David Majnemer8de68642014-12-05 08:11:58 +00001968 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001969 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1970 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001971 options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001972 options::OPT_fno_exceptions))
1973 CXXExceptionsEnabled =
1974 A->getOption().matches(options::OPT_fcxx_exceptions) ||
1975 A->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001976
1977 if (CXXExceptionsEnabled) {
1978 CmdArgs.push_back("-fcxx-exceptions");
1979
David Majnemer8de68642014-12-05 08:11:58 +00001980 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001981 }
1982 }
1983
David Majnemer8de68642014-12-05 08:11:58 +00001984 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00001985 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001986}
1987
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001988static bool ShouldDisableAutolink(const ArgList &Args,
1989 const ToolChain &TC) {
1990 bool Default = true;
1991 if (TC.getTriple().isOSDarwin()) {
1992 // The native darwin assembler doesn't support the linker_option directives,
1993 // so we disable them if we think the .s file will be passed to it.
1994 Default = TC.useIntegratedAs();
1995 }
1996 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1997 Default);
1998}
1999
Ted Kremenek62093662013-03-12 17:02:12 +00002000static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2001 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002002 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
2003 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002004 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002005 return !UseDwarfDirectory;
2006}
2007
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002008/// \brief Check whether the given input tree contains any compilation actions.
2009static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002010 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002011 return true;
2012
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002013 for (const auto &Act : *A)
2014 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002015 return true;
2016
2017 return false;
2018}
2019
2020/// \brief Check if -relax-all should be passed to the internal assembler.
2021/// This is done by default when compiling non-assembler source with -O0.
2022static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2023 bool RelaxDefault = true;
2024
2025 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2026 RelaxDefault = A->getOption().matches(options::OPT_O0);
2027
2028 if (RelaxDefault) {
2029 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002030 for (const auto &Act : C.getActions()) {
2031 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002032 RelaxDefault = true;
2033 break;
2034 }
2035 }
2036 }
2037
2038 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2039 RelaxDefault);
2040}
2041
David Blaikie9260ed62013-07-25 21:19:01 +00002042static void CollectArgsForIntegratedAssembler(Compilation &C,
2043 const ArgList &Args,
2044 ArgStringList &CmdArgs,
2045 const Driver &D) {
2046 if (UseRelaxAll(C, Args))
2047 CmdArgs.push_back("-mrelax-all");
2048
David Peixottodfb66142013-11-14 22:52:58 +00002049 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002050 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002051 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2052 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2053 // arg after parsing the '-I' arg.
2054 bool TakeNextArg = false;
2055
David Blaikie9260ed62013-07-25 21:19:01 +00002056 // When using an integrated assembler, translate -Wa, and -Xassembler
2057 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002058 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00002059 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
2060 options::OPT_Xassembler),
2061 ie = Args.filtered_end(); it != ie; ++it) {
2062 const Arg *A = *it;
2063 A->claim();
2064
2065 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2066 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002067 if (TakeNextArg) {
2068 CmdArgs.push_back(Value.data());
2069 TakeNextArg = false;
2070 continue;
2071 }
David Blaikie9260ed62013-07-25 21:19:01 +00002072
2073 if (Value == "-force_cpusubtype_ALL") {
2074 // Do nothing, this is the default and we don't support anything else.
2075 } else if (Value == "-L") {
2076 CmdArgs.push_back("-msave-temp-labels");
2077 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002078 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002079 } else if (Value == "--noexecstack") {
2080 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002081 } else if (Value == "-compress-debug-sections" ||
2082 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002083 CompressDebugSections = true;
2084 } else if (Value == "-nocompress-debug-sections" ||
2085 Value == "--nocompress-debug-sections") {
2086 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002087 } else if (Value.startswith("-I")) {
2088 CmdArgs.push_back(Value.data());
2089 // We need to consume the next argument if the current arg is a plain
2090 // -I. The next arg will be the include directory.
2091 if (Value == "-I")
2092 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002093 } else if (Value.startswith("-gdwarf-")) {
2094 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002095 } else {
2096 D.Diag(diag::err_drv_unsupported_option_argument)
2097 << A->getOption().getName() << Value;
2098 }
2099 }
2100 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002101 if (CompressDebugSections) {
2102 if (llvm::zlib::isAvailable())
2103 CmdArgs.push_back("-compress-debug-sections");
2104 else
2105 D.Diag(diag::warn_debug_compression_unavailable);
2106 }
David Blaikie9260ed62013-07-25 21:19:01 +00002107}
2108
Renato Goline807c122014-01-31 11:47:28 +00002109// Until ARM libraries are build separately, we have them all in one library
2110static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool61770ab2015-01-02 21:47:33 +00002111 // FIXME: handle 64-bit
2112 if (TC.getTriple().isOSWindows() &&
2113 !TC.getTriple().isWindowsItaniumEnvironment())
2114 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002115 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002116 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002117 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002118}
2119
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002120static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2121 // The runtimes are located in the OS-specific resource directory.
2122 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002123 const llvm::Triple &Triple = TC.getTriple();
2124 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002125 StringRef OSLibName =
2126 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002127 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002128 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002129}
2130
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002131static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
2132 bool Shared = false,
2133 const char *Env = "") {
2134 bool IsOSWindows = TC.getTriple().isOSWindows();
2135 StringRef Arch = getArchNameForCompilerRTLib(TC);
2136 const char *Prefix = IsOSWindows ? "" : "lib";
2137 const char *Suffix =
2138 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2139
2140 SmallString<128> Path = getCompilerRTLibDir(TC);
2141 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2142 Arch + Env + Suffix);
2143
2144 return Path;
2145}
2146
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002147// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002148// FIXME: Make sure we can also emit shared objects if they're requested
2149// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002150static void addClangRT(const ToolChain &TC, const ArgList &Args,
2151 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002152 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002153
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002154 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002155 // FIXME: why do we link against gcc when we are using compiler-rt?
2156 CmdArgs.push_back("-lgcc_s");
2157 if (TC.getDriver().CCCIsCXX())
2158 CmdArgs.push_back("-lgcc_eh");
2159 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002160}
2161
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002162static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2163 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002164 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2165 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002166 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002167 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002168 Args.hasArg(options::OPT_fcreate_profile) ||
2169 Args.hasArg(options::OPT_coverage)))
2170 return;
2171
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002172 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002173}
2174
Alexey Samsonov52550342014-09-15 19:58:40 +00002175static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2176 ArgStringList &CmdArgs, StringRef Sanitizer,
2177 bool IsShared) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002178 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2179 ? "-android"
2180 : "";
2181
Alexey Samsonov52550342014-09-15 19:58:40 +00002182 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002183 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002184 if (!IsShared)
2185 CmdArgs.push_back("-whole-archive");
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002186 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared,
2187 Env)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002188 if (!IsShared)
2189 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002190}
2191
Alexey Samsonov52550342014-09-15 19:58:40 +00002192// Tries to use a file with the list of dynamic symbols that need to be exported
2193// from the runtime library. Returns true if the file was found.
2194static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2195 ArgStringList &CmdArgs,
2196 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002197 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2198 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2199 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002200 return true;
2201 }
2202 return false;
2203}
2204
2205static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2206 ArgStringList &CmdArgs) {
2207 // Force linking against the system libraries sanitizers depends on
2208 // (see PR15823 why this is necessary).
2209 CmdArgs.push_back("--no-as-needed");
2210 CmdArgs.push_back("-lpthread");
2211 CmdArgs.push_back("-lrt");
2212 CmdArgs.push_back("-lm");
2213 // There's no libdl on FreeBSD.
2214 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2215 CmdArgs.push_back("-ldl");
2216}
2217
2218static void
2219collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2220 SmallVectorImpl<StringRef> &SharedRuntimes,
2221 SmallVectorImpl<StringRef> &StaticRuntimes,
2222 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2223 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2224 // Collect shared runtimes.
2225 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2226 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002227 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002228
Alexey Samsonov52550342014-09-15 19:58:40 +00002229 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002230 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002231 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2232 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002233 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002234 }
2235 if (SanArgs.needsAsanRt()) {
2236 if (SanArgs.needsSharedAsanRt()) {
2237 HelperStaticRuntimes.push_back("asan-preinit");
2238 } else {
2239 StaticRuntimes.push_back("asan");
2240 if (SanArgs.linkCXXRuntimes())
2241 StaticRuntimes.push_back("asan_cxx");
2242 }
2243 }
2244 if (SanArgs.needsDfsanRt())
2245 StaticRuntimes.push_back("dfsan");
2246 if (SanArgs.needsLsanRt())
2247 StaticRuntimes.push_back("lsan");
2248 if (SanArgs.needsMsanRt())
2249 StaticRuntimes.push_back("msan");
2250 if (SanArgs.needsTsanRt())
2251 StaticRuntimes.push_back("tsan");
2252 // WARNING: UBSan should always go last.
2253 if (SanArgs.needsUbsanRt()) {
2254 // If UBSan is not combined with another sanitizer, we need to pull in
2255 // sanitizer_common explicitly.
2256 if (StaticRuntimes.empty())
2257 HelperStaticRuntimes.push_back("san");
2258 StaticRuntimes.push_back("ubsan");
2259 if (SanArgs.linkCXXRuntimes())
2260 StaticRuntimes.push_back("ubsan_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002261 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002262}
2263
Alexey Samsonov52550342014-09-15 19:58:40 +00002264// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2265// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2266static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002267 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002268 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2269 HelperStaticRuntimes;
2270 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2271 HelperStaticRuntimes);
2272 for (auto RT : SharedRuntimes)
2273 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2274 for (auto RT : HelperStaticRuntimes)
2275 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2276 bool AddExportDynamic = false;
2277 for (auto RT : StaticRuntimes) {
2278 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2279 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2280 }
2281 // If there is a static runtime with no dynamic list, force all the symbols
2282 // to be dynamic to be sure we export sanitizer interface functions.
2283 if (AddExportDynamic)
2284 CmdArgs.push_back("-export-dynamic");
2285 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002286}
2287
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002288static bool shouldUseFramePointerForTarget(const ArgList &Args,
2289 const llvm::Triple &Triple) {
2290 switch (Triple.getArch()) {
2291 // Don't use a frame pointer on linux if optimizing for certain targets.
2292 case llvm::Triple::mips64:
2293 case llvm::Triple::mips64el:
2294 case llvm::Triple::mips:
2295 case llvm::Triple::mipsel:
2296 case llvm::Triple::systemz:
2297 case llvm::Triple::x86:
2298 case llvm::Triple::x86_64:
2299 if (Triple.isOSLinux())
2300 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2301 if (!A->getOption().matches(options::OPT_O0))
2302 return false;
2303 return true;
2304 case llvm::Triple::xcore:
2305 return false;
2306 default:
2307 return true;
2308 }
2309}
2310
Rafael Espindola224dd632011-12-14 21:02:23 +00002311static bool shouldUseFramePointer(const ArgList &Args,
2312 const llvm::Triple &Triple) {
2313 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2314 options::OPT_fomit_frame_pointer))
2315 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2316
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002317 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002318}
2319
Eric Christopherb7d97e92013-04-03 01:58:53 +00002320static bool shouldUseLeafFramePointer(const ArgList &Args,
2321 const llvm::Triple &Triple) {
2322 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2323 options::OPT_momit_leaf_frame_pointer))
2324 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2325
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002326 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002327}
2328
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002329/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002330static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002331 SmallString<128> cwd;
2332 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002333 CmdArgs.push_back("-fdebug-compilation-dir");
2334 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002335 }
2336}
2337
Eric Christopherd3804002013-02-22 20:12:52 +00002338static const char *SplitDebugName(const ArgList &Args,
2339 const InputInfoList &Inputs) {
2340 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2341 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2342 SmallString<128> T(FinalOutput->getValue());
2343 llvm::sys::path::replace_extension(T, "dwo");
2344 return Args.MakeArgString(T);
2345 } else {
2346 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002347 SmallString<128> T(
2348 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002349 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2350 llvm::sys::path::replace_extension(F, "dwo");
2351 T += F;
2352 return Args.MakeArgString(F);
2353 }
2354}
2355
2356static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2357 const Tool &T, const JobAction &JA,
2358 const ArgList &Args, const InputInfo &Output,
2359 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002360 ArgStringList ExtractArgs;
2361 ExtractArgs.push_back("--extract-dwo");
2362
2363 ArgStringList StripArgs;
2364 StripArgs.push_back("--strip-dwo");
2365
2366 // Grabbing the output of the earlier compile step.
2367 StripArgs.push_back(Output.getFilename());
2368 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002369 ExtractArgs.push_back(OutFile);
2370
2371 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002372 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002373
2374 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002375 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002376
2377 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002378 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002379}
2380
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002381/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002382/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2383static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002384 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002385 if (A->getOption().matches(options::OPT_O4) ||
2386 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002387 return true;
2388
2389 if (A->getOption().matches(options::OPT_O0))
2390 return false;
2391
2392 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2393
Rafael Espindola91780de2013-08-26 14:05:41 +00002394 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002395 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002396 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002397 return true;
2398
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002399 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002400 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002401 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002402
2403 unsigned OptLevel = 0;
2404 if (S.getAsInteger(10, OptLevel))
2405 return false;
2406
2407 return OptLevel > 1;
2408 }
2409
2410 return false;
2411}
2412
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002413/// Add -x lang to \p CmdArgs for \p Input.
2414static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2415 ArgStringList &CmdArgs) {
2416 // When using -verify-pch, we don't want to provide the type
2417 // 'precompiled-header' if it was inferred from the file extension
2418 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2419 return;
2420
2421 CmdArgs.push_back("-x");
2422 if (Args.hasArg(options::OPT_rewrite_objc))
2423 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2424 else
2425 CmdArgs.push_back(types::getTypeName(Input.getType()));
2426}
2427
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002428static std::string getMSCompatibilityVersion(const char *VersionStr) {
2429 unsigned Version;
2430 if (StringRef(VersionStr).getAsInteger(10, Version))
2431 return "0";
2432
2433 if (Version < 100)
2434 return llvm::utostr_32(Version) + ".0";
2435
2436 if (Version < 10000)
2437 return llvm::utostr_32(Version / 100) + "." +
2438 llvm::utostr_32(Version % 100);
2439
2440 unsigned Build = 0, Factor = 1;
2441 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2442 Build = Build + (Version % 10) * Factor;
2443 return llvm::utostr_32(Version / 100) + "." +
2444 llvm::utostr_32(Version % 100) + "." +
2445 llvm::utostr_32(Build);
2446}
2447
Rafael Espindola577637a2015-01-03 00:06:04 +00002448// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002449// options that build systems might add but are unused when assembling or only
2450// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002451static void claimNoWarnArgs(const ArgList &Args) {
2452 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002453 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002454 Args.ClaimAllArgs(options::OPT_flto);
2455 Args.ClaimAllArgs(options::OPT_fno_lto);
2456}
2457
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002458void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002459 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002460 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002461 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002462 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002463 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2464 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002465 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002466 ArgStringList CmdArgs;
2467
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002468 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002469 bool IsWindowsCygnus =
2470 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002471 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2472
Daniel Dunbare521a892009-03-31 20:53:55 +00002473 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2474
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002475 // Invoke ourselves in -cc1 mode.
2476 //
2477 // FIXME: Implement custom jobs for internal actions.
2478 CmdArgs.push_back("-cc1");
2479
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002480 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002481 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002482 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002483 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002484
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002485 const llvm::Triple TT(TripleStr);
2486 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2487 TT.getArch() == llvm::Triple::thumb)) {
2488 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2489 unsigned Version;
2490 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2491 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002492 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2493 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002494 }
2495
Tim Northover336f1892014-03-29 13:16:12 +00002496 // Push all default warning arguments that are specific to
2497 // the given target. These come before user provided warning options
2498 // are provided.
2499 getToolChain().addClangWarningOptions(CmdArgs);
2500
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002501 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002502 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002503
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002504 if (isa<AnalyzeJobAction>(JA)) {
2505 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2506 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002507 } else if (isa<MigrateJobAction>(JA)) {
2508 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002509 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002510 if (Output.getType() == types::TY_Dependencies)
2511 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002512 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002513 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002514 if (Args.hasArg(options::OPT_rewrite_objc) &&
2515 !Args.hasArg(options::OPT_g_Group))
2516 CmdArgs.push_back("-P");
2517 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002518 } else if (isa<AssembleJobAction>(JA)) {
2519 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002520
David Blaikie9260ed62013-07-25 21:19:01 +00002521 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002522
2523 // Also ignore explicit -force_cpusubtype_ALL option.
2524 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002525 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002526 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002527 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002528
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002529 if (JA.getType() == types::TY_Nothing)
2530 CmdArgs.push_back("-fsyntax-only");
2531 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002532 CmdArgs.push_back("-emit-pch");
2533 else
2534 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002535 } else if (isa<VerifyPCHJobAction>(JA)) {
2536 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002537 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002538 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2539 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002540
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002541 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002542 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002543 } else if (JA.getType() == types::TY_LLVM_IR ||
2544 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002545 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002546 } else if (JA.getType() == types::TY_LLVM_BC ||
2547 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002548 CmdArgs.push_back("-emit-llvm-bc");
2549 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002550 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002551 } else if (JA.getType() == types::TY_AST) {
2552 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002553 } else if (JA.getType() == types::TY_ModuleFile) {
2554 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002555 } else if (JA.getType() == types::TY_RewrittenObjC) {
2556 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002557 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002558 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2559 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002560 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002561 } else {
2562 assert(JA.getType() == types::TY_PP_Asm &&
2563 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002564 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002565 }
2566
Justin Bognera88f0122014-06-20 22:59:50 +00002567 // We normally speed up the clang process a bit by skipping destructors at
2568 // exit, but when we're generating diagnostics we can rely on some of the
2569 // cleanup.
2570 if (!C.isForDiagnostics())
2571 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002572
John McCallbb79b5f2010-02-13 03:50:24 +00002573 // Disable the verification pass in -asserts builds.
2574#ifdef NDEBUG
2575 CmdArgs.push_back("-disable-llvm-verifier");
2576#endif
2577
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002578 // Set the main file name, so that debug info works even with
2579 // -save-temps.
2580 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002581 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002582
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002583 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002584 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002585 if (Args.hasArg(options::OPT_static))
2586 CmdArgs.push_back("-static-define");
2587
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002588 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002589 // Enable region store model by default.
2590 CmdArgs.push_back("-analyzer-store=region");
2591
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002592 // Treat blocks as analysis entry points.
2593 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2594
Ted Kremenek49c79792011-03-24 00:28:47 +00002595 CmdArgs.push_back("-analyzer-eagerly-assume");
2596
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002597 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002598 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002599 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002600
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002601 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002602 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002603
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002604 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002605 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002606
2607 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002608
Jordan Rose10ad0812013-04-05 17:55:07 +00002609 if (types::isCXX(Inputs[0].getType()))
2610 CmdArgs.push_back("-analyzer-checker=cplusplus");
2611
Nico Webere8e53112014-05-11 01:04:02 +00002612 // Enable the following experimental checkers for testing.
2613 CmdArgs.push_back(
2614 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002615 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2616 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2617 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2618 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2619 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002620 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002621
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002622 // Set the output format. The default is plist, for (lame) historical
2623 // reasons.
2624 CmdArgs.push_back("-analyzer-output");
2625 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002626 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002627 else
2628 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002629
Ted Kremenekfe449a22010-03-22 22:32:05 +00002630 // Disable the presentation of standard compiler warnings when
2631 // using --analyze. We only want to show static analyzer diagnostics
2632 // or frontend errors.
2633 CmdArgs.push_back("-w");
2634
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002635 // Add -Xanalyzer arguments when running as analyzer.
2636 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002637 }
2638
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002639 CheckCodeGenerationOptions(D, Args);
2640
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002641 bool PIE = getToolChain().isPIEDefault();
2642 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002643 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002644
Alexey Bataev40e75222014-01-28 06:30:35 +00002645 // Android-specific defaults for PIC/PIE
2646 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2647 switch (getToolChain().getTriple().getArch()) {
2648 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002649 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002650 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002651 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002652 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002653 case llvm::Triple::mips:
2654 case llvm::Triple::mipsel:
2655 case llvm::Triple::mips64:
2656 case llvm::Triple::mips64el:
2657 PIC = true; // "-fpic"
2658 break;
2659
2660 case llvm::Triple::x86:
2661 case llvm::Triple::x86_64:
2662 PIC = true; // "-fPIC"
2663 IsPICLevelTwo = true;
2664 break;
2665
2666 default:
2667 break;
2668 }
2669 }
2670
Brad Smith5b05db82014-06-24 19:51:29 +00002671 // OpenBSD-specific defaults for PIE
2672 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2673 switch (getToolChain().getTriple().getArch()) {
2674 case llvm::Triple::mips64:
2675 case llvm::Triple::mips64el:
2676 case llvm::Triple::sparc:
2677 case llvm::Triple::x86:
2678 case llvm::Triple::x86_64:
2679 IsPICLevelTwo = false; // "-fpie"
2680 break;
2681
2682 case llvm::Triple::ppc:
2683 case llvm::Triple::sparcv9:
2684 IsPICLevelTwo = true; // "-fPIE"
2685 break;
2686
2687 default:
2688 break;
2689 }
2690 }
2691
Alexey Samsonov090301e2013-04-09 12:28:19 +00002692 // For the PIC and PIE flag options, this logic is different from the
2693 // legacy logic in very old versions of GCC, as that logic was just
2694 // a bug no one had ever fixed. This logic is both more rational and
2695 // consistent with GCC's new logic now that the bugs are fixed. The last
2696 // argument relating to either PIC or PIE wins, and no other argument is
2697 // used. If the last argument is any flavor of the '-fno-...' arguments,
2698 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2699 // at the same level.
2700 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2701 options::OPT_fpic, options::OPT_fno_pic,
2702 options::OPT_fPIE, options::OPT_fno_PIE,
2703 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002704 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2705 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002706 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002707 if (LastPICArg) {
2708 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002709 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2710 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2711 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2712 PIC = PIE || O.matches(options::OPT_fPIC) ||
2713 O.matches(options::OPT_fpic);
2714 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2715 O.matches(options::OPT_fPIC);
2716 } else {
2717 PIE = PIC = false;
2718 }
2719 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002720 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002721
Nick Lewycky609dd662013-10-11 03:33:53 +00002722 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002723 // specified while enabling PIC enabled level 1 PIC, just force it back to
2724 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2725 // informal testing).
2726 if (PIC && getToolChain().getTriple().isOSDarwin())
2727 IsPICLevelTwo |= getToolChain().isPICDefault();
2728
Chandler Carruthc0c04552012-04-08 16:40:35 +00002729 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2730 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002731 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00002732 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002733 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002734 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002735 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002736
Chandler Carruth76a943b2012-11-19 03:52:03 +00002737 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2738 // This is a very special mode. It trumps the other modes, almost no one
2739 // uses it, and it isn't even valid on any OS but Darwin.
2740 if (!getToolChain().getTriple().isOSDarwin())
2741 D.Diag(diag::err_drv_unsupported_opt_for_target)
2742 << A->getSpelling() << getToolChain().getTriple().str();
2743
2744 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2745
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002746 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002747 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002748
Chandler Carruth76a943b2012-11-19 03:52:03 +00002749 // Only a forced PIC mode can cause the actual compile to have PIC defines
2750 // etc., no flags are sufficient. This behavior was selected to closely
2751 // match that of llvm-gcc and Apple GCC before that.
2752 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2753 CmdArgs.push_back("-pic-level");
2754 CmdArgs.push_back("2");
2755 }
2756 } else {
2757 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2758 // handled in Clang's IRGen by the -pie-level flag.
2759 CmdArgs.push_back("-mrelocation-model");
2760 CmdArgs.push_back(PIC ? "pic" : "static");
2761
2762 if (PIC) {
2763 CmdArgs.push_back("-pic-level");
2764 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2765 if (PIE) {
2766 CmdArgs.push_back("-pie-level");
2767 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2768 }
2769 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002770 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002771
Jonathan Roelofsb140a102014-10-03 21:57:44 +00002772 CmdArgs.push_back("-mthread-model");
2773 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2774 CmdArgs.push_back(A->getValue());
2775 else
2776 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2777
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002778 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2779 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002780 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002781
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002782 // LLVM Code Generator Options.
2783
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00002784 if (Args.hasArg(options::OPT_frewrite_map_file) ||
2785 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
2786 for (arg_iterator
2787 MFI = Args.filtered_begin(options::OPT_frewrite_map_file,
2788 options::OPT_frewrite_map_file_EQ),
2789 MFE = Args.filtered_end();
2790 MFI != MFE; ++MFI) {
2791 CmdArgs.push_back("-frewrite-map-file");
2792 CmdArgs.push_back((*MFI)->getValue());
2793 (*MFI)->claim();
2794 }
2795 }
2796
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002797 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2798 StringRef v = A->getValue();
2799 CmdArgs.push_back("-mllvm");
2800 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2801 A->claim();
2802 }
2803
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002804 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2805 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002806 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002807 }
2808
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002809 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2810 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002811 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002812 D.Diag(diag::err_drv_unsupported_opt_for_target)
2813 << A->getSpelling() << getToolChain().getTriple().str();
2814 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2815 CmdArgs.push_back("-fpcc-struct-return");
2816 } else {
2817 assert(A->getOption().matches(options::OPT_freg_struct_return));
2818 CmdArgs.push_back("-freg-struct-return");
2819 }
2820 }
2821
Roman Divacky65b88cd2011-03-01 17:40:53 +00002822 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2823 CmdArgs.push_back("-mrtd");
2824
Rafael Espindola224dd632011-12-14 21:02:23 +00002825 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002826 CmdArgs.push_back("-mdisable-fp-elim");
2827 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2828 options::OPT_fno_zero_initialized_in_bss))
2829 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002830
2831 bool OFastEnabled = isOptimizationLevelFast(Args);
2832 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2833 // enabled. This alias option is being used to simplify the hasFlag logic.
2834 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2835 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002836 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2837 // doesn't do any TBAA.
2838 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002839 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002840 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002841 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002842 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2843 options::OPT_fno_struct_path_tbaa))
2844 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002845 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2846 false))
2847 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002848 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2849 options::OPT_fno_optimize_sibling_calls))
2850 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002851
Eric Christopher006208c2013-04-04 06:29:47 +00002852 // Handle segmented stacks.
2853 if (Args.hasArg(options::OPT_fsplit_stack))
2854 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002855
2856 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2857 // This alias option is being used to simplify the getLastArg logic.
2858 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2859 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002860
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002861 // Handle various floating point optimization flags, mapping them to the
2862 // appropriate LLVM code generation flags. The pattern for all of these is to
2863 // default off the codegen optimizations, and if any flag enables them and no
2864 // flag disables them after the flag enabling them, enable the codegen
2865 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002866 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002867 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002868 options::OPT_ffinite_math_only,
2869 options::OPT_fno_finite_math_only,
2870 options::OPT_fhonor_infinities,
2871 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002872 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2873 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002874 A->getOption().getID() != options::OPT_fhonor_infinities)
2875 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002876 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002877 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002878 options::OPT_ffinite_math_only,
2879 options::OPT_fno_finite_math_only,
2880 options::OPT_fhonor_nans,
2881 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002882 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2883 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002884 A->getOption().getID() != options::OPT_fhonor_nans)
2885 CmdArgs.push_back("-menable-no-nans");
2886
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002887 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2888 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002889 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002890 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002891 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002892 options::OPT_fno_math_errno)) {
2893 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2894 // However, turning *off* -ffast_math merely restores the toolchain default
2895 // (which may be false).
2896 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2897 A->getOption().getID() == options::OPT_ffast_math ||
2898 A->getOption().getID() == options::OPT_Ofast)
2899 MathErrno = false;
2900 else if (A->getOption().getID() == options::OPT_fmath_errno)
2901 MathErrno = true;
2902 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002903 if (MathErrno)
2904 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002905
2906 // There are several flags which require disabling very specific
2907 // optimizations. Any of these being disabled forces us to turn off the
2908 // entire set of LLVM optimizations, so collect them through all the flag
2909 // madness.
2910 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002911 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002912 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002913 options::OPT_funsafe_math_optimizations,
2914 options::OPT_fno_unsafe_math_optimizations,
2915 options::OPT_fassociative_math,
2916 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002917 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2918 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002919 A->getOption().getID() != options::OPT_fno_associative_math)
2920 AssociativeMath = true;
2921 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002922 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002923 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002924 options::OPT_funsafe_math_optimizations,
2925 options::OPT_fno_unsafe_math_optimizations,
2926 options::OPT_freciprocal_math,
2927 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002928 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2929 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002930 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2931 ReciprocalMath = true;
2932 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002933 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002934 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002935 options::OPT_funsafe_math_optimizations,
2936 options::OPT_fno_unsafe_math_optimizations,
2937 options::OPT_fsigned_zeros,
2938 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002939 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2940 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002941 A->getOption().getID() != options::OPT_fsigned_zeros)
2942 SignedZeros = false;
2943 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002944 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002945 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002946 options::OPT_funsafe_math_optimizations,
2947 options::OPT_fno_unsafe_math_optimizations,
2948 options::OPT_ftrapping_math,
2949 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002950 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2951 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002952 A->getOption().getID() != options::OPT_ftrapping_math)
2953 TrappingMath = false;
2954 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2955 !TrappingMath)
2956 CmdArgs.push_back("-menable-unsafe-fp-math");
2957
Lang Hamesaa53b932012-07-06 00:59:19 +00002958
2959 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002960 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002961 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002962 options::OPT_ffp_contract)) {
2963 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002964 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002965 if (Val == "fast" || Val == "on" || Val == "off") {
2966 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2967 } else {
2968 D.Diag(diag::err_drv_unsupported_option_argument)
2969 << A->getOption().getName() << Val;
2970 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002971 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2972 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002973 // If fast-math is set then set the fp-contract mode to fast.
2974 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2975 }
2976 }
2977
Bob Wilson6a039162012-07-19 03:52:53 +00002978 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2979 // and if we find them, tell the frontend to provide the appropriate
2980 // preprocessor macros. This is distinct from enabling any optimizations as
2981 // these options induce language changes which must survive serialization
2982 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002983 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2984 options::OPT_fno_fast_math))
2985 if (!A->getOption().matches(options::OPT_fno_fast_math))
2986 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002987 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2988 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002989 if (A->getOption().matches(options::OPT_ffinite_math_only))
2990 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002991
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002992 // Decide whether to use verbose asm. Verbose assembly is the default on
2993 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002994 bool IsIntegratedAssemblerDefault =
2995 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002996 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002997 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002998 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002999 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003000
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00003001 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003002 IsIntegratedAssemblerDefault))
3003 CmdArgs.push_back("-no-integrated-as");
3004
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003005 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3006 CmdArgs.push_back("-mdebug-pass");
3007 CmdArgs.push_back("Structure");
3008 }
3009 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3010 CmdArgs.push_back("-mdebug-pass");
3011 CmdArgs.push_back("Arguments");
3012 }
3013
John McCall8517abc2010-02-19 02:45:38 +00003014 // Enable -mconstructor-aliases except on darwin, where we have to
3015 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003016 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003017 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003018
John McCall7ef5cb32011-03-18 02:56:14 +00003019 // Darwin's kernel doesn't support guard variables; just die if we
3020 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003021 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003022 CmdArgs.push_back("-fforbid-guard-variables");
3023
Douglas Gregordbe39272011-02-01 15:15:22 +00003024 if (Args.hasArg(options::OPT_mms_bitfields)) {
3025 CmdArgs.push_back("-mms-bitfields");
3026 }
John McCall8517abc2010-02-19 02:45:38 +00003027
Daniel Dunbar306945d2009-09-16 06:17:29 +00003028 // This is a coarse approximation of what llvm-gcc actually does, both
3029 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3030 // complicated ways.
3031 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003032 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3033 options::OPT_fno_asynchronous_unwind_tables,
3034 (getToolChain().IsUnwindTablesDefault() ||
3035 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3036 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003037 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3038 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003039 CmdArgs.push_back("-munwind-tables");
3040
Chandler Carruth05fb5852012-11-21 23:40:23 +00003041 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003042
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003043 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3044 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003045 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003046 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003047
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003048 // FIXME: Handle -mtune=.
3049 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003050
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003051 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003052 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003053 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003054 }
3055
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003056 // Add the target cpu
3057 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3058 llvm::Triple ETriple(ETripleStr);
3059 std::string CPU = getCPUName(Args, ETriple);
3060 if (!CPU.empty()) {
3061 CmdArgs.push_back("-target-cpu");
3062 CmdArgs.push_back(Args.MakeArgString(CPU));
3063 }
3064
Rafael Espindolaeb265472013-08-21 21:59:03 +00003065 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3066 CmdArgs.push_back("-mfpmath");
3067 CmdArgs.push_back(A->getValue());
3068 }
3069
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003070 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003071 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003072
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003073 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003074 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003075 default:
3076 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003077
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003078 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003079 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003080 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003081 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003082 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003083 break;
3084
Tim Northover573cbee2014-05-24 12:52:07 +00003085 case llvm::Triple::aarch64:
3086 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003087 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003088 break;
3089
Eric Christopher0b26a612010-03-02 02:41:08 +00003090 case llvm::Triple::mips:
3091 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003092 case llvm::Triple::mips64:
3093 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003094 AddMIPSTargetArgs(Args, CmdArgs);
3095 break;
3096
Ulrich Weigand8afad612014-07-28 13:17:52 +00003097 case llvm::Triple::ppc:
3098 case llvm::Triple::ppc64:
3099 case llvm::Triple::ppc64le:
3100 AddPPCTargetArgs(Args, CmdArgs);
3101 break;
3102
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003103 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003104 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003105 AddSparcTargetArgs(Args, CmdArgs);
3106 break;
3107
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003108 case llvm::Triple::x86:
3109 case llvm::Triple::x86_64:
3110 AddX86TargetArgs(Args, CmdArgs);
3111 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003112
3113 case llvm::Triple::hexagon:
3114 AddHexagonTargetArgs(Args, CmdArgs);
3115 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003116 }
3117
Hans Wennborg75958c42013-08-08 00:17:41 +00003118 // Add clang-cl arguments.
3119 if (getToolChain().getDriver().IsCLMode())
3120 AddClangCLArgs(Args, CmdArgs);
3121
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003122 // Pass the linker version in use.
3123 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3124 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003125 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003126 }
3127
Eric Christopherb7d97e92013-04-03 01:58:53 +00003128 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003129 CmdArgs.push_back("-momit-leaf-frame-pointer");
3130
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003131 // Explicitly error on some things we know we don't support and can't just
3132 // ignore.
3133 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003134 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3135 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003136 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003137 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003138 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003139 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3140 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003141 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003142 << Unsupported->getOption().getName();
3143 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003144 }
3145
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003146 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003147 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003148 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003149 CmdArgs.push_back("-header-include-file");
3150 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3151 D.CCPrintHeadersFilename : "-");
3152 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003153 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003154 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003155
Chad Rosierbe10f982011-08-02 17:58:04 +00003156 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003157 CmdArgs.push_back("-diagnostic-log-file");
3158 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3159 D.CCLogDiagnosticsFilename : "-");
3160 }
3161
Manman Ren17bdb0f2013-11-20 20:22:14 +00003162 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3163 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003164 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003165 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003166 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3167 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003168 // FIXME: we should support specifying dwarf version with
3169 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003170 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003171 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003172 const llvm::Triple &Triple = getToolChain().getTriple();
3173 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003174 Triple.getOS() == llvm::Triple::FreeBSD ||
3175 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003176 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003177 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003178 CmdArgs.push_back("-gdwarf-2");
3179 else if (A->getOption().matches(options::OPT_gdwarf_3))
3180 CmdArgs.push_back("-gdwarf-3");
3181 else if (A->getOption().matches(options::OPT_gdwarf_4))
3182 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003183 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003184 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003185 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003186 const llvm::Triple &Triple = getToolChain().getTriple();
3187 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003188 Triple.getOS() == llvm::Triple::FreeBSD ||
3189 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003190 CmdArgs.push_back("-gdwarf-2");
3191 else
3192 CmdArgs.push_back("-g");
3193 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003194 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003195
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003196 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3197 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003198 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3199 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003200 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003201
Eric Christopher138c32b2013-09-13 22:37:55 +00003202 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003203 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3204 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003205 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003206 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003207 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003208 CmdArgs.push_back("-g");
3209 CmdArgs.push_back("-backend-option");
3210 CmdArgs.push_back("-split-dwarf=Enable");
3211 }
3212
Eric Christopher138c32b2013-09-13 22:37:55 +00003213 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3214 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3215 CmdArgs.push_back("-backend-option");
3216 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3217 }
Eric Christophereec89c22013-06-18 00:03:50 +00003218
Eric Christopher0d403d22014-02-14 01:27:03 +00003219 // -gdwarf-aranges turns on the emission of the aranges section in the
3220 // backend.
3221 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3222 CmdArgs.push_back("-backend-option");
3223 CmdArgs.push_back("-generate-arange-section");
3224 }
3225
David Blaikief36d9ba2014-01-27 18:52:43 +00003226 if (Args.hasFlag(options::OPT_fdebug_types_section,
3227 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003228 CmdArgs.push_back("-backend-option");
3229 CmdArgs.push_back("-generate-type-units");
3230 }
Eric Christophereec89c22013-06-18 00:03:50 +00003231
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003232 if (Args.hasFlag(options::OPT_ffunction_sections,
3233 options::OPT_fno_function_sections, false)) {
3234 CmdArgs.push_back("-ffunction-sections");
3235 }
3236
3237 if (Args.hasFlag(options::OPT_fdata_sections,
3238 options::OPT_fno_data_sections, false)) {
3239 CmdArgs.push_back("-fdata-sections");
3240 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003241
Chris Lattner3c77a352010-06-22 00:03:40 +00003242 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3243
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003244 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3245 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3246 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3247 D.Diag(diag::err_drv_argument_not_allowed_with)
3248 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3249
3250 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3251
3252 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3253 A->render(Args, CmdArgs);
3254 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3255 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3256
Nick Lewycky207bce32011-04-21 23:44:07 +00003257 if (Args.hasArg(options::OPT_ftest_coverage) ||
3258 Args.hasArg(options::OPT_coverage))
3259 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003260 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3261 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003262 Args.hasArg(options::OPT_coverage))
3263 CmdArgs.push_back("-femit-coverage-data");
3264
Alex Lorenzee024992014-08-04 18:41:51 +00003265 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
3266 !Args.hasArg(options::OPT_fprofile_instr_generate))
3267 D.Diag(diag::err_drv_argument_only_allowed_with)
3268 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3269
3270 if (Args.hasArg(options::OPT_fcoverage_mapping))
3271 CmdArgs.push_back("-fcoverage-mapping");
3272
Nick Lewycky480cb992011-05-04 20:46:58 +00003273 if (C.getArgs().hasArg(options::OPT_c) ||
3274 C.getArgs().hasArg(options::OPT_S)) {
3275 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003276 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003277 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003278 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003279 CoverageFilename = FinalOutput->getValue();
3280 } else {
3281 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3282 }
Nick Lewycky737a4522013-03-07 08:28:53 +00003283 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003284 SmallString<128> Pwd;
3285 if (!llvm::sys::fs::current_path(Pwd)) {
3286 llvm::sys::path::append(Pwd, CoverageFilename.str());
3287 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003288 }
3289 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003290 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003291 }
3292 }
3293
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003294 // Pass options for controlling the default header search paths.
3295 if (Args.hasArg(options::OPT_nostdinc)) {
3296 CmdArgs.push_back("-nostdsysteminc");
3297 CmdArgs.push_back("-nobuiltininc");
3298 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003299 if (Args.hasArg(options::OPT_nostdlibinc))
3300 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003301 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3302 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3303 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003304
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003305 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003306 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003307 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003308
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003309 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3310
Ted Kremenekf7639e12012-03-06 20:06:33 +00003311 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003312 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003313 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003314 options::OPT_ccc_arcmt_modify,
3315 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003316 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003317 switch (A->getOption().getID()) {
3318 default:
3319 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003320 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003321 CmdArgs.push_back("-arcmt-check");
3322 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003323 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003324 CmdArgs.push_back("-arcmt-modify");
3325 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003326 case options::OPT_ccc_arcmt_migrate:
3327 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003328 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003329 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003330
3331 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3332 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003333 break;
John McCalld70fb982011-06-15 23:25:17 +00003334 }
3335 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003336 } else {
3337 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3338 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3339 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003340 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003341
Ted Kremenekf7639e12012-03-06 20:06:33 +00003342 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3343 if (ARCMTEnabled) {
3344 D.Diag(diag::err_drv_argument_not_allowed_with)
3345 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3346 }
3347 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003348 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003349
3350 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003351 options::OPT_objcmt_migrate_subscripting,
3352 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003353 // None specified, means enable them all.
3354 CmdArgs.push_back("-objcmt-migrate-literals");
3355 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003356 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003357 } else {
3358 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3359 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003360 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003361 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003362 } else {
3363 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3364 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3365 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3366 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3367 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3368 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3369 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3370 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3371 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3372 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3373 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3374 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3375 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003376 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003377 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003378 }
3379
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003380 // Add preprocessing options like -I, -D, etc. if we are using the
3381 // preprocessor.
3382 //
3383 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003384 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003385 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003386
Rafael Espindolaa7431922011-07-21 23:40:37 +00003387 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3388 // that "The compiler can only warn and ignore the option if not recognized".
3389 // When building with ccache, it will pass -D options to clang even on
3390 // preprocessed inputs and configure concludes that -fPIC is not supported.
3391 Args.ClaimAllArgs(options::OPT_D);
3392
Alp Toker7874bdc2013-11-15 20:40:58 +00003393 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003394 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3395 if (A->getOption().matches(options::OPT_O4)) {
3396 CmdArgs.push_back("-O3");
3397 D.Diag(diag::warn_O4_is_O3);
3398 } else {
3399 A->render(Args, CmdArgs);
3400 }
3401 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003402
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003403 // Warn about ignored options to clang.
3404 for (arg_iterator it = Args.filtered_begin(
3405 options::OPT_clang_ignored_gcc_optimization_f_Group),
3406 ie = Args.filtered_end(); it != ie; ++it) {
3407 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3408 }
3409
Rafael Espindola577637a2015-01-03 00:06:04 +00003410 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003411
Richard Smith3be1cb22014-08-07 00:24:21 +00003412 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003413 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003414 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3415 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003416 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003417 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003418
3419 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003420 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003421 //
3422 // If a std is supplied, only add -trigraphs if it follows the
3423 // option.
3424 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3425 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003426 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003427 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003428 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003429 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003430 else
3431 Std->render(Args, CmdArgs);
3432
Nico Weber00721502014-12-23 22:32:37 +00003433 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003434 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003435 options::OPT_ftrigraphs,
3436 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003437 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003438 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003439 } else {
3440 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003441 //
3442 // FIXME: Clang doesn't correctly handle -std= when the input language
3443 // doesn't match. For the time being just ignore this for C++ inputs;
3444 // eventually we want to do all the standard defaulting here instead of
3445 // splitting it between the driver and clang -cc1.
3446 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003447 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3448 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003449 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003450 CmdArgs.push_back("-std=c++11");
3451
Nico Weber00721502014-12-23 22:32:37 +00003452 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3453 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003454 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003455
Richard Smith282b4492013-09-04 22:50:31 +00003456 // GCC's behavior for -Wwrite-strings is a bit strange:
3457 // * In C, this "warning flag" changes the types of string literals from
3458 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3459 // for the discarded qualifier.
3460 // * In C++, this is just a normal warning flag.
3461 //
3462 // Implementing this warning correctly in C is hard, so we follow GCC's
3463 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3464 // a non-const char* in C, rather than using this crude hack.
3465 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003466 // FIXME: This should behave just like a warning flag, and thus should also
3467 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3468 Arg *WriteStrings =
3469 Args.getLastArg(options::OPT_Wwrite_strings,
3470 options::OPT_Wno_write_strings, options::OPT_w);
3471 if (WriteStrings &&
3472 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003473 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003474 }
3475
Chandler Carruth61fbf622011-04-23 09:27:53 +00003476 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003477 // during C++ compilation, which it is by default. GCC keeps this define even
3478 // in the presence of '-w', match this behavior bug-for-bug.
3479 if (types::isCXX(InputType) &&
3480 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3481 true)) {
3482 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003483 }
3484
Chandler Carruthe0391482010-05-22 02:21:53 +00003485 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3486 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3487 if (Asm->getOption().matches(options::OPT_fasm))
3488 CmdArgs.push_back("-fgnu-keywords");
3489 else
3490 CmdArgs.push_back("-fno-gnu-keywords");
3491 }
3492
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003493 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3494 CmdArgs.push_back("-fno-dwarf-directory-asm");
3495
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003496 if (ShouldDisableAutolink(Args, getToolChain()))
3497 CmdArgs.push_back("-fno-autolink");
3498
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003499 // Add in -fdebug-compilation-dir if necessary.
3500 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003501
Richard Smith9a568822011-11-21 19:36:32 +00003502 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3503 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003504 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003505 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003506 }
3507
Richard Smith79c927b2013-11-06 19:31:51 +00003508 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3509 CmdArgs.push_back("-foperator-arrow-depth");
3510 CmdArgs.push_back(A->getValue());
3511 }
3512
Richard Smith9a568822011-11-21 19:36:32 +00003513 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3514 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003515 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003516 }
3517
Richard Smitha3d3bd22013-05-08 02:12:03 +00003518 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3519 CmdArgs.push_back("-fconstexpr-steps");
3520 CmdArgs.push_back(A->getValue());
3521 }
3522
Richard Smithb3a14522013-02-22 01:59:51 +00003523 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3524 CmdArgs.push_back("-fbracket-depth");
3525 CmdArgs.push_back(A->getValue());
3526 }
3527
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003528 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3529 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003530 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003531 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003532 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3533 } else
3534 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003535 }
3536
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003537
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003538 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003539 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003540
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003541 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3542 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003543 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003544 }
David Chisnall5778fce2009-08-31 16:41:57 +00003545
Chris Lattnere23003d2010-01-09 21:54:33 +00003546 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3547 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003548 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003549 }
3550
Chris Lattnerb35583d2010-04-07 20:49:23 +00003551 CmdArgs.push_back("-ferror-limit");
3552 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003553 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003554 else
3555 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003556
Chandler Carrutha77a7272010-05-06 04:55:18 +00003557 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3558 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003559 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003560 }
3561
3562 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3563 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003564 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003565 }
3566
Richard Smithf6f003a2011-12-16 19:06:07 +00003567 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3568 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003569 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003570 }
3571
Nick Lewycky24653262014-12-16 21:39:02 +00003572 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3573 CmdArgs.push_back("-fspell-checking-limit");
3574 CmdArgs.push_back(A->getValue());
3575 }
3576
Daniel Dunbar2c978472009-11-04 06:24:47 +00003577 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003578 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003579 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003580 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003581 } else {
3582 // If -fmessage-length=N was not specified, determine whether this is a
3583 // terminal and, if so, implicitly define -fmessage-length appropriately.
3584 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003585 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003586 }
3587
John McCallb4a99d32013-02-19 01:57:35 +00003588 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3589 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3590 options::OPT_fvisibility_ms_compat)) {
3591 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3592 CmdArgs.push_back("-fvisibility");
3593 CmdArgs.push_back(A->getValue());
3594 } else {
3595 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3596 CmdArgs.push_back("-fvisibility");
3597 CmdArgs.push_back("hidden");
3598 CmdArgs.push_back("-ftype-visibility");
3599 CmdArgs.push_back("default");
3600 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003601 }
3602
Douglas Gregor08329632010-06-15 17:05:35 +00003603 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003604
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003605 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3606
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003607 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003608 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3609 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003610 CmdArgs.push_back("-ffreestanding");
3611
Daniel Dunbare357d562009-12-03 18:42:11 +00003612 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003613 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003614 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003615 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3616 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003617 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003618 // AltiVec language extensions aren't relevant for assembling.
3619 if (!isa<PreprocessJobAction>(JA) ||
3620 Output.getType() != types::TY_PP_Asm)
3621 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003622 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3623 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003624
Peter Collingbourne32701642013-11-01 18:16:25 +00003625 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3626 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003627
Eric Christopher459d2712013-02-19 06:16:53 +00003628 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003629 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003630 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003631 getToolChain().getArch() == llvm::Triple::ppc64 ||
3632 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003633 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003634 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003635
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003636 if (getToolChain().SupportsProfiling())
3637 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003638
3639 // -flax-vector-conversions is default.
3640 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3641 options::OPT_fno_lax_vector_conversions))
3642 CmdArgs.push_back("-fno-lax-vector-conversions");
3643
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003644 if (Args.getLastArg(options::OPT_fapple_kext))
3645 CmdArgs.push_back("-fapple-kext");
3646
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003647 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003648 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003649 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003650 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3651 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003652
3653 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3654 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003655 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003656 }
3657
Bob Wilson14adb362012-02-03 06:27:22 +00003658 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003659
Chandler Carruth6e501032011-03-27 00:04:55 +00003660 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3661 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3662 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3663 options::OPT_fno_wrapv)) {
3664 if (A->getOption().matches(options::OPT_fwrapv))
3665 CmdArgs.push_back("-fwrapv");
3666 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3667 options::OPT_fno_strict_overflow)) {
3668 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3669 CmdArgs.push_back("-fwrapv");
3670 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003671
3672 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3673 options::OPT_fno_reroll_loops))
3674 if (A->getOption().matches(options::OPT_freroll_loops))
3675 CmdArgs.push_back("-freroll-loops");
3676
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003677 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003678 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3679 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003680
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003681 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3682
Mahesha S6a682be42012-10-27 07:47:56 +00003683
Daniel Dunbar4930e332009-11-17 08:07:36 +00003684 // -stack-protector=0 is default.
3685 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003686 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3687 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003688 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003689 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003690 if (A->getOption().matches(options::OPT_fstack_protector)) {
3691 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3692 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3693 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003694 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003695 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003696 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003697 } else {
3698 StackProtectorLevel =
3699 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3700 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003701 if (StackProtectorLevel) {
3702 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003703 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003704 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003705
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003706 // --param ssp-buffer-size=
3707 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3708 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003709 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003710 if (Str.startswith("ssp-buffer-size=")) {
3711 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003712 CmdArgs.push_back("-stack-protector-buffer-size");
3713 // FIXME: Verify the argument is a valid integer.
3714 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003715 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003716 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003717 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003718 }
3719
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003720 // Translate -mstackrealign
3721 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3722 false)) {
3723 CmdArgs.push_back("-backend-option");
3724 CmdArgs.push_back("-force-align-stack");
3725 }
3726 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3727 false)) {
3728 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3729 }
3730
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003731 if (Args.hasArg(options::OPT_mstack_alignment)) {
3732 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3733 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003734 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003735
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003736 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3737 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
3738 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3739
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003740 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3741 options::OPT_mno_restrict_it)) {
3742 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3743 CmdArgs.push_back("-backend-option");
3744 CmdArgs.push_back("-arm-restrict-it");
3745 } else {
3746 CmdArgs.push_back("-backend-option");
3747 CmdArgs.push_back("-arm-no-restrict-it");
3748 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003749 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3750 TT.getArch() == llvm::Triple::thumb)) {
3751 // Windows on ARM expects restricted IT blocks
3752 CmdArgs.push_back("-backend-option");
3753 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003754 }
3755
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003756 if (TT.getArch() == llvm::Triple::arm ||
3757 TT.getArch() == llvm::Triple::thumb) {
3758 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3759 options::OPT_mno_long_calls)) {
3760 if (A->getOption().matches(options::OPT_mlong_calls)) {
3761 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003762 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003763 }
3764 }
3765 }
3766
Daniel Dunbard18049a2009-04-07 21:16:11 +00003767 // Forward -f options with positive and negative forms; we translate
3768 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003769 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3770 StringRef fname = A->getValue();
3771 if (!llvm::sys::fs::exists(fname))
3772 D.Diag(diag::err_drv_no_such_file) << fname;
3773 else
3774 A->render(Args, CmdArgs);
3775 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003776
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003777 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003778 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003779 CmdArgs.push_back("-fapple-kext");
3780 if (!Args.hasArg(options::OPT_fbuiltin))
3781 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003782 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003783 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003784 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003785 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003786 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003787
Nuno Lopes13c88c72009-12-16 16:59:22 +00003788 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3789 options::OPT_fno_assume_sane_operator_new))
3790 CmdArgs.push_back("-fno-assume-sane-operator-new");
3791
Daniel Dunbar4930e332009-11-17 08:07:36 +00003792 // -fblocks=0 is default.
3793 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003794 getToolChain().IsBlocksDefault()) ||
3795 (Args.hasArg(options::OPT_fgnu_runtime) &&
3796 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3797 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003798 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003799
3800 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3801 !getToolChain().hasBlocksRuntime())
3802 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003803 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003804
Richard Smithffb65082014-09-30 23:10:19 +00003805 // -fmodules enables modules (off by default).
3806 // Users can pass -fno-cxx-modules to turn off modules support for
3807 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003808 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003809 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3810 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3811 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00003812 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003813 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003814 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003815 HaveModules = true;
3816 }
3817 }
3818
Daniel Jasper07e6c402013-08-05 20:26:17 +00003819 // -fmodule-maps enables module map processing (off by default) for header
3820 // checking. It is implied by -fmodules.
3821 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3822 false)) {
3823 CmdArgs.push_back("-fmodule-maps");
3824 }
3825
Daniel Jasperac42b752013-10-21 06:34:34 +00003826 // -fmodules-decluse checks that modules used are declared so (off by
3827 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003828 if (Args.hasFlag(options::OPT_fmodules_decluse,
3829 options::OPT_fno_modules_decluse,
3830 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003831 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003832 }
3833
Daniel Jasper962b38e2014-04-11 11:47:45 +00003834 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3835 // all #included headers are part of modules.
3836 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3837 options::OPT_fno_modules_strict_decluse,
3838 false)) {
3839 CmdArgs.push_back("-fmodules-strict-decluse");
3840 }
3841
Daniel Jasperac42b752013-10-21 06:34:34 +00003842 // -fmodule-name specifies the module that is currently being built (or
3843 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00003844 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00003845
Richard Smith9887d792014-10-17 01:42:53 +00003846 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00003847 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00003848 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00003849
Richard Smithe842a472014-10-22 02:05:46 +00003850 // -fmodule-file can be used to specify files containing precompiled modules.
3851 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3852
3853 // -fmodule-cache-path specifies where our implicitly-built module files
3854 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00003855 SmallString<128> ModuleCachePath;
3856 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3857 ModuleCachePath = A->getValue();
3858 if (HaveModules) {
3859 if (C.isForDiagnostics()) {
3860 // When generating crash reports, we want to emit the modules along with
3861 // the reproduction sources, so we ignore any provided module path.
3862 ModuleCachePath = Output.getFilename();
3863 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3864 llvm::sys::path::append(ModuleCachePath, "modules");
3865 } else if (ModuleCachePath.empty()) {
3866 // No module path was provided: use the default.
3867 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3868 ModuleCachePath);
3869 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3870 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3871 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003872 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003873 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3874 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3875 }
3876
3877 // When building modules and generating crashdumps, we need to dump a module
3878 // dependency VFS alongside the output.
3879 if (HaveModules && C.isForDiagnostics()) {
3880 SmallString<128> VFSDir(Output.getFilename());
3881 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00003882 // Add the cache directory as a temp so the crash diagnostics pick it up.
3883 C.addTempFile(Args.MakeArgString(VFSDir));
3884
Justin Bognera88f0122014-06-20 22:59:50 +00003885 llvm::sys::path::append(VFSDir, "vfs");
3886 CmdArgs.push_back("-module-dependency-dir");
3887 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003888 }
3889
Richard Smith9887d792014-10-17 01:42:53 +00003890 if (HaveModules)
3891 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003892
Douglas Gregor35b04d62013-02-07 19:01:24 +00003893 // Pass through all -fmodules-ignore-macro arguments.
3894 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003895 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3896 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003897
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003898 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3899
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003900 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3901 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3902 D.Diag(diag::err_drv_argument_not_allowed_with)
3903 << A->getAsString(Args) << "-fbuild-session-timestamp";
3904
3905 llvm::sys::fs::file_status Status;
3906 if (llvm::sys::fs::status(A->getValue(), Status))
3907 D.Diag(diag::err_drv_no_such_file) << A->getValue();
NAKAMURA Takumi0f9447d2014-08-03 01:11:44 +00003908 char TimeStamp[48];
3909 snprintf(TimeStamp, sizeof(TimeStamp), "-fbuild-session-timestamp=%" PRIu64,
3910 (uint64_t)Status.getLastModificationTime().toEpochTime());
3911 CmdArgs.push_back(Args.MakeArgString(TimeStamp));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003912 }
3913
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003914 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003915 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3916 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003917 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3918
3919 Args.AddLastArg(CmdArgs,
3920 options::OPT_fmodules_validate_once_per_build_session);
3921 }
3922
Ben Langmuirdcf73862014-03-12 00:06:17 +00003923 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3924
John McCalldfea9982010-04-09 19:12:06 +00003925 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003926 if (Args.hasFlag(options::OPT_fno_access_control,
3927 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003928 false))
John McCall3155f572010-04-09 19:03:51 +00003929 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003930
Anders Carlssond470fef2010-11-21 00:09:52 +00003931 // -felide-constructors is the default.
3932 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3933 options::OPT_felide_constructors,
3934 false))
3935 CmdArgs.push_back("-fno-elide-constructors");
3936
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003937 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003938 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003939 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003940 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003941
Richard Smith52be6192012-11-05 22:04:41 +00003942 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003943 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003944 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003945 Args.getLastArg(options::OPT_mkernel,
3946 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003947 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003948 D.Diag(diag::err_drv_argument_not_allowed_with)
3949 << "-fsanitize=vptr" << NoRttiArg;
3950 }
3951 }
3952
Tony Linthicum76329bf2011-12-12 21:14:55 +00003953 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003954 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003955 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003956 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003957 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003958 CmdArgs.push_back("-fshort-enums");
3959
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003960 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003961 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003962 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003963 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003964
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003965 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003966 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003967 options::OPT_fno_threadsafe_statics))
3968 CmdArgs.push_back("-fno-threadsafe-statics");
3969
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003970 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003971 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3972 options::OPT_fno_use_cxa_atexit,
3973 !IsWindowsCygnus && !IsWindowsGNU &&
3974 getToolChain().getArch() != llvm::Triple::hexagon &&
3975 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003976 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003977 CmdArgs.push_back("-fno-use-cxa-atexit");
3978
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003979 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003980 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003981 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003982 CmdArgs.push_back("-fms-extensions");
3983
Francois Pichet1b4f1632011-09-17 04:32:15 +00003984 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003985 if (Args.hasFlag(options::OPT_fms_compatibility,
3986 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003987 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3988 options::OPT_fno_ms_extensions,
3989 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003990 CmdArgs.push_back("-fms-compatibility");
3991
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003992 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003993 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003994 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3995 Args.hasArg(options::OPT_fms_compatibility_version)) {
3996 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3997 const Arg *MSCompatibilityVersion =
3998 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003999
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00004000 if (MSCVersion && MSCompatibilityVersion)
4001 D.Diag(diag::err_drv_argument_not_allowed_with)
4002 << MSCVersion->getAsString(Args)
4003 << MSCompatibilityVersion->getAsString(Args);
4004
4005 std::string Ver;
4006 if (MSCompatibilityVersion)
4007 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
4008 else if (MSCVersion)
4009 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
4010
4011 if (Ver.empty())
4012 CmdArgs.push_back("-fms-compatibility-version=17.00");
4013 else
4014 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
4015 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004016
Eric Christopher5ecce122013-02-18 00:38:31 +00004017 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004018 if (Args.hasFlag(options::OPT_fborland_extensions,
4019 options::OPT_fno_borland_extensions, false))
4020 CmdArgs.push_back("-fborland-extensions");
4021
Francois Pichet02744872011-09-01 16:38:08 +00004022 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4023 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004024 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004025 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004026 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004027
Chandler Carruthe03aa552010-04-17 20:17:31 +00004028 // -fgnu-keywords default varies depending on language; only pass if
4029 // specified.
4030 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004031 options::OPT_fno_gnu_keywords))
4032 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004033
Rafael Espindola922a6242011-06-02 17:30:53 +00004034 if (Args.hasFlag(options::OPT_fgnu89_inline,
4035 options::OPT_fno_gnu89_inline,
4036 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004037 CmdArgs.push_back("-fgnu89-inline");
4038
Chad Rosier9c76d242012-03-15 22:31:42 +00004039 if (Args.hasArg(options::OPT_fno_inline))
4040 CmdArgs.push_back("-fno-inline");
4041
Chad Rosier64d6be92012-03-06 21:17:19 +00004042 if (Args.hasArg(options::OPT_fno_inline_functions))
4043 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004044
John McCall5fb5df92012-06-20 06:18:46 +00004045 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004046
John McCall5fb5df92012-06-20 06:18:46 +00004047 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004048 // legacy is the default. Except for deployment taget of 10.5,
4049 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4050 // gets ignored silently.
4051 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004052 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4053 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004054 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004055 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004056 if (getToolChain().UseObjCMixedDispatch())
4057 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4058 else
4059 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4060 }
4061 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004062
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004063 // When ObjectiveC legacy runtime is in effect on MacOSX,
4064 // turn on the option to do Array/Dictionary subscripting
4065 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004066 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
4067 getToolChain().getTriple().isMacOSX() &&
4068 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4069 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004070 objcRuntime.isNeXTFamily())
4071 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4072
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004073 // -fencode-extended-block-signature=1 is default.
4074 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4075 CmdArgs.push_back("-fencode-extended-block-signature");
4076 }
4077
John McCall24fc0de2011-07-06 00:26:06 +00004078 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4079 // NOTE: This logic is duplicated in ToolChains.cpp.
4080 bool ARC = isObjCAutoRefCount(Args);
4081 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004082 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004083
John McCall24fc0de2011-07-06 00:26:06 +00004084 CmdArgs.push_back("-fobjc-arc");
4085
Chandler Carruth491db322011-11-04 07:34:47 +00004086 // FIXME: It seems like this entire block, and several around it should be
4087 // wrapped in isObjC, but for now we just use it here as this is where it
4088 // was being used previously.
4089 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4090 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4091 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4092 else
4093 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4094 }
4095
John McCall24fc0de2011-07-06 00:26:06 +00004096 // Allow the user to enable full exceptions code emission.
4097 // We define off for Objective-CC, on for Objective-C++.
4098 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4099 options::OPT_fno_objc_arc_exceptions,
4100 /*default*/ types::isCXX(InputType)))
4101 CmdArgs.push_back("-fobjc-arc-exceptions");
4102 }
4103
4104 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4105 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004106 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004107 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004108
John McCall24fc0de2011-07-06 00:26:06 +00004109 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4110 // takes precedence.
4111 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4112 if (!GCArg)
4113 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4114 if (GCArg) {
4115 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004116 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004117 << GCArg->getAsString(Args);
4118 } else if (getToolChain().SupportsObjCGC()) {
4119 GCArg->render(Args, CmdArgs);
4120 } else {
4121 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004122 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004123 << GCArg->getAsString(Args);
4124 }
4125 }
4126
Reid Klecknerc542d372014-06-27 17:02:02 +00004127 // Handle GCC-style exception args.
4128 if (!C.getDriver().IsCLMode())
4129 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
4130 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004131
4132 if (getToolChain().UseSjLjExceptions())
4133 CmdArgs.push_back("-fsjlj-exceptions");
4134
4135 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004136 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4137 options::OPT_fno_assume_sane_operator_new))
4138 CmdArgs.push_back("-fno-assume-sane-operator-new");
4139
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004140 // -fconstant-cfstrings is default, and may be subject to argument translation
4141 // on Darwin.
4142 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4143 options::OPT_fno_constant_cfstrings) ||
4144 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4145 options::OPT_mno_constant_cfstrings))
4146 CmdArgs.push_back("-fno-constant-cfstrings");
4147
John Thompsoned4e2952009-11-05 20:14:16 +00004148 // -fshort-wchar default varies depending on platform; only
4149 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004150 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4151 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004152 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004153
Hans Wennborg28c96312013-07-31 23:39:13 +00004154 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004155 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004156 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004157 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004158 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004159
Daniel Dunbar096ed292011-10-05 21:04:55 +00004160 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4161 // -fno-pack-struct doesn't apply to -fpack-struct=.
4162 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004163 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004164 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004165 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004166 } else if (Args.hasFlag(options::OPT_fpack_struct,
4167 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004168 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004169 }
4170
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004171 // Handle -fmax-type-align=N and -fno-type-align
4172 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4173 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4174 if (!SkipMaxTypeAlign) {
4175 std::string MaxTypeAlignStr = "-fmax-type-align=";
4176 MaxTypeAlignStr += A->getValue();
4177 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4178 }
4179 } else if (getToolChain().getTriple().isOSDarwin()) {
4180 if (!SkipMaxTypeAlign) {
4181 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4182 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4183 }
4184 }
4185
Robert Lytton0e076492013-08-13 09:43:10 +00004186 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004187 if (!Args.hasArg(options::OPT_fcommon))
4188 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004189 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004190 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004191
Daniel Dunbard18049a2009-04-07 21:16:11 +00004192 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004193 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004194 CmdArgs.push_back("-fno-common");
4195
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004196 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004197 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004198 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004199 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004200 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004201 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4202
Daniel Dunbar6358d682010-10-15 22:30:42 +00004203 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4204 if (!Args.hasFlag(options::OPT_ffor_scope,
4205 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004206 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004207 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4208
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004209 // -finput_charset=UTF-8 is default. Reject others
4210 if (Arg *inputCharset = Args.getLastArg(
4211 options::OPT_finput_charset_EQ)) {
4212 StringRef value = inputCharset->getValue();
4213 if (value != "UTF-8")
4214 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4215 }
4216
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004217 // -fexec_charset=UTF-8 is default. Reject others
4218 if (Arg *execCharset = Args.getLastArg(
4219 options::OPT_fexec_charset_EQ)) {
4220 StringRef value = execCharset->getValue();
4221 if (value != "UTF-8")
4222 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4223 }
4224
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004225 // -fcaret-diagnostics is default.
4226 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4227 options::OPT_fno_caret_diagnostics, true))
4228 CmdArgs.push_back("-fno-caret-diagnostics");
4229
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004230 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004231 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004232 options::OPT_fno_diagnostics_fixit_info))
4233 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004234
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004235 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004236 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004237 options::OPT_fno_diagnostics_show_option))
4238 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004239
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004240 if (const Arg *A =
4241 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4242 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004243 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004244 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004245
Douglas Gregor643c9222011-05-21 17:07:29 +00004246 if (const Arg *A =
4247 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4248 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004249 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004250 }
4251
Chandler Carruthb6766f02011-03-27 01:50:55 +00004252 if (Arg *A = Args.getLastArg(
4253 options::OPT_fdiagnostics_show_note_include_stack,
4254 options::OPT_fno_diagnostics_show_note_include_stack)) {
4255 if (A->getOption().matches(
4256 options::OPT_fdiagnostics_show_note_include_stack))
4257 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4258 else
4259 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4260 }
4261
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004262 // Color diagnostics are the default, unless the terminal doesn't support
4263 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004264 // Support both clang's -f[no-]color-diagnostics and gcc's
4265 // -f[no-]diagnostics-colors[=never|always|auto].
4266 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004267 for (const auto &Arg : Args) {
4268 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004269 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4270 !O.matches(options::OPT_fdiagnostics_color) &&
4271 !O.matches(options::OPT_fno_color_diagnostics) &&
4272 !O.matches(options::OPT_fno_diagnostics_color) &&
4273 !O.matches(options::OPT_fdiagnostics_color_EQ))
4274 continue;
4275
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004276 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004277 if (O.matches(options::OPT_fcolor_diagnostics) ||
4278 O.matches(options::OPT_fdiagnostics_color)) {
4279 ShowColors = Colors_On;
4280 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4281 O.matches(options::OPT_fno_diagnostics_color)) {
4282 ShowColors = Colors_Off;
4283 } else {
4284 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004285 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004286 if (value == "always")
4287 ShowColors = Colors_On;
4288 else if (value == "never")
4289 ShowColors = Colors_Off;
4290 else if (value == "auto")
4291 ShowColors = Colors_Auto;
4292 else
4293 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4294 << ("-fdiagnostics-color=" + value).str();
4295 }
4296 }
4297 if (ShowColors == Colors_On ||
4298 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004299 CmdArgs.push_back("-fcolor-diagnostics");
4300
Nico Rieck7857d462013-09-11 00:38:02 +00004301 if (Args.hasArg(options::OPT_fansi_escape_codes))
4302 CmdArgs.push_back("-fansi-escape-codes");
4303
Daniel Dunbardb097022009-06-08 21:13:54 +00004304 if (!Args.hasFlag(options::OPT_fshow_source_location,
4305 options::OPT_fno_show_source_location))
4306 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004307
Douglas Gregor643c9222011-05-21 17:07:29 +00004308 if (!Args.hasFlag(options::OPT_fshow_column,
4309 options::OPT_fno_show_column,
4310 true))
4311 CmdArgs.push_back("-fno-show-column");
4312
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004313 if (!Args.hasFlag(options::OPT_fspell_checking,
4314 options::OPT_fno_spell_checking))
4315 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004316
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004317
Chad Rosierc8e56e82012-12-05 21:08:21 +00004318 // -fno-asm-blocks is default.
4319 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4320 false))
4321 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004322
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004323 // Enable vectorization per default according to the optimization level
4324 // selected. For optimization levels that want vectorization we use the alias
4325 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004326 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004327 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004328 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004329 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004330 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004331 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004332
Chad Rosier136d67d2014-04-28 19:30:57 +00004333 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004334 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4335 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004336 options::OPT_fslp_vectorize;
4337 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004338 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004339 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004340
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004341 // -fno-slp-vectorize-aggressive is default.
4342 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004343 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004344 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004345
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004346 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4347 A->render(Args, CmdArgs);
4348
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004349 // -fdollars-in-identifiers default varies depending on platform and
4350 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004351 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004352 options::OPT_fno_dollars_in_identifiers)) {
4353 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004354 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004355 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004356 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004357 }
4358
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004359 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4360 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004361 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004362 options::OPT_fno_unit_at_a_time)) {
4363 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004364 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004365 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004366
Eli Friedman055c9702011-11-02 01:53:16 +00004367 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4368 options::OPT_fno_apple_pragma_pack, false))
4369 CmdArgs.push_back("-fapple-pragma-pack");
4370
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004371 // le32-specific flags:
4372 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4373 // by default.
4374 if (getToolChain().getArch() == llvm::Triple::le32) {
4375 CmdArgs.push_back("-fno-math-builtin");
4376 }
4377
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004378 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004379 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004380 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004381#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004382 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004383 (getToolChain().getArch() == llvm::Triple::arm ||
4384 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004385 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4386 CmdArgs.push_back("-fno-builtin-strcat");
4387 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4388 CmdArgs.push_back("-fno-builtin-strcpy");
4389 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004390#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004391
Justin Bognera88f0122014-06-20 22:59:50 +00004392 // Enable rewrite includes if the user's asked for it or if we're generating
4393 // diagnostics.
4394 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4395 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004396 if (Args.hasFlag(options::OPT_frewrite_includes,
4397 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004398 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004399 CmdArgs.push_back("-frewrite-includes");
4400
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004401 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004402 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004403 options::OPT_traditional_cpp)) {
4404 if (isa<PreprocessJobAction>(JA))
4405 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004406 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004407 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004408 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004409
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004410 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004411 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004412
4413 // Handle serialized diagnostics.
4414 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4415 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004416 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004417 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004418
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004419 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4420 CmdArgs.push_back("-fretain-comments-from-system-headers");
4421
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004422 // Forward -fcomment-block-commands to -cc1.
4423 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004424 // Forward -fparse-all-comments to -cc1.
4425 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004426
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004427 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4428 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004429 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004430 bool OptDisabled = false;
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004431 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4432 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004433 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004434
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004435 // We translate this by hand to the -cc1 argument, since nightly test uses
4436 // it and developers have been trained to spell it with -mllvm.
Bob Wilson23a55f12014-12-21 07:00:00 +00004437 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004438 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004439 OptDisabled = true;
4440 } else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004441 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004442 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004443
Bob Wilson23a55f12014-12-21 07:00:00 +00004444 // With -save-temps, we want to save the unoptimized bitcode output from the
4445 // CompileJobAction, so disable optimizations if they are not already
4446 // disabled.
4447 if (Args.hasArg(options::OPT_save_temps) && !OptDisabled &&
4448 isa<CompileJobAction>(JA))
4449 CmdArgs.push_back("-disable-llvm-optzns");
4450
Daniel Dunbard67a3222009-03-30 06:36:42 +00004451 if (Output.getType() == types::TY_Dependencies) {
4452 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004453 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004454 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004455 CmdArgs.push_back(Output.getFilename());
4456 } else {
4457 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004458 }
4459
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004460 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004461 addDashXForInput(Args, II, CmdArgs);
4462
Daniel Dunbarb440f562010-08-02 02:38:21 +00004463 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004464 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004465 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004466 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004467 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004468
Chris Lattnere9d7d782009-11-03 19:50:27 +00004469 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4470
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004471 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004472
4473 // Optionally embed the -cc1 level arguments into the debug info, for build
4474 // analysis.
4475 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004476 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004477 for (const auto &Arg : Args)
4478 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004479
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004480 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004481 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004482 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004483 SmallString<128> EscapedArg;
4484 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004485 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004486 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004487 }
4488 CmdArgs.push_back("-dwarf-debug-flags");
4489 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4490 }
4491
Eric Christopherd3804002013-02-22 20:12:52 +00004492 // Add the split debug info name to the command lines here so we
4493 // can propagate it to the backend.
4494 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004495 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004496 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4497 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004498 const char *SplitDwarfOut;
4499 if (SplitDwarf) {
4500 CmdArgs.push_back("-split-dwarf-file");
4501 SplitDwarfOut = SplitDebugName(Args, Inputs);
4502 CmdArgs.push_back(SplitDwarfOut);
4503 }
4504
4505 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004506 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004507 Output.getType() == types::TY_Object &&
4508 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004509 auto CLCommand =
4510 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4511 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4512 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004513 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004514 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004515 }
4516
Daniel Dunbar17731772009-03-23 19:03:36 +00004517
Eric Christopherf1545832013-02-22 23:50:16 +00004518 // Handle the debug info splitting at object creation time if we're
4519 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004520 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004521 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004522 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004523
Roman Divacky178e01602011-02-10 16:52:03 +00004524 if (Arg *A = Args.getLastArg(options::OPT_pg))
4525 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004526 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004527 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004528
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004529 // Claim some arguments which clang supports automatically.
4530
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004531 // -fpch-preprocess is used with gcc to add a special marker in the output to
4532 // include the PCH file. Clang's PTH solution is completely transparent, so we
4533 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004534 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004535
Daniel Dunbar17731772009-03-23 19:03:36 +00004536 // Claim some arguments which clang doesn't support, but we don't
4537 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004538 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4539 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004540
Rafael Espindolab0092d72013-09-04 19:37:35 +00004541 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004542 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004543}
4544
John McCall5fb5df92012-06-20 06:18:46 +00004545/// Add options related to the Objective-C runtime/ABI.
4546///
4547/// Returns true if the runtime is non-fragile.
4548ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4549 ArgStringList &cmdArgs,
4550 RewriteKind rewriteKind) const {
4551 // Look for the controlling runtime option.
4552 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4553 options::OPT_fgnu_runtime,
4554 options::OPT_fobjc_runtime_EQ);
4555
4556 // Just forward -fobjc-runtime= to the frontend. This supercedes
4557 // options about fragility.
4558 if (runtimeArg &&
4559 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4560 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004561 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004562 if (runtime.tryParse(value)) {
4563 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4564 << value;
4565 }
4566
4567 runtimeArg->render(args, cmdArgs);
4568 return runtime;
4569 }
4570
4571 // Otherwise, we'll need the ABI "version". Version numbers are
4572 // slightly confusing for historical reasons:
4573 // 1 - Traditional "fragile" ABI
4574 // 2 - Non-fragile ABI, version 1
4575 // 3 - Non-fragile ABI, version 2
4576 unsigned objcABIVersion = 1;
4577 // If -fobjc-abi-version= is present, use that to set the version.
4578 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004579 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004580 if (value == "1")
4581 objcABIVersion = 1;
4582 else if (value == "2")
4583 objcABIVersion = 2;
4584 else if (value == "3")
4585 objcABIVersion = 3;
4586 else
4587 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4588 << value;
4589 } else {
4590 // Otherwise, determine if we are using the non-fragile ABI.
4591 bool nonFragileABIIsDefault =
4592 (rewriteKind == RK_NonFragile ||
4593 (rewriteKind == RK_None &&
4594 getToolChain().IsObjCNonFragileABIDefault()));
4595 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4596 options::OPT_fno_objc_nonfragile_abi,
4597 nonFragileABIIsDefault)) {
4598 // Determine the non-fragile ABI version to use.
4599#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4600 unsigned nonFragileABIVersion = 1;
4601#else
4602 unsigned nonFragileABIVersion = 2;
4603#endif
4604
4605 if (Arg *abiArg = args.getLastArg(
4606 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004607 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004608 if (value == "1")
4609 nonFragileABIVersion = 1;
4610 else if (value == "2")
4611 nonFragileABIVersion = 2;
4612 else
4613 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4614 << value;
4615 }
4616
4617 objcABIVersion = 1 + nonFragileABIVersion;
4618 } else {
4619 objcABIVersion = 1;
4620 }
4621 }
4622
4623 // We don't actually care about the ABI version other than whether
4624 // it's non-fragile.
4625 bool isNonFragile = objcABIVersion != 1;
4626
4627 // If we have no runtime argument, ask the toolchain for its default runtime.
4628 // However, the rewriter only really supports the Mac runtime, so assume that.
4629 ObjCRuntime runtime;
4630 if (!runtimeArg) {
4631 switch (rewriteKind) {
4632 case RK_None:
4633 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4634 break;
4635 case RK_Fragile:
4636 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4637 break;
4638 case RK_NonFragile:
4639 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4640 break;
4641 }
4642
4643 // -fnext-runtime
4644 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4645 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004646 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004647 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4648
4649 // Otherwise, build for a generic macosx port.
4650 } else {
4651 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4652 }
4653
4654 // -fgnu-runtime
4655 } else {
4656 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004657 // Legacy behaviour is to target the gnustep runtime if we are i
4658 // non-fragile mode or the GCC runtime in fragile mode.
4659 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004660 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004661 else
4662 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004663 }
4664
4665 cmdArgs.push_back(args.MakeArgString(
4666 "-fobjc-runtime=" + runtime.getAsString()));
4667 return runtime;
4668}
4669
Reid Klecknerc542d372014-06-27 17:02:02 +00004670static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4671 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4672 I += HaveDash;
4673 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004674}
Reid Klecknerc542d372014-06-27 17:02:02 +00004675
4676struct EHFlags {
4677 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4678 bool Synch;
4679 bool Asynch;
4680 bool NoExceptC;
4681};
4682
4683/// /EH controls whether to run destructor cleanups when exceptions are
4684/// thrown. There are three modifiers:
4685/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4686/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4687/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4688/// - c: Assume that extern "C" functions are implicitly noexcept. This
4689/// modifier is an optimization, so we ignore it for now.
4690/// The default is /EHs-c-, meaning cleanups are disabled.
4691static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4692 EHFlags EH;
4693 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4694 for (auto EHVal : EHArgs) {
4695 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4696 switch (EHVal[I]) {
4697 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4698 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4699 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4700 default: break;
4701 }
4702 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4703 break;
4704 }
4705 }
4706 return EH;
4707}
4708
Hans Wennborg75958c42013-08-08 00:17:41 +00004709void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4710 unsigned RTOptionID = options::OPT__SLASH_MT;
4711
Hans Wennborgf1a74252013-09-10 20:18:04 +00004712 if (Args.hasArg(options::OPT__SLASH_LDd))
4713 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4714 // but defining _DEBUG is sticky.
4715 RTOptionID = options::OPT__SLASH_MTd;
4716
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004717 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004718 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004719
Hans Wennborg75958c42013-08-08 00:17:41 +00004720 switch(RTOptionID) {
4721 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004722 if (Args.hasArg(options::OPT__SLASH_LDd))
4723 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004724 CmdArgs.push_back("-D_MT");
4725 CmdArgs.push_back("-D_DLL");
4726 CmdArgs.push_back("--dependent-lib=msvcrt");
4727 break;
4728 case options::OPT__SLASH_MDd:
4729 CmdArgs.push_back("-D_DEBUG");
4730 CmdArgs.push_back("-D_MT");
4731 CmdArgs.push_back("-D_DLL");
4732 CmdArgs.push_back("--dependent-lib=msvcrtd");
4733 break;
4734 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004735 if (Args.hasArg(options::OPT__SLASH_LDd))
4736 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004737 CmdArgs.push_back("-D_MT");
4738 CmdArgs.push_back("--dependent-lib=libcmt");
4739 break;
4740 case options::OPT__SLASH_MTd:
4741 CmdArgs.push_back("-D_DEBUG");
4742 CmdArgs.push_back("-D_MT");
4743 CmdArgs.push_back("--dependent-lib=libcmtd");
4744 break;
4745 default:
4746 llvm_unreachable("Unexpected option ID.");
4747 }
4748
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004749 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4750 // users want. The /Za flag to cl.exe turns this off, but it's not
4751 // implemented in clang.
4752 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004753
Hans Wennborg8858a032014-07-21 23:42:07 +00004754 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4755 // would produce interleaved output, so ignore /showIncludes in such cases.
4756 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4757 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4758 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004759
David Majnemerf6072342014-07-01 22:24:56 +00004760 // This controls whether or not we emit RTTI data for polymorphic types.
4761 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4762 /*default=*/false))
4763 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004764
Reid Klecknerc542d372014-06-27 17:02:02 +00004765 const Driver &D = getToolChain().getDriver();
4766 EHFlags EH = parseClangCLEHFlags(D, Args);
4767 // FIXME: Do something with NoExceptC.
4768 if (EH.Synch || EH.Asynch) {
4769 CmdArgs.push_back("-fexceptions");
4770 CmdArgs.push_back("-fcxx-exceptions");
4771 }
4772
Hans Wennborge50cec32014-06-13 20:59:54 +00004773 // /EP should expand to -E -P.
4774 if (Args.hasArg(options::OPT__SLASH_EP)) {
4775 CmdArgs.push_back("-E");
4776 CmdArgs.push_back("-P");
4777 }
4778
David Majnemer86c318f2014-02-11 21:05:00 +00004779 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4780 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4781 if (MostGeneralArg && BestCaseArg)
4782 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4783 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4784
4785 if (MostGeneralArg) {
4786 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4787 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4788 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4789
4790 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4791 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4792 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4793 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4794 << FirstConflict->getAsString(Args)
4795 << SecondConflict->getAsString(Args);
4796
4797 if (SingleArg)
4798 CmdArgs.push_back("-fms-memptr-rep=single");
4799 else if (MultipleArg)
4800 CmdArgs.push_back("-fms-memptr-rep=multiple");
4801 else
4802 CmdArgs.push_back("-fms-memptr-rep=virtual");
4803 }
4804
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004805 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4806 A->render(Args, CmdArgs);
4807
Hans Wennborg81f74482013-09-10 01:07:07 +00004808 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4809 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004810 if (Args.hasArg(options::OPT__SLASH_fallback))
4811 CmdArgs.push_back("msvc-fallback");
4812 else
4813 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004814 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004815}
4816
Hans Wennborg1da044a2014-06-26 19:59:02 +00004817visualstudio::Compile *Clang::getCLFallback() const {
4818 if (!CLFallback)
4819 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4820 return CLFallback.get();
4821}
4822
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004823void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004824 const InputInfo &Output,
4825 const InputInfoList &Inputs,
4826 const ArgList &Args,
4827 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004828 ArgStringList CmdArgs;
4829
4830 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4831 const InputInfo &Input = Inputs[0];
4832
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004833 // Don't warn about "clang -w -c foo.s"
4834 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004835 // and "clang -emit-llvm -c foo.s"
4836 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004837
Rafael Espindola577637a2015-01-03 00:06:04 +00004838 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00004839
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004840 // Invoke ourselves in -cc1as mode.
4841 //
4842 // FIXME: Implement custom jobs for internal actions.
4843 CmdArgs.push_back("-cc1as");
4844
4845 // Add the "effective" target triple.
4846 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004847 std::string TripleStr =
4848 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004849 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4850
4851 // Set the output mode, we currently only expect to be used as a real
4852 // assembler.
4853 CmdArgs.push_back("-filetype");
4854 CmdArgs.push_back("obj");
4855
Eric Christopher45f2e712012-12-18 00:31:10 +00004856 // Set the main file name, so that debug info works even with
4857 // -save-temps or preprocessed assembly.
4858 CmdArgs.push_back("-main-file-name");
4859 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4860
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004861 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004862 const llvm::Triple &Triple = getToolChain().getTriple();
4863 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004864 if (!CPU.empty()) {
4865 CmdArgs.push_back("-target-cpu");
4866 CmdArgs.push_back(Args.MakeArgString(CPU));
4867 }
4868
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004869 // Add the target features
4870 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004871 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004872
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004873 // Ignore explicit -force_cpusubtype_ALL option.
4874 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004875
Eric Christopherfc3ee562012-01-10 00:38:01 +00004876 // Determine the original source input.
4877 const Action *SourceAction = &JA;
4878 while (SourceAction->getKind() != Action::InputClass) {
4879 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4880 SourceAction = SourceAction->getInputs()[0];
4881 }
4882
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004883 // Forward -g and handle debug info related flags, assuming we are dealing
4884 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004885 if (SourceAction->getType() == types::TY_Asm ||
4886 SourceAction->getType() == types::TY_PP_Asm) {
4887 Args.ClaimAllArgs(options::OPT_g_Group);
4888 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4889 if (!A->getOption().matches(options::OPT_g0))
4890 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004891
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004892 if (Args.hasArg(options::OPT_gdwarf_2))
4893 CmdArgs.push_back("-gdwarf-2");
4894 if (Args.hasArg(options::OPT_gdwarf_3))
4895 CmdArgs.push_back("-gdwarf-3");
4896 if (Args.hasArg(options::OPT_gdwarf_4))
4897 CmdArgs.push_back("-gdwarf-4");
4898
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004899 // Add the -fdebug-compilation-dir flag if needed.
4900 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004901
4902 // Set the AT_producer to the clang version when using the integrated
4903 // assembler on assembly source files.
4904 CmdArgs.push_back("-dwarf-debug-producer");
4905 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004906 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004907
4908 // Optionally embed the -cc1as level arguments into the debug info, for build
4909 // analysis.
4910 if (getToolChain().UseDwarfDebugFlags()) {
4911 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004912 for (const auto &Arg : Args)
4913 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004914
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004915 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004916 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4917 Flags += Exec;
4918 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004919 SmallString<128> EscapedArg;
4920 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00004921 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004922 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00004923 }
4924 CmdArgs.push_back("-dwarf-debug-flags");
4925 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4926 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004927
4928 // FIXME: Add -static support, once we have it.
4929
David Blaikie372d9502014-01-17 03:17:40 +00004930 // Consume all the warning flags. Usually this would be handled more
4931 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4932 // doesn't handle that so rather than warning about unused flags that are
4933 // actually used, we'll lie by omission instead.
4934 // FIXME: Stop lying and consume only the appropriate driver flags
4935 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4936 ie = Args.filtered_end();
4937 it != ie; ++it)
4938 (*it)->claim();
4939
David Blaikie9260ed62013-07-25 21:19:01 +00004940 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4941 getToolChain().getDriver());
4942
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004943 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004944
4945 assert(Output.isFilename() && "Unexpected lipo output.");
4946 CmdArgs.push_back("-o");
4947 CmdArgs.push_back(Output.getFilename());
4948
Daniel Dunbarb440f562010-08-02 02:38:21 +00004949 assert(Input.isFilename() && "Invalid input.");
4950 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004951
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004952 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00004953 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004954
4955 // Handle the debug info splitting at object creation time if we're
4956 // creating an object.
4957 // TODO: Currently only works on linux with newer objcopy.
4958 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004959 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004960 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4961 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004962}
4963
Reid Kleckner0290c9c2014-09-15 17:45:39 +00004964void GnuTool::anchor() {}
4965
Daniel Dunbara3246a02009-03-18 08:07:30 +00004966void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004967 const InputInfo &Output,
4968 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004969 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004970 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004971 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004972 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004973
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004974 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004975 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004976 // Don't forward any -g arguments to assembly steps.
4977 if (isa<AssembleJobAction>(JA) &&
4978 A->getOption().matches(options::OPT_g_Group))
4979 continue;
4980
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004981 // Don't forward any -W arguments to assembly and link steps.
4982 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4983 A->getOption().matches(options::OPT_W_Group))
4984 continue;
4985
Daniel Dunbar2da02722009-03-19 07:55:12 +00004986 // It is unfortunate that we have to claim here, as this means
4987 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004988 // platforms using a generic gcc, even if we are just using gcc
4989 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004990 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004991 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004992 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004993 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004994
Daniel Dunbar4e295052010-01-25 22:35:08 +00004995 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004996
4997 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004998 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004999 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005000 CmdArgs.push_back(
5001 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005002 }
5003
Daniel Dunbar5716d872009-05-02 21:41:52 +00005004 // Try to force gcc to match the tool chain we want, if we recognize
5005 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005006 //
5007 // FIXME: The triple class should directly provide the information we want
5008 // here.
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005009 llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005010 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005011 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00005012 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5013 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005014 CmdArgs.push_back("-m64");
5015
Daniel Dunbarb440f562010-08-02 02:38:21 +00005016 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005017 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005018 CmdArgs.push_back(Output.getFilename());
5019 } else {
5020 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005021 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005022 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005023
Tony Linthicum76329bf2011-12-12 21:14:55 +00005024 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5025 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005026
5027 // Only pass -x if gcc will understand it; otherwise hope gcc
5028 // understands the suffix correctly. The main use case this would go
5029 // wrong in is for linker inputs if they happened to have an odd
5030 // suffix; really the only way to get this to happen is a command
5031 // like '-x foobar a.c' which will treat a.c like a linker input.
5032 //
5033 // FIXME: For the linker case specifically, can we safely convert
5034 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005035 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005036 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005037 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5038 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005039 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005040 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005041 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005042 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005043 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005044 else if (II.getType() == types::TY_ModuleFile)
5045 D.Diag(diag::err_drv_no_module_support)
5046 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005047
Daniel Dunbara3246a02009-03-18 08:07:30 +00005048 if (types::canTypeBeUserSpecified(II.getType())) {
5049 CmdArgs.push_back("-x");
5050 CmdArgs.push_back(types::getTypeName(II.getType()));
5051 }
5052
Daniel Dunbarb440f562010-08-02 02:38:21 +00005053 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005054 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005055 else {
5056 const Arg &A = II.getInputArg();
5057
5058 // Reverse translate some rewritten options.
5059 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5060 CmdArgs.push_back("-lstdc++");
5061 continue;
5062 }
5063
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005064 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005065 A.render(Args, CmdArgs);
5066 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005067 }
5068
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005069 const std::string customGCCName = D.getCCCGenericGCCName();
5070 const char *GCCName;
5071 if (!customGCCName.empty())
5072 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005073 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005074 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005075 } else
5076 GCCName = "gcc";
5077
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005078 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005079 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005080 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005081}
5082
Daniel Dunbar4e295052010-01-25 22:35:08 +00005083void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5084 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005085 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005086}
5087
Daniel Dunbar4e295052010-01-25 22:35:08 +00005088void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5089 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005090 const Driver &D = getToolChain().getDriver();
5091
Daniel Dunbar4e295052010-01-25 22:35:08 +00005092 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005093 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
5094 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00005095 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005096 else {
5097 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005098 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005099 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005100
Daniel Dunbar4e295052010-01-25 22:35:08 +00005101 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005102 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005103}
5104
Daniel Dunbar4e295052010-01-25 22:35:08 +00005105void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5106 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005107 // The types are (hopefully) good enough.
5108}
5109
Tony Linthicum76329bf2011-12-12 21:14:55 +00005110// Hexagon tools start.
5111void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5112 ArgStringList &CmdArgs) const {
5113
5114}
5115void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5116 const InputInfo &Output,
5117 const InputInfoList &Inputs,
5118 const ArgList &Args,
5119 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005120 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005121
5122 const Driver &D = getToolChain().getDriver();
5123 ArgStringList CmdArgs;
5124
5125 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005126 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005127 CmdArgs.push_back(Args.MakeArgString(MarchString));
5128
5129 RenderExtraToolArgs(JA, CmdArgs);
5130
5131 if (Output.isFilename()) {
5132 CmdArgs.push_back("-o");
5133 CmdArgs.push_back(Output.getFilename());
5134 } else {
5135 assert(Output.isNothing() && "Unexpected output");
5136 CmdArgs.push_back("-fsyntax-only");
5137 }
5138
Matthew Curtise8f80a12012-12-06 17:49:03 +00005139 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5140 if (!SmallDataThreshold.empty())
5141 CmdArgs.push_back(
5142 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005143
Matthew Curtise5df3812012-12-07 17:23:04 +00005144 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5145 options::OPT_Xassembler);
5146
Tony Linthicum76329bf2011-12-12 21:14:55 +00005147 // Only pass -x if gcc will understand it; otherwise hope gcc
5148 // understands the suffix correctly. The main use case this would go
5149 // wrong in is for linker inputs if they happened to have an odd
5150 // suffix; really the only way to get this to happen is a command
5151 // like '-x foobar a.c' which will treat a.c like a linker input.
5152 //
5153 // FIXME: For the linker case specifically, can we safely convert
5154 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005155 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005156 // Don't try to pass LLVM or AST inputs to a generic gcc.
5157 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5158 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5159 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5160 << getToolChain().getTripleString();
5161 else if (II.getType() == types::TY_AST)
5162 D.Diag(clang::diag::err_drv_no_ast_support)
5163 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005164 else if (II.getType() == types::TY_ModuleFile)
5165 D.Diag(diag::err_drv_no_module_support)
5166 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005167
5168 if (II.isFilename())
5169 CmdArgs.push_back(II.getFilename());
5170 else
5171 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5172 II.getInputArg().render(Args, CmdArgs);
5173 }
5174
5175 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005176 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005177 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005178}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005179
Tony Linthicum76329bf2011-12-12 21:14:55 +00005180void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5181 ArgStringList &CmdArgs) const {
5182 // The types are (hopefully) good enough.
5183}
5184
5185void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5186 const InputInfo &Output,
5187 const InputInfoList &Inputs,
5188 const ArgList &Args,
5189 const char *LinkingOutput) const {
5190
Matthew Curtise689b052012-12-06 15:46:07 +00005191 const toolchains::Hexagon_TC& ToolChain =
5192 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5193 const Driver &D = ToolChain.getDriver();
5194
Tony Linthicum76329bf2011-12-12 21:14:55 +00005195 ArgStringList CmdArgs;
5196
Matthew Curtise689b052012-12-06 15:46:07 +00005197 //----------------------------------------------------------------------------
5198 //
5199 //----------------------------------------------------------------------------
5200 bool hasStaticArg = Args.hasArg(options::OPT_static);
5201 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005202 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005203 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5204 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5205 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5206 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005207
Matthew Curtise689b052012-12-06 15:46:07 +00005208 //----------------------------------------------------------------------------
5209 // Silence warnings for various options
5210 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005211
Matthew Curtise689b052012-12-06 15:46:07 +00005212 Args.ClaimAllArgs(options::OPT_g_Group);
5213 Args.ClaimAllArgs(options::OPT_emit_llvm);
5214 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5215 // handled somewhere else.
5216 Args.ClaimAllArgs(options::OPT_static_libgcc);
5217
5218 //----------------------------------------------------------------------------
5219 //
5220 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005221 for (const auto &Opt : ToolChain.ExtraOpts)
5222 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005223
Matthew Curtisf10a5952012-12-06 14:16:43 +00005224 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5225 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005226
Matthew Curtise689b052012-12-06 15:46:07 +00005227 if (buildingLib) {
5228 CmdArgs.push_back("-shared");
5229 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5230 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005231 }
5232
Matthew Curtise689b052012-12-06 15:46:07 +00005233 if (hasStaticArg)
5234 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005235
Matthew Curtise8f80a12012-12-06 17:49:03 +00005236 if (buildPIE && !buildingLib)
5237 CmdArgs.push_back("-pie");
5238
5239 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5240 if (!SmallDataThreshold.empty()) {
5241 CmdArgs.push_back(
5242 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5243 }
5244
Matthew Curtise689b052012-12-06 15:46:07 +00005245 //----------------------------------------------------------------------------
5246 //
5247 //----------------------------------------------------------------------------
5248 CmdArgs.push_back("-o");
5249 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005250
Matthew Curtise689b052012-12-06 15:46:07 +00005251 const std::string MarchSuffix = "/" + MarchString;
5252 const std::string G0Suffix = "/G0";
5253 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005254 const std::string RootDir =
5255 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005256 const std::string StartFilesDir = RootDir
5257 + "hexagon/lib"
5258 + (buildingLib
5259 ? MarchG0Suffix : MarchSuffix);
5260
5261 //----------------------------------------------------------------------------
5262 // moslib
5263 //----------------------------------------------------------------------------
5264 std::vector<std::string> oslibs;
5265 bool hasStandalone= false;
5266
5267 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5268 ie = Args.filtered_end(); it != ie; ++it) {
5269 (*it)->claim();
5270 oslibs.push_back((*it)->getValue());
5271 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005272 }
Matthew Curtise689b052012-12-06 15:46:07 +00005273 if (oslibs.empty()) {
5274 oslibs.push_back("standalone");
5275 hasStandalone = true;
5276 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005277
Matthew Curtise689b052012-12-06 15:46:07 +00005278 //----------------------------------------------------------------------------
5279 // Start Files
5280 //----------------------------------------------------------------------------
5281 if (incStdLib && incStartFiles) {
5282
5283 if (!buildingLib) {
5284 if (hasStandalone) {
5285 CmdArgs.push_back(
5286 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5287 }
5288 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5289 }
5290 std::string initObj = useShared ? "/initS.o" : "/init.o";
5291 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5292 }
5293
5294 //----------------------------------------------------------------------------
5295 // Library Search Paths
5296 //----------------------------------------------------------------------------
5297 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005298 for (const auto &LibPath : LibPaths)
5299 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005300
5301 //----------------------------------------------------------------------------
5302 //
5303 //----------------------------------------------------------------------------
5304 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5305 Args.AddAllArgs(CmdArgs, options::OPT_e);
5306 Args.AddAllArgs(CmdArgs, options::OPT_s);
5307 Args.AddAllArgs(CmdArgs, options::OPT_t);
5308 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5309
5310 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5311
5312 //----------------------------------------------------------------------------
5313 // Libraries
5314 //----------------------------------------------------------------------------
5315 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005316 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005317 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5318 CmdArgs.push_back("-lm");
5319 }
5320
5321 CmdArgs.push_back("--start-group");
5322
5323 if (!buildingLib) {
5324 for(std::vector<std::string>::iterator i = oslibs.begin(),
5325 e = oslibs.end(); i != e; ++i)
5326 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5327 CmdArgs.push_back("-lc");
5328 }
5329 CmdArgs.push_back("-lgcc");
5330
5331 CmdArgs.push_back("--end-group");
5332 }
5333
5334 //----------------------------------------------------------------------------
5335 // End files
5336 //----------------------------------------------------------------------------
5337 if (incStdLib && incStartFiles) {
5338 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5339 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5340 }
5341
5342 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005343 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5344 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005345}
5346// Hexagon tools end.
5347
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005348/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005349const char *arm::getARMCPUForMArch(const ArgList &Args,
5350 const llvm::Triple &Triple) {
5351 StringRef MArch;
5352 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5353 // Otherwise, if we have -march= choose the base CPU for that arch.
5354 MArch = A->getValue();
5355 } else {
5356 // Otherwise, use the Arch from the triple.
5357 MArch = Triple.getArchName();
5358 }
5359
5360 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005361 if (MArch == "native") {
5362 std::string CPU = llvm::sys::getHostCPUName();
5363 if (CPU != "generic") {
5364 // Translate the native cpu into the architecture. The switch below will
5365 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005366 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005367 }
5368 }
5369
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005370 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005371}
5372
5373/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005374StringRef arm::getARMTargetCPU(const ArgList &Args,
5375 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005376 // FIXME: Warn on inconsistent use of -mcpu and -march.
5377 // If we have -mcpu=, use that.
5378 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5379 StringRef MCPU = A->getValue();
5380 // Handle -mcpu=native.
5381 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005382 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005383 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005384 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005385 }
5386
5387 return getARMCPUForMArch(Args, Triple);
5388}
5389
5390/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5391/// CPU.
5392//
5393// FIXME: This is redundant with -mcpu, why does LLVM use this.
5394// FIXME: tblgen this, or kill it!
5395const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5396 return llvm::StringSwitch<const char *>(CPU)
5397 .Case("strongarm", "v4")
5398 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5399 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5400 .Cases("arm920", "arm920t", "arm922t", "v4t")
5401 .Cases("arm940t", "ep9312","v4t")
5402 .Cases("arm10tdmi", "arm1020t", "v5")
5403 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5404 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5405 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5406 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5407 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5408 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Charlie Turner2919cbd2014-11-06 14:59:30 +00005409 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
Renato Golin5886bc32014-10-13 10:22:48 +00005410 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005411 .Cases("cortex-r4", "cortex-r5", "v7r")
5412 .Case("cortex-m0", "v6m")
5413 .Case("cortex-m3", "v7m")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00005414 .Cases("cortex-m4", "cortex-m7", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005415 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005416 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005417 .Cases("cortex-a53", "cortex-a57", "v8")
5418 .Default("");
5419}
5420
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005421bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5422 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5423 return A && (A->getValue() == StringRef(Value));
5424}
5425
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005426bool mips::isUCLibc(const ArgList &Args) {
5427 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005428 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005429}
5430
Daniel Sanders2bf13662014-07-10 14:40:57 +00005431bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005432 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5433 return llvm::StringSwitch<bool>(NaNArg->getValue())
5434 .Case("2008", true)
5435 .Case("legacy", false)
5436 .Default(false);
5437
5438 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005439 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5440 .Cases("mips32r6", "mips64r6", true)
5441 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005442
5443 return false;
5444}
5445
Daniel Sanders379d44b2014-07-16 11:52:23 +00005446bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5447 StringRef ABIName) {
5448 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005449 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005450 return false;
5451
5452 if (ABIName != "32")
5453 return false;
5454
5455 return llvm::StringSwitch<bool>(CPUName)
5456 .Cases("mips2", "mips3", "mips4", "mips5", true)
5457 .Cases("mips32", "mips32r2", true)
5458 .Cases("mips64", "mips64r2", true)
5459 .Default(false);
5460}
5461
Tim Northover157d9112014-01-16 08:48:16 +00005462llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005463 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5464 // archs which Darwin doesn't use.
5465
5466 // The matching this routine does is fairly pointless, since it is neither the
5467 // complete architecture list, nor a reasonable subset. The problem is that
5468 // historically the driver driver accepts this and also ties its -march=
5469 // handling to the architecture name, so we need to be careful before removing
5470 // support for it.
5471
5472 // This code must be kept in sync with Clang's Darwin specific argument
5473 // translation.
5474
5475 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5476 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5477 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5478 .Case("ppc64", llvm::Triple::ppc64)
5479 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5480 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5481 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005482 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005483 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005484 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005485 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005486 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005487 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005488 .Case("r600", llvm::Triple::r600)
Tom Stellardd8e38a32015-01-06 20:34:47 +00005489 .Case("amdgcn", llvm::Triple::amdgcn)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005490 .Case("nvptx", llvm::Triple::nvptx)
5491 .Case("nvptx64", llvm::Triple::nvptx64)
5492 .Case("amdil", llvm::Triple::amdil)
5493 .Case("spir", llvm::Triple::spir)
5494 .Default(llvm::Triple::UnknownArch);
5495}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005496
Tim Northover157d9112014-01-16 08:48:16 +00005497void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5498 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5499 T.setArch(Arch);
5500
5501 if (Str == "x86_64h")
5502 T.setArchName(Str);
5503 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5504 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005505 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005506 }
5507}
5508
Bob Wilsondecc03e2012-11-23 06:14:39 +00005509const char *Clang::getBaseInputName(const ArgList &Args,
5510 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005511 return Args.MakeArgString(
5512 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005513}
5514
Bob Wilsondecc03e2012-11-23 06:14:39 +00005515const char *Clang::getBaseInputStem(const ArgList &Args,
5516 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005517 const char *Str = getBaseInputName(Args, Inputs);
5518
Chris Lattner906bb902011-01-16 08:14:11 +00005519 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005520 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005521
5522 return Str;
5523}
5524
Bob Wilsondecc03e2012-11-23 06:14:39 +00005525const char *Clang::getDependencyFileName(const ArgList &Args,
5526 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005527 // FIXME: Think about this more.
5528 std::string Res;
5529
5530 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005531 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005532 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005533 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005534 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005535 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005536 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005537}
5538
Daniel Dunbarbe220842009-03-20 16:06:39 +00005539void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005540 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005541 const InputInfoList &Inputs,
5542 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005543 const char *LinkingOutput) const {
5544 ArgStringList CmdArgs;
5545
5546 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5547 const InputInfo &Input = Inputs[0];
5548
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005549 // Determine the original source input.
5550 const Action *SourceAction = &JA;
5551 while (SourceAction->getKind() != Action::InputClass) {
5552 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5553 SourceAction = SourceAction->getInputs()[0];
5554 }
5555
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005556 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005557 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005558 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5559 // FIXME: at run-time detect assembler capabilities or rely on version
5560 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005561 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005562 const llvm::Triple &T(getToolChain().getTriple());
5563 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005564 CmdArgs.push_back("-Q");
5565 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005566
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005567 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005568 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005569 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005570 if (Args.hasArg(options::OPT_gstabs))
5571 CmdArgs.push_back("--gstabs");
5572 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005573 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005574 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005575
Daniel Dunbarbe220842009-03-20 16:06:39 +00005576 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005577 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005578
Daniel Dunbar6d484762010-07-22 01:47:22 +00005579 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005580 if (getToolChain().getArch() == llvm::Triple::x86 ||
5581 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005582 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5583 CmdArgs.push_back("-force_cpusubtype_ALL");
5584
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005585 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005586 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005587 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005588 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005589 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005590 CmdArgs.push_back("-static");
5591
Daniel Dunbarbe220842009-03-20 16:06:39 +00005592 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5593 options::OPT_Xassembler);
5594
5595 assert(Output.isFilename() && "Unexpected lipo output.");
5596 CmdArgs.push_back("-o");
5597 CmdArgs.push_back(Output.getFilename());
5598
Daniel Dunbarb440f562010-08-02 02:38:21 +00005599 assert(Input.isFilename() && "Invalid input.");
5600 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005601
5602 // asm_final spec is empty.
5603
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005604 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005605 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005606 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005607}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005608
Tim Northover157d9112014-01-16 08:48:16 +00005609void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005610
Tim Northover157d9112014-01-16 08:48:16 +00005611void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5612 ArgStringList &CmdArgs) const {
5613 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005614
Daniel Dunbarc1964212009-03-26 16:23:12 +00005615 // Derived from darwin_arch spec.
5616 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005617 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005618
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005619 // FIXME: Is this needed anymore?
5620 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005621 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005622}
5623
Bill Wendling3b2000f2012-10-02 18:02:50 +00005624bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5625 // We only need to generate a temp path for LTO if we aren't compiling object
5626 // files. When compiling source files, we run 'dsymutil' after linking. We
5627 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005628 for (const auto &Input : Inputs)
5629 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005630 return true;
5631
5632 return false;
5633}
5634
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005635void darwin::Link::AddLinkArgs(Compilation &C,
5636 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005637 ArgStringList &CmdArgs,
5638 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005639 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005640 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005641
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005642 unsigned Version[3] = { 0, 0, 0 };
5643 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5644 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005645 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005646 Version[1], Version[2], HadExtra) ||
5647 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005648 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005649 << A->getAsString(Args);
5650 }
5651
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005652 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005653 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005654 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5655 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005656
Bob Wilson3d27dad2013-08-02 22:25:34 +00005657 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5658 CmdArgs.push_back("-export_dynamic");
5659
Bill Wendling313b6bf2012-11-16 23:03:00 +00005660 // If we are using LTO, then automatically create a temporary file path for
5661 // the linker to use, so that it's lifetime will extend past a possible
5662 // dsymutil step.
5663 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5664 const char *TmpPath = C.getArgs().MakeArgString(
5665 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5666 C.addTempFile(TmpPath);
5667 CmdArgs.push_back("-object_path_lto");
5668 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005669 }
5670
Daniel Dunbarc1964212009-03-26 16:23:12 +00005671 // Derived from the "link" spec.
5672 Args.AddAllArgs(CmdArgs, options::OPT_static);
5673 if (!Args.hasArg(options::OPT_static))
5674 CmdArgs.push_back("-dynamic");
5675 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5676 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5677 // here. How do we wish to handle such things?
5678 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005679
Daniel Dunbarc1964212009-03-26 16:23:12 +00005680 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005681 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005682 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005683 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005684
5685 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5686 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5687 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5688
5689 Arg *A;
5690 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5691 (A = Args.getLastArg(options::OPT_current__version)) ||
5692 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005693 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005694 << A->getAsString(Args) << "-dynamiclib";
5695
5696 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5697 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5698 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5699 } else {
5700 CmdArgs.push_back("-dylib");
5701
5702 Arg *A;
5703 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5704 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5705 (A = Args.getLastArg(options::OPT_client__name)) ||
5706 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5707 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5708 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005709 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005710 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005711
Daniel Dunbarc1964212009-03-26 16:23:12 +00005712 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5713 "-dylib_compatibility_version");
5714 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5715 "-dylib_current_version");
5716
Tim Northover157d9112014-01-16 08:48:16 +00005717 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005718
5719 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5720 "-dylib_install_name");
5721 }
5722
5723 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5724 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5725 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005726 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005727 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005728 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5729 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5730 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5731 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5732 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5733 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005734 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005735 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5736 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5737 Args.AddAllArgs(CmdArgs, options::OPT_init);
5738
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005739 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005740 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005741
Daniel Dunbarc1964212009-03-26 16:23:12 +00005742 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5743 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5744 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5745 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5746 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005747
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005748 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5749 options::OPT_fno_pie,
5750 options::OPT_fno_PIE)) {
5751 if (A->getOption().matches(options::OPT_fpie) ||
5752 A->getOption().matches(options::OPT_fPIE))
5753 CmdArgs.push_back("-pie");
5754 else
5755 CmdArgs.push_back("-no_pie");
5756 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005757
5758 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5759 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5760 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5761 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5762 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5763 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5764 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5765 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5766 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5767 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5768 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5769 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5770 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5771 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5772 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5773 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005774
Daniel Dunbar84384642011-05-02 21:03:47 +00005775 // Give --sysroot= preference, over the Apple specific behavior to also use
5776 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005777 StringRef sysroot = C.getSysRoot();
5778 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005779 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005780 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005781 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5782 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005783 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005784 }
5785
Daniel Dunbarc1964212009-03-26 16:23:12 +00005786 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5787 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5788 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5789 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5790 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005791 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005792 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5793 Args.AddAllArgs(CmdArgs, options::OPT_y);
5794 Args.AddLastArg(CmdArgs, options::OPT_w);
5795 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5796 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5797 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5798 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5799 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5800 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5801 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5802 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5803 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5804 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5805 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5806 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5807}
5808
Alexey Bataev186b28a2014-03-06 05:43:53 +00005809enum LibOpenMP {
5810 LibUnknown,
5811 LibGOMP,
5812 LibIOMP5
5813};
5814
Daniel Dunbarc1964212009-03-26 16:23:12 +00005815void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005816 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005817 const InputInfoList &Inputs,
5818 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005819 const char *LinkingOutput) const {
5820 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005821
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005822 // If the number of arguments surpasses the system limits, we will encode the
5823 // input files in a separate file, shortening the command line. To this end,
5824 // build a list of input file names that can be passed via a file with the
5825 // -filelist linker option.
5826 llvm::opt::ArgStringList InputFileList;
5827
Daniel Dunbarc1964212009-03-26 16:23:12 +00005828 // The logic here is derived from gcc's behavior; most of which
5829 // comes from specs (starting with link_command). Consult gcc for
5830 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005831 ArgStringList CmdArgs;
5832
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005833 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5834 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5835 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005836 for (const auto &Arg : Args)
5837 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005838 const char *Exec =
5839 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5840 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00005841 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005842 return;
5843 }
5844
Daniel Dunbarc1964212009-03-26 16:23:12 +00005845 // I'm not sure why this particular decomposition exists in gcc, but
5846 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005847 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005848
Daniel Dunbarc1964212009-03-26 16:23:12 +00005849 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5850 Args.AddAllArgs(CmdArgs, options::OPT_s);
5851 Args.AddAllArgs(CmdArgs, options::OPT_t);
5852 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5853 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005854 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005855 Args.AddAllArgs(CmdArgs, options::OPT_r);
5856
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005857 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5858 // members of static archive libraries which implement Objective-C classes or
5859 // categories.
5860 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5861 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005862
Daniel Dunbarc1964212009-03-26 16:23:12 +00005863 CmdArgs.push_back("-o");
5864 CmdArgs.push_back(Output.getFilename());
5865
Chad Rosier06fd3c62012-05-16 23:45:12 +00005866 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005867 !Args.hasArg(options::OPT_nostartfiles))
5868 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005869
5870 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005871
Alexey Bataev186b28a2014-03-06 05:43:53 +00005872 LibOpenMP UsedOpenMPLib = LibUnknown;
5873 if (Args.hasArg(options::OPT_fopenmp)) {
5874 UsedOpenMPLib = LibGOMP;
5875 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5876 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5877 .Case("libgomp", LibGOMP)
5878 .Case("libiomp5", LibIOMP5)
5879 .Default(LibUnknown);
5880 if (UsedOpenMPLib == LibUnknown)
5881 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5882 << A->getOption().getName() << A->getValue();
5883 }
5884 switch (UsedOpenMPLib) {
5885 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005886 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005887 break;
5888 case LibIOMP5:
5889 CmdArgs.push_back("-liomp5");
5890 break;
5891 case LibUnknown:
5892 break;
5893 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005894
Douglas Gregor9295df02012-05-15 21:00:27 +00005895 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005896 // Build the input file for -filelist (list of linker input files) in case we
5897 // need it later
5898 for (const auto &II : Inputs) {
5899 if (!II.isFilename()) {
5900 // This is a linker input argument.
5901 // We cannot mix input arguments and file names in a -filelist input, thus
5902 // we prematurely stop our list (remaining files shall be passed as
5903 // arguments).
5904 if (InputFileList.size() > 0)
5905 break;
5906
5907 continue;
5908 }
5909
5910 InputFileList.push_back(II.getFilename());
5911 }
5912
Bob Wilson16d93952012-05-15 18:57:39 +00005913 if (isObjCRuntimeLinked(Args) &&
5914 !Args.hasArg(options::OPT_nostdlib) &&
5915 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005916 // We use arclite library for both ARC and subscripting support.
5917 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5918
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005919 CmdArgs.push_back("-framework");
5920 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005921 // Link libobj.
5922 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005923 }
John McCall31168b02011-06-15 23:02:42 +00005924
Daniel Dunbarc1964212009-03-26 16:23:12 +00005925 if (LinkingOutput) {
5926 CmdArgs.push_back("-arch_multiple");
5927 CmdArgs.push_back("-final_output");
5928 CmdArgs.push_back(LinkingOutput);
5929 }
5930
Daniel Dunbarc1964212009-03-26 16:23:12 +00005931 if (Args.hasArg(options::OPT_fnested_functions))
5932 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005933
Daniel Dunbarc1964212009-03-26 16:23:12 +00005934 if (!Args.hasArg(options::OPT_nostdlib) &&
5935 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005936 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005937 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005938
Daniel Dunbarc1964212009-03-26 16:23:12 +00005939 // link_ssp spec is empty.
5940
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005941 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005942 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005943 }
5944
Chad Rosier06fd3c62012-05-16 23:45:12 +00005945 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005946 !Args.hasArg(options::OPT_nostartfiles)) {
5947 // endfile_spec is empty.
5948 }
5949
5950 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5951 Args.AddAllArgs(CmdArgs, options::OPT_F);
5952
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005953 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005954 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005955 std::unique_ptr<Command> Cmd =
5956 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
5957 Cmd->setInputFileList(std::move(InputFileList));
5958 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005959}
5960
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005961void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005962 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005963 const InputInfoList &Inputs,
5964 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005965 const char *LinkingOutput) const {
5966 ArgStringList CmdArgs;
5967
5968 CmdArgs.push_back("-create");
5969 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005970
5971 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005972 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005973
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005974 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005975 assert(II.isFilename() && "Unexpected lipo input.");
5976 CmdArgs.push_back(II.getFilename());
5977 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005978
5979 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00005980 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005981}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005982
Daniel Dunbar88299622010-06-04 18:28:36 +00005983void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005984 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005985 const InputInfoList &Inputs,
5986 const ArgList &Args,
5987 const char *LinkingOutput) const {
5988 ArgStringList CmdArgs;
5989
Daniel Dunbareb86b042011-05-09 17:23:16 +00005990 CmdArgs.push_back("-o");
5991 CmdArgs.push_back(Output.getFilename());
5992
Daniel Dunbar88299622010-06-04 18:28:36 +00005993 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5994 const InputInfo &Input = Inputs[0];
5995 assert(Input.isFilename() && "Unexpected dsymutil input.");
5996 CmdArgs.push_back(Input.getFilename());
5997
Daniel Dunbar88299622010-06-04 18:28:36 +00005998 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005999 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00006000 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006001}
6002
Eric Christopher551ef452011-08-23 17:56:55 +00006003void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006004 const InputInfo &Output,
6005 const InputInfoList &Inputs,
6006 const ArgList &Args,
6007 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006008 ArgStringList CmdArgs;
6009 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006010 CmdArgs.push_back("--debug-info");
6011 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006012 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006013
6014 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6015 const InputInfo &Input = Inputs[0];
6016 assert(Input.isFilename() && "Unexpected verify input");
6017
6018 // Grabbing the output of the earlier dsymutil run.
6019 CmdArgs.push_back(Input.getFilename());
6020
6021 const char *Exec =
6022 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00006023 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006024}
6025
David Chisnallf571cde2012-02-15 13:39:01 +00006026void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6027 const InputInfo &Output,
6028 const InputInfoList &Inputs,
6029 const ArgList &Args,
6030 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006031 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006032 ArgStringList CmdArgs;
6033
6034 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6035 options::OPT_Xassembler);
6036
6037 CmdArgs.push_back("-o");
6038 CmdArgs.push_back(Output.getFilename());
6039
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006040 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006041 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006042
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006043 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006044 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006045}
6046
David Chisnallf571cde2012-02-15 13:39:01 +00006047void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6048 const InputInfo &Output,
6049 const InputInfoList &Inputs,
6050 const ArgList &Args,
6051 const char *LinkingOutput) const {
6052 // FIXME: Find a real GCC, don't hard-code versions here
6053 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6054 const llvm::Triple &T = getToolChain().getTriple();
6055 std::string LibPath = "/usr/lib/";
6056 llvm::Triple::ArchType Arch = T.getArch();
6057 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006058 case llvm::Triple::x86:
6059 GCCLibPath +=
6060 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6061 break;
6062 case llvm::Triple::x86_64:
6063 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6064 GCCLibPath += "/4.5.2/amd64/";
6065 LibPath += "amd64/";
6066 break;
6067 default:
6068 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006069 }
6070
6071 ArgStringList CmdArgs;
6072
David Chisnall272a0712012-02-29 15:06:12 +00006073 // Demangle C++ names in errors
6074 CmdArgs.push_back("-C");
6075
David Chisnallf571cde2012-02-15 13:39:01 +00006076 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6077 (!Args.hasArg(options::OPT_shared))) {
6078 CmdArgs.push_back("-e");
6079 CmdArgs.push_back("_start");
6080 }
6081
6082 if (Args.hasArg(options::OPT_static)) {
6083 CmdArgs.push_back("-Bstatic");
6084 CmdArgs.push_back("-dn");
6085 } else {
6086 CmdArgs.push_back("-Bdynamic");
6087 if (Args.hasArg(options::OPT_shared)) {
6088 CmdArgs.push_back("-shared");
6089 } else {
6090 CmdArgs.push_back("--dynamic-linker");
6091 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6092 }
6093 }
6094
6095 if (Output.isFilename()) {
6096 CmdArgs.push_back("-o");
6097 CmdArgs.push_back(Output.getFilename());
6098 } else {
6099 assert(Output.isNothing() && "Invalid output.");
6100 }
6101
6102 if (!Args.hasArg(options::OPT_nostdlib) &&
6103 !Args.hasArg(options::OPT_nostartfiles)) {
6104 if (!Args.hasArg(options::OPT_shared)) {
6105 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6106 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006107 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006108 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6109 } else {
6110 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006111 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6112 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006113 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006114 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006115 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006116 }
6117
6118 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6119
6120 Args.AddAllArgs(CmdArgs, options::OPT_L);
6121 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6122 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006123 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006124
6125 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6126
6127 if (!Args.hasArg(options::OPT_nostdlib) &&
6128 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006129 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006130 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006131 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006132 if (!Args.hasArg(options::OPT_shared)) {
6133 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006134 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006135 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006136 }
David Chisnallf571cde2012-02-15 13:39:01 +00006137 }
6138
6139 if (!Args.hasArg(options::OPT_nostdlib) &&
6140 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006141 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006142 }
David Chisnall96de9932012-02-16 16:00:47 +00006143 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006144
Alexey Samsonov7811d192014-02-20 13:57:37 +00006145 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006146
6147 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006148 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006149 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006150}
6151
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006152void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006153 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006154 const InputInfoList &Inputs,
6155 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006156 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006157 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006158 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006159 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006160
Rafael Espindolacc126272014-02-28 01:55:21 +00006161 switch (getToolChain().getArch()) {
6162 case llvm::Triple::x86:
6163 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6164 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006165 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006166 break;
6167
6168 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006169 CmdArgs.push_back("-mppc");
6170 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006171 break;
6172
6173 case llvm::Triple::sparc:
6174 CmdArgs.push_back("-32");
6175 NeedsKPIC = true;
6176 break;
6177
6178 case llvm::Triple::sparcv9:
6179 CmdArgs.push_back("-64");
6180 CmdArgs.push_back("-Av9a");
6181 NeedsKPIC = true;
6182 break;
6183
6184 case llvm::Triple::mips64:
6185 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006186 StringRef CPUName;
6187 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006188 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006189
6190 CmdArgs.push_back("-mabi");
6191 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6192
6193 if (getToolChain().getArch() == llvm::Triple::mips64)
6194 CmdArgs.push_back("-EB");
6195 else
6196 CmdArgs.push_back("-EL");
6197
Rafael Espindolacc126272014-02-28 01:55:21 +00006198 NeedsKPIC = true;
6199 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006200 }
6201
Rafael Espindolacc126272014-02-28 01:55:21 +00006202 default:
6203 break;
6204 }
6205
6206 if (NeedsKPIC)
6207 addAssemblerKPIC(Args, CmdArgs);
6208
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006209 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6210 options::OPT_Xassembler);
6211
6212 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006213 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006214
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006215 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006216 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006217
6218 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006219 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006220 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006221}
6222
6223void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006224 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006225 const InputInfoList &Inputs,
6226 const ArgList &Args,
6227 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006228 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006229 ArgStringList CmdArgs;
6230
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006231 // Silence warning for "clang -g foo.o -o foo"
6232 Args.ClaimAllArgs(options::OPT_g_Group);
6233 // and "clang -emit-llvm foo.o -o foo"
6234 Args.ClaimAllArgs(options::OPT_emit_llvm);
6235 // and for "clang -w foo.o -o foo". Other warning options are already
6236 // handled somewhere else.
6237 Args.ClaimAllArgs(options::OPT_w);
6238
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006239 if (getToolChain().getArch() == llvm::Triple::mips64)
6240 CmdArgs.push_back("-EB");
6241 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6242 CmdArgs.push_back("-EL");
6243
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006244 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006245 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006246 CmdArgs.push_back("-e");
6247 CmdArgs.push_back("__start");
6248 }
6249
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006250 if (Args.hasArg(options::OPT_static)) {
6251 CmdArgs.push_back("-Bstatic");
6252 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006253 if (Args.hasArg(options::OPT_rdynamic))
6254 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006255 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006256 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006257 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006258 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006259 } else {
6260 CmdArgs.push_back("-dynamic-linker");
6261 CmdArgs.push_back("/usr/libexec/ld.so");
6262 }
6263 }
6264
Rafael Espindola044f7832013-06-05 04:28:55 +00006265 if (Args.hasArg(options::OPT_nopie))
6266 CmdArgs.push_back("-nopie");
6267
Daniel Dunbarb440f562010-08-02 02:38:21 +00006268 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006269 CmdArgs.push_back("-o");
6270 CmdArgs.push_back(Output.getFilename());
6271 } else {
6272 assert(Output.isNothing() && "Invalid output.");
6273 }
6274
6275 if (!Args.hasArg(options::OPT_nostdlib) &&
6276 !Args.hasArg(options::OPT_nostartfiles)) {
6277 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006278 if (Args.hasArg(options::OPT_pg))
6279 CmdArgs.push_back(Args.MakeArgString(
6280 getToolChain().GetFilePath("gcrt0.o")));
6281 else
6282 CmdArgs.push_back(Args.MakeArgString(
6283 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006284 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006285 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006286 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006287 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006288 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006289 }
6290 }
6291
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006292 std::string Triple = getToolChain().getTripleString();
6293 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006294 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006295 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006296 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006297
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006298 Args.AddAllArgs(CmdArgs, options::OPT_L);
6299 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6300 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006301 Args.AddAllArgs(CmdArgs, options::OPT_s);
6302 Args.AddAllArgs(CmdArgs, options::OPT_t);
6303 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6304 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006305
Daniel Dunbar54423b22010-09-17 00:24:54 +00006306 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006307
6308 if (!Args.hasArg(options::OPT_nostdlib) &&
6309 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006310 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006311 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006312 if (Args.hasArg(options::OPT_pg))
6313 CmdArgs.push_back("-lm_p");
6314 else
6315 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006316 }
6317
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006318 // FIXME: For some reason GCC passes -lgcc before adding
6319 // the default system libraries. Just mimic this for now.
6320 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006321
Eric Christopher17674ec2012-09-13 06:32:34 +00006322 if (Args.hasArg(options::OPT_pthread)) {
6323 if (!Args.hasArg(options::OPT_shared) &&
6324 Args.hasArg(options::OPT_pg))
6325 CmdArgs.push_back("-lpthread_p");
6326 else
6327 CmdArgs.push_back("-lpthread");
6328 }
6329
Chandler Carruth45661652011-12-17 22:32:42 +00006330 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006331 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006332 CmdArgs.push_back("-lc_p");
6333 else
6334 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006335 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006336
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006337 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006338 }
6339
6340 if (!Args.hasArg(options::OPT_nostdlib) &&
6341 !Args.hasArg(options::OPT_nostartfiles)) {
6342 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006343 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006344 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006345 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006346 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006347 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006348 }
6349
6350 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006351 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006352 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006353}
Ed Schoutene33194b2009-04-02 19:13:12 +00006354
Eli Friedman9fa28852012-08-08 23:57:20 +00006355void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6356 const InputInfo &Output,
6357 const InputInfoList &Inputs,
6358 const ArgList &Args,
6359 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006360 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00006361 ArgStringList CmdArgs;
6362
6363 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6364 options::OPT_Xassembler);
6365
6366 CmdArgs.push_back("-o");
6367 CmdArgs.push_back(Output.getFilename());
6368
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006369 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006370 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006371
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006372 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006373 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006374}
6375
6376void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6377 const InputInfo &Output,
6378 const InputInfoList &Inputs,
6379 const ArgList &Args,
6380 const char *LinkingOutput) const {
6381 const Driver &D = getToolChain().getDriver();
6382 ArgStringList CmdArgs;
6383
6384 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6385 (!Args.hasArg(options::OPT_shared))) {
6386 CmdArgs.push_back("-e");
6387 CmdArgs.push_back("__start");
6388 }
6389
6390 if (Args.hasArg(options::OPT_static)) {
6391 CmdArgs.push_back("-Bstatic");
6392 } else {
6393 if (Args.hasArg(options::OPT_rdynamic))
6394 CmdArgs.push_back("-export-dynamic");
6395 CmdArgs.push_back("--eh-frame-hdr");
6396 CmdArgs.push_back("-Bdynamic");
6397 if (Args.hasArg(options::OPT_shared)) {
6398 CmdArgs.push_back("-shared");
6399 } else {
6400 CmdArgs.push_back("-dynamic-linker");
6401 CmdArgs.push_back("/usr/libexec/ld.so");
6402 }
6403 }
6404
6405 if (Output.isFilename()) {
6406 CmdArgs.push_back("-o");
6407 CmdArgs.push_back(Output.getFilename());
6408 } else {
6409 assert(Output.isNothing() && "Invalid output.");
6410 }
6411
6412 if (!Args.hasArg(options::OPT_nostdlib) &&
6413 !Args.hasArg(options::OPT_nostartfiles)) {
6414 if (!Args.hasArg(options::OPT_shared)) {
6415 if (Args.hasArg(options::OPT_pg))
6416 CmdArgs.push_back(Args.MakeArgString(
6417 getToolChain().GetFilePath("gcrt0.o")));
6418 else
6419 CmdArgs.push_back(Args.MakeArgString(
6420 getToolChain().GetFilePath("crt0.o")));
6421 CmdArgs.push_back(Args.MakeArgString(
6422 getToolChain().GetFilePath("crtbegin.o")));
6423 } else {
6424 CmdArgs.push_back(Args.MakeArgString(
6425 getToolChain().GetFilePath("crtbeginS.o")));
6426 }
6427 }
6428
6429 Args.AddAllArgs(CmdArgs, options::OPT_L);
6430 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6431 Args.AddAllArgs(CmdArgs, options::OPT_e);
6432
6433 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6434
6435 if (!Args.hasArg(options::OPT_nostdlib) &&
6436 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006437 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006438 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6439 if (Args.hasArg(options::OPT_pg))
6440 CmdArgs.push_back("-lm_p");
6441 else
6442 CmdArgs.push_back("-lm");
6443 }
6444
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006445 if (Args.hasArg(options::OPT_pthread)) {
6446 if (!Args.hasArg(options::OPT_shared) &&
6447 Args.hasArg(options::OPT_pg))
6448 CmdArgs.push_back("-lpthread_p");
6449 else
6450 CmdArgs.push_back("-lpthread");
6451 }
6452
Eli Friedman9fa28852012-08-08 23:57:20 +00006453 if (!Args.hasArg(options::OPT_shared)) {
6454 if (Args.hasArg(options::OPT_pg))
6455 CmdArgs.push_back("-lc_p");
6456 else
6457 CmdArgs.push_back("-lc");
6458 }
6459
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006460 StringRef MyArch;
6461 switch (getToolChain().getTriple().getArch()) {
6462 case llvm::Triple::arm:
6463 MyArch = "arm";
6464 break;
6465 case llvm::Triple::x86:
6466 MyArch = "i386";
6467 break;
6468 case llvm::Triple::x86_64:
6469 MyArch = "amd64";
6470 break;
6471 default:
6472 llvm_unreachable("Unsupported architecture");
6473 }
6474 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006475 }
6476
6477 if (!Args.hasArg(options::OPT_nostdlib) &&
6478 !Args.hasArg(options::OPT_nostartfiles)) {
6479 if (!Args.hasArg(options::OPT_shared))
6480 CmdArgs.push_back(Args.MakeArgString(
6481 getToolChain().GetFilePath("crtend.o")));
6482 else
6483 CmdArgs.push_back(Args.MakeArgString(
6484 getToolChain().GetFilePath("crtendS.o")));
6485 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006486
6487 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006488 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006489 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006490}
6491
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006492void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006493 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006494 const InputInfoList &Inputs,
6495 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006496 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006497 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006498 ArgStringList CmdArgs;
6499
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006500 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6501 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006502 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006503 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006504 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006505 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006506 else if (getToolChain().getArch() == llvm::Triple::mips ||
6507 getToolChain().getArch() == llvm::Triple::mipsel ||
6508 getToolChain().getArch() == llvm::Triple::mips64 ||
6509 getToolChain().getArch() == llvm::Triple::mips64el) {
6510 StringRef CPUName;
6511 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006512 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006513
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006514 CmdArgs.push_back("-march");
6515 CmdArgs.push_back(CPUName.data());
6516
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006517 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006518 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006519
6520 if (getToolChain().getArch() == llvm::Triple::mips ||
6521 getToolChain().getArch() == llvm::Triple::mips64)
6522 CmdArgs.push_back("-EB");
6523 else
6524 CmdArgs.push_back("-EL");
6525
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006526 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006527 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006528 getToolChain().getArch() == llvm::Triple::armeb ||
6529 getToolChain().getArch() == llvm::Triple::thumb ||
6530 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006531 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006532 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006533 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6534
6535 if (FloatABI == "hard") {
6536 CmdArgs.push_back("-mfpu=vfp");
6537 } else {
6538 CmdArgs.push_back("-mfpu=softvfp");
6539 }
6540
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006541 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006542 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006543 case llvm::Triple::GNUEABI:
6544 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006545 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006546 break;
6547
6548 default:
6549 CmdArgs.push_back("-matpcs");
6550 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006551 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006552 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006553 if (getToolChain().getArch() == llvm::Triple::sparc)
6554 CmdArgs.push_back("-Av8plusa");
6555 else
6556 CmdArgs.push_back("-Av9a");
6557
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006558 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006559 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006560
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006561 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6562 options::OPT_Xassembler);
6563
6564 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006565 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006566
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006567 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006568 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006569
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006570 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006571 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006572}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006573
6574void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006575 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006576 const InputInfoList &Inputs,
6577 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006578 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006579 const toolchains::FreeBSD& ToolChain =
6580 static_cast<const toolchains::FreeBSD&>(getToolChain());
6581 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006582 const bool IsPIE =
6583 !Args.hasArg(options::OPT_shared) &&
6584 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006585 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006586
6587 // Silence warning for "clang -g foo.o -o foo"
6588 Args.ClaimAllArgs(options::OPT_g_Group);
6589 // and "clang -emit-llvm foo.o -o foo"
6590 Args.ClaimAllArgs(options::OPT_emit_llvm);
6591 // and for "clang -w foo.o -o foo". Other warning options are already
6592 // handled somewhere else.
6593 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006594
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006595 if (!D.SysRoot.empty())
6596 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6597
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006598 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006599 CmdArgs.push_back("-pie");
6600
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006601 if (Args.hasArg(options::OPT_static)) {
6602 CmdArgs.push_back("-Bstatic");
6603 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006604 if (Args.hasArg(options::OPT_rdynamic))
6605 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006606 CmdArgs.push_back("--eh-frame-hdr");
6607 if (Args.hasArg(options::OPT_shared)) {
6608 CmdArgs.push_back("-Bshareable");
6609 } else {
6610 CmdArgs.push_back("-dynamic-linker");
6611 CmdArgs.push_back("/libexec/ld-elf.so.1");
6612 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006613 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6614 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006615 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6616 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6617 CmdArgs.push_back("--hash-style=both");
6618 }
6619 }
6620 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006621 }
6622
6623 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6624 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006625 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006626 CmdArgs.push_back("-m");
6627 CmdArgs.push_back("elf_i386_fbsd");
6628 }
6629
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006630 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006631 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006632 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006633 }
6634
Daniel Dunbarb440f562010-08-02 02:38:21 +00006635 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006636 CmdArgs.push_back("-o");
6637 CmdArgs.push_back(Output.getFilename());
6638 } else {
6639 assert(Output.isNothing() && "Invalid output.");
6640 }
6641
6642 if (!Args.hasArg(options::OPT_nostdlib) &&
6643 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006644 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006645 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006646 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006647 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006648 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006649 crt1 = "Scrt1.o";
6650 else
6651 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006652 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006653 if (crt1)
6654 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6655
6656 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6657
Craig Topper92fc2df2014-05-17 16:56:41 +00006658 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006659 if (Args.hasArg(options::OPT_static))
6660 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006661 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006662 crtbegin = "crtbeginS.o";
6663 else
6664 crtbegin = "crtbegin.o";
6665
6666 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006667 }
6668
6669 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00006670 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006671 for (const auto &Path : Paths)
6672 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006673 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6674 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006675 Args.AddAllArgs(CmdArgs, options::OPT_s);
6676 Args.AddAllArgs(CmdArgs, options::OPT_t);
6677 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6678 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006679
Alp Tokerce365ca2013-12-02 12:43:03 +00006680 if (D.IsUsingLTO(Args))
6681 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006682
Alexey Samsonov52550342014-09-15 19:58:40 +00006683 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00006684 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006685
6686 if (!Args.hasArg(options::OPT_nostdlib) &&
6687 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006688 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006689 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006690 if (Args.hasArg(options::OPT_pg))
6691 CmdArgs.push_back("-lm_p");
6692 else
6693 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006694 }
Alexey Samsonov52550342014-09-15 19:58:40 +00006695 if (NeedsSanitizerDeps)
6696 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006697 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6698 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006699 if (Args.hasArg(options::OPT_pg))
6700 CmdArgs.push_back("-lgcc_p");
6701 else
6702 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006703 if (Args.hasArg(options::OPT_static)) {
6704 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006705 } else if (Args.hasArg(options::OPT_pg)) {
6706 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006707 } else {
6708 CmdArgs.push_back("--as-needed");
6709 CmdArgs.push_back("-lgcc_s");
6710 CmdArgs.push_back("--no-as-needed");
6711 }
6712
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006713 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006714 if (Args.hasArg(options::OPT_pg))
6715 CmdArgs.push_back("-lpthread_p");
6716 else
6717 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006718 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006719
Roman Divacky66f22762011-02-10 16:59:40 +00006720 if (Args.hasArg(options::OPT_pg)) {
6721 if (Args.hasArg(options::OPT_shared))
6722 CmdArgs.push_back("-lc");
6723 else
6724 CmdArgs.push_back("-lc_p");
6725 CmdArgs.push_back("-lgcc_p");
6726 } else {
6727 CmdArgs.push_back("-lc");
6728 CmdArgs.push_back("-lgcc");
6729 }
6730
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006731 if (Args.hasArg(options::OPT_static)) {
6732 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006733 } else if (Args.hasArg(options::OPT_pg)) {
6734 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006735 } else {
6736 CmdArgs.push_back("--as-needed");
6737 CmdArgs.push_back("-lgcc_s");
6738 CmdArgs.push_back("--no-as-needed");
6739 }
6740 }
6741
6742 if (!Args.hasArg(options::OPT_nostdlib) &&
6743 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006744 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006745 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006746 else
6747 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006748 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006749 }
6750
Alexey Samsonov7811d192014-02-20 13:57:37 +00006751 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006752
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006753 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006754 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006755 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006756}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006757
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006758void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6759 const InputInfo &Output,
6760 const InputInfoList &Inputs,
6761 const ArgList &Args,
6762 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006763 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006764 ArgStringList CmdArgs;
6765
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006766 // GNU as needs different flags for creating the correct output format
6767 // on architectures with different ABIs or optional feature sets.
6768 switch (getToolChain().getArch()) {
6769 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006770 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006771 break;
6772 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006773 case llvm::Triple::armeb:
6774 case llvm::Triple::thumb:
6775 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006776 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006777 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006778 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006779 }
6780
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006781 case llvm::Triple::mips:
6782 case llvm::Triple::mipsel:
6783 case llvm::Triple::mips64:
6784 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006785 StringRef CPUName;
6786 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006787 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006788
6789 CmdArgs.push_back("-march");
6790 CmdArgs.push_back(CPUName.data());
6791
6792 CmdArgs.push_back("-mabi");
6793 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6794
6795 if (getToolChain().getArch() == llvm::Triple::mips ||
6796 getToolChain().getArch() == llvm::Triple::mips64)
6797 CmdArgs.push_back("-EB");
6798 else
6799 CmdArgs.push_back("-EL");
6800
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006801 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006802 break;
6803 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006804
6805 case llvm::Triple::sparc:
6806 CmdArgs.push_back("-32");
6807 addAssemblerKPIC(Args, CmdArgs);
6808 break;
6809
6810 case llvm::Triple::sparcv9:
6811 CmdArgs.push_back("-64");
6812 CmdArgs.push_back("-Av9");
6813 addAssemblerKPIC(Args, CmdArgs);
6814 break;
6815
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006816 default:
6817 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006818 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006819
6820 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6821 options::OPT_Xassembler);
6822
6823 CmdArgs.push_back("-o");
6824 CmdArgs.push_back(Output.getFilename());
6825
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006826 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006827 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006828
David Chisnallddbd68f2011-09-27 22:03:18 +00006829 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00006830 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006831}
6832
6833void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6834 const InputInfo &Output,
6835 const InputInfoList &Inputs,
6836 const ArgList &Args,
6837 const char *LinkingOutput) const {
6838 const Driver &D = getToolChain().getDriver();
6839 ArgStringList CmdArgs;
6840
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006841 if (!D.SysRoot.empty())
6842 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6843
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006844 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006845 if (Args.hasArg(options::OPT_static)) {
6846 CmdArgs.push_back("-Bstatic");
6847 } else {
6848 if (Args.hasArg(options::OPT_rdynamic))
6849 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006850 if (Args.hasArg(options::OPT_shared)) {
6851 CmdArgs.push_back("-Bshareable");
6852 } else {
6853 CmdArgs.push_back("-dynamic-linker");
6854 CmdArgs.push_back("/libexec/ld.elf_so");
6855 }
6856 }
6857
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006858 // Many NetBSD architectures support more than one ABI.
6859 // Determine the correct emulation for ld.
6860 switch (getToolChain().getArch()) {
6861 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006862 CmdArgs.push_back("-m");
6863 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006864 break;
6865 case llvm::Triple::arm:
6866 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006867 CmdArgs.push_back("-m");
6868 switch (getToolChain().getTriple().getEnvironment()) {
6869 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006870 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006871 CmdArgs.push_back("armelf_nbsd_eabi");
6872 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006873 case llvm::Triple::EABIHF:
6874 case llvm::Triple::GNUEABIHF:
6875 CmdArgs.push_back("armelf_nbsd_eabihf");
6876 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006877 default:
6878 CmdArgs.push_back("armelf_nbsd");
6879 break;
6880 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006881 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00006882 case llvm::Triple::armeb:
6883 case llvm::Triple::thumbeb:
6884 CmdArgs.push_back("-m");
6885 switch (getToolChain().getTriple().getEnvironment()) {
6886 case llvm::Triple::EABI:
6887 case llvm::Triple::GNUEABI:
6888 CmdArgs.push_back("armelfb_nbsd_eabi");
6889 break;
6890 case llvm::Triple::EABIHF:
6891 case llvm::Triple::GNUEABIHF:
6892 CmdArgs.push_back("armelfb_nbsd_eabihf");
6893 break;
6894 default:
6895 CmdArgs.push_back("armelfb_nbsd");
6896 break;
6897 }
6898 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006899 case llvm::Triple::mips64:
6900 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006901 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006902 CmdArgs.push_back("-m");
6903 if (getToolChain().getArch() == llvm::Triple::mips64)
6904 CmdArgs.push_back("elf32btsmip");
6905 else
6906 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006907 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006908 CmdArgs.push_back("-m");
6909 if (getToolChain().getArch() == llvm::Triple::mips64)
6910 CmdArgs.push_back("elf64btsmip");
6911 else
6912 CmdArgs.push_back("elf64ltsmip");
6913 }
6914 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006915 case llvm::Triple::ppc:
6916 CmdArgs.push_back("-m");
6917 CmdArgs.push_back("elf32ppc_nbsd");
6918 break;
6919
6920 case llvm::Triple::ppc64:
6921 case llvm::Triple::ppc64le:
6922 CmdArgs.push_back("-m");
6923 CmdArgs.push_back("elf64ppc");
6924 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006925
6926 case llvm::Triple::sparc:
6927 CmdArgs.push_back("-m");
6928 CmdArgs.push_back("elf32_sparc");
6929 break;
6930
6931 case llvm::Triple::sparcv9:
6932 CmdArgs.push_back("-m");
6933 CmdArgs.push_back("elf64_sparc");
6934 break;
6935
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006936 default:
6937 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006938 }
6939
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006940 if (Output.isFilename()) {
6941 CmdArgs.push_back("-o");
6942 CmdArgs.push_back(Output.getFilename());
6943 } else {
6944 assert(Output.isNothing() && "Invalid output.");
6945 }
6946
6947 if (!Args.hasArg(options::OPT_nostdlib) &&
6948 !Args.hasArg(options::OPT_nostartfiles)) {
6949 if (!Args.hasArg(options::OPT_shared)) {
6950 CmdArgs.push_back(Args.MakeArgString(
6951 getToolChain().GetFilePath("crt0.o")));
6952 CmdArgs.push_back(Args.MakeArgString(
6953 getToolChain().GetFilePath("crti.o")));
6954 CmdArgs.push_back(Args.MakeArgString(
6955 getToolChain().GetFilePath("crtbegin.o")));
6956 } else {
6957 CmdArgs.push_back(Args.MakeArgString(
6958 getToolChain().GetFilePath("crti.o")));
6959 CmdArgs.push_back(Args.MakeArgString(
6960 getToolChain().GetFilePath("crtbeginS.o")));
6961 }
6962 }
6963
6964 Args.AddAllArgs(CmdArgs, options::OPT_L);
6965 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6966 Args.AddAllArgs(CmdArgs, options::OPT_e);
6967 Args.AddAllArgs(CmdArgs, options::OPT_s);
6968 Args.AddAllArgs(CmdArgs, options::OPT_t);
6969 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6970 Args.AddAllArgs(CmdArgs, options::OPT_r);
6971
6972 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6973
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006974 unsigned Major, Minor, Micro;
6975 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6976 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006977 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006978 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00006979 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006980 case llvm::Triple::arm:
6981 case llvm::Triple::armeb:
6982 case llvm::Triple::thumb:
6983 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006984 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006985 case llvm::Triple::ppc64:
6986 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006987 case llvm::Triple::x86:
6988 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006989 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006990 break;
6991 default:
6992 break;
6993 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006994 }
6995
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006996 if (!Args.hasArg(options::OPT_nostdlib) &&
6997 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006998 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006999 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7000 CmdArgs.push_back("-lm");
7001 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007002 if (Args.hasArg(options::OPT_pthread))
7003 CmdArgs.push_back("-lpthread");
7004 CmdArgs.push_back("-lc");
7005
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007006 if (useLibgcc) {
7007 if (Args.hasArg(options::OPT_static)) {
7008 // libgcc_eh depends on libc, so resolve as much as possible,
7009 // pull in any new requirements from libc and then get the rest
7010 // of libgcc.
7011 CmdArgs.push_back("-lgcc_eh");
7012 CmdArgs.push_back("-lc");
7013 CmdArgs.push_back("-lgcc");
7014 } else {
7015 CmdArgs.push_back("-lgcc");
7016 CmdArgs.push_back("--as-needed");
7017 CmdArgs.push_back("-lgcc_s");
7018 CmdArgs.push_back("--no-as-needed");
7019 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007020 }
7021 }
7022
7023 if (!Args.hasArg(options::OPT_nostdlib) &&
7024 !Args.hasArg(options::OPT_nostartfiles)) {
7025 if (!Args.hasArg(options::OPT_shared))
7026 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7027 "crtend.o")));
7028 else
7029 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7030 "crtendS.o")));
7031 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7032 "crtn.o")));
7033 }
7034
Alexey Samsonov7811d192014-02-20 13:57:37 +00007035 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007036
Logan Chieneb9162f2014-06-26 14:23:45 +00007037 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007038 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007039}
7040
Thomas Schwinge4e555262013-03-28 19:04:25 +00007041void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7042 const InputInfo &Output,
7043 const InputInfoList &Inputs,
7044 const ArgList &Args,
7045 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007046 claimNoWarnArgs(Args);
7047
Rafael Espindola92b00932010-08-10 00:25:48 +00007048 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007049 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007050
7051 // Add --32/--64 to make sure we get the format we want.
7052 // This is incomplete
7053 if (getToolChain().getArch() == llvm::Triple::x86) {
7054 CmdArgs.push_back("--32");
7055 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00007056 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7057 CmdArgs.push_back("--x32");
7058 else
7059 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00007060 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
7061 CmdArgs.push_back("-a32");
7062 CmdArgs.push_back("-mppc");
7063 CmdArgs.push_back("-many");
7064 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
7065 CmdArgs.push_back("-a64");
7066 CmdArgs.push_back("-mppc64");
7067 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00007068 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
7069 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007070 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007071 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007072 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007073 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
7074 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007075 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007076 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007077 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
7078 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007079 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007080 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007081 } else if (getToolChain().getArch() == llvm::Triple::arm ||
7082 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007083 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00007084 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
7085 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007086 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
7087 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00007088 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007089
Tim Northover9c7e0352013-12-12 11:55:52 +00007090 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7091 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007092 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007093
7094 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007095
7096 // FIXME: remove krait check when GNU tools support krait cpu
7097 // for now replace it with -march=armv7-a to avoid a lower
7098 // march from being picked in the absence of a cpu flag.
7099 Arg *A;
7100 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7101 StringRef(A->getValue()) == "krait")
7102 CmdArgs.push_back("-march=armv7-a");
7103 else
7104 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007105 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007106 } else if (getToolChain().getArch() == llvm::Triple::mips ||
7107 getToolChain().getArch() == llvm::Triple::mipsel ||
7108 getToolChain().getArch() == llvm::Triple::mips64 ||
7109 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007110 StringRef CPUName;
7111 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007112 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007113 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007114
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007115 CmdArgs.push_back("-march");
7116 CmdArgs.push_back(CPUName.data());
7117
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007118 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007119 CmdArgs.push_back(ABIName.data());
7120
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007121 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7122 // or -mshared (not implemented) is in effect.
7123 bool IsPicOrPie = false;
7124 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7125 options::OPT_fpic, options::OPT_fno_pic,
7126 options::OPT_fPIE, options::OPT_fno_PIE,
7127 options::OPT_fpie, options::OPT_fno_pie)) {
7128 if (A->getOption().matches(options::OPT_fPIC) ||
7129 A->getOption().matches(options::OPT_fpic) ||
7130 A->getOption().matches(options::OPT_fPIE) ||
7131 A->getOption().matches(options::OPT_fpie))
7132 IsPicOrPie = true;
7133 }
7134 if (!IsPicOrPie)
7135 CmdArgs.push_back("-mno-shared");
7136
Daniel Sanders379d44b2014-07-16 11:52:23 +00007137 // LLVM doesn't support -mplt yet and acts as if it is always given.
7138 // However, -mplt has no effect with the N64 ABI.
7139 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007140
7141 if (getToolChain().getArch() == llvm::Triple::mips ||
7142 getToolChain().getArch() == llvm::Triple::mips64)
7143 CmdArgs.push_back("-EB");
7144 else
7145 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007146
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007147 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7148 if (StringRef(A->getValue()) == "2008")
7149 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7150 }
7151
Daniel Sanders379d44b2014-07-16 11:52:23 +00007152 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7153 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7154 options::OPT_mfp64)) {
7155 A->claim();
7156 A->render(Args, CmdArgs);
7157 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7158 ABIName))
7159 CmdArgs.push_back("-mfpxx");
7160
7161 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7162 // -mno-mips16 is actually -no-mips16.
7163 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7164 options::OPT_mno_mips16)) {
7165 if (A->getOption().matches(options::OPT_mips16)) {
7166 A->claim();
7167 A->render(Args, CmdArgs);
7168 } else {
7169 A->claim();
7170 CmdArgs.push_back("-no-mips16");
7171 }
7172 }
7173
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007174 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7175 options::OPT_mno_micromips);
7176 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7177 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7178
Simon Atanasyanbd986632013-11-26 11:58:04 +00007179 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7180 // Do not use AddLastArg because not all versions of MIPS assembler
7181 // support -mmsa / -mno-msa options.
7182 if (A->getOption().matches(options::OPT_mmsa))
7183 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7184 }
7185
Daniel Sanders379d44b2014-07-16 11:52:23 +00007186 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7187 options::OPT_msoft_float);
7188
7189 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7190 options::OPT_mno_odd_spreg);
7191
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007192 NeedsKPIC = true;
7193 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7194 // Always pass an -march option, since our default of z10 is later
7195 // than the GNU assembler's default.
7196 StringRef CPUName = getSystemZTargetCPU(Args);
7197 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7198 }
7199
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007200 if (NeedsKPIC)
7201 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007202
7203 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7204 options::OPT_Xassembler);
7205
7206 CmdArgs.push_back("-o");
7207 CmdArgs.push_back(Output.getFilename());
7208
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007209 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007210 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007211
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007212 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007213 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007214
7215 // Handle the debug info splitting at object creation time if we're
7216 // creating an object.
7217 // TODO: Currently only works on linux with newer objcopy.
7218 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007219 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007220 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7221 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007222}
7223
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007224static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007225 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007226 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007227 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7228 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007229 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007230 CmdArgs.push_back("-lgcc");
7231
Logan Chien3d3373c2012-11-19 12:04:11 +00007232 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007233 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007234 CmdArgs.push_back("-lgcc");
7235 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007236 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007237 CmdArgs.push_back("--as-needed");
7238 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007239 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007240 CmdArgs.push_back("--no-as-needed");
7241 }
7242
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007243 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007244 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007245 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007246 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007247
7248 // According to Android ABI, we have to link with libdl if we are
7249 // linking with non-static libgcc.
7250 //
7251 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7252 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7253 if (isAndroid && !StaticLibgcc)
7254 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007255}
7256
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007257static std::string getLinuxDynamicLinker(const ArgList &Args,
7258 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007259 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7260 if (ToolChain.getTriple().isArch64Bit())
7261 return "/system/bin/linker64";
7262 else
7263 return "/system/bin/linker";
7264 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7265 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007266 return "/lib/ld-linux.so.2";
Tim Northover40956e62014-07-23 12:32:58 +00007267 else if (ToolChain.getArch() == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007268 return "/lib/ld-linux-aarch64.so.1";
Tim Northover40956e62014-07-23 12:32:58 +00007269 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007270 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007271 else if (ToolChain.getArch() == llvm::Triple::arm ||
7272 ToolChain.getArch() == llvm::Triple::thumb) {
7273 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7274 return "/lib/ld-linux-armhf.so.3";
7275 else
7276 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007277 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7278 ToolChain.getArch() == llvm::Triple::thumbeb) {
7279 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7280 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7281 else
7282 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007283 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007284 ToolChain.getArch() == llvm::Triple::mipsel ||
7285 ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007286 ToolChain.getArch() == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007287 StringRef CPUName;
7288 StringRef ABIName;
7289 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7290 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7291
7292 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7293 .Case("o32", "/lib")
7294 .Case("n32", "/lib32")
7295 .Case("n64", "/lib64")
7296 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007297 StringRef LibName;
7298 if (mips::isUCLibc(Args))
7299 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7300 else
7301 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007302
7303 return (LibDir + "/" + LibName).str();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007304 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7305 return "/lib/ld.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007306 else if (ToolChain.getArch() == llvm::Triple::ppc64) {
7307 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7308 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007309 return "/lib64/ld64.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007310 } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
7311 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7312 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007313 return "/lib64/ld64.so.2";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007314 } else if (ToolChain.getArch() == llvm::Triple::systemz)
7315 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007316 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7317 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007318 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7319 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7320 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007321 else
7322 return "/lib64/ld-linux-x86-64.so.2";
7323}
7324
Renato Golinc4b49242014-02-13 10:01:16 +00007325static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007326 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007327 // Make use of compiler-rt if --rtlib option is used
7328 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7329
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007330 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007331 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007332 switch (TC.getTriple().getOS()) {
7333 default: llvm_unreachable("unsupported OS");
7334 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007335 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007336 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007337 break;
7338 }
Renato Golinc4b49242014-02-13 10:01:16 +00007339 break;
7340 case ToolChain::RLT_Libgcc:
7341 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7342 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007343 }
7344}
7345
Rafael Espindola1e085772014-08-15 17:14:35 +00007346static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7347 switch (T.getArch()) {
7348 case llvm::Triple::x86:
7349 return "elf_i386";
7350 case llvm::Triple::aarch64:
7351 return "aarch64linux";
7352 case llvm::Triple::aarch64_be:
7353 return "aarch64_be_linux";
7354 case llvm::Triple::arm:
7355 case llvm::Triple::thumb:
7356 return "armelf_linux_eabi";
7357 case llvm::Triple::armeb:
7358 case llvm::Triple::thumbeb:
7359 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7360 case llvm::Triple::ppc:
7361 return "elf32ppclinux";
7362 case llvm::Triple::ppc64:
7363 return "elf64ppc";
7364 case llvm::Triple::ppc64le:
7365 return "elf64lppc";
7366 case llvm::Triple::sparc:
7367 return "elf32_sparc";
7368 case llvm::Triple::sparcv9:
7369 return "elf64_sparc";
7370 case llvm::Triple::mips:
7371 return "elf32btsmip";
7372 case llvm::Triple::mipsel:
7373 return "elf32ltsmip";
7374 case llvm::Triple::mips64:
7375 if (mips::hasMipsAbiArg(Args, "n32"))
7376 return "elf32btsmipn32";
7377 return "elf64btsmip";
7378 case llvm::Triple::mips64el:
7379 if (mips::hasMipsAbiArg(Args, "n32"))
7380 return "elf32ltsmipn32";
7381 return "elf64ltsmip";
7382 case llvm::Triple::systemz:
7383 return "elf64_s390";
7384 case llvm::Triple::x86_64:
7385 if (T.getEnvironment() == llvm::Triple::GNUX32)
7386 return "elf32_x86_64";
7387 return "elf_x86_64";
7388 default:
7389 llvm_unreachable("Unexpected arch");
7390 }
7391}
7392
Thomas Schwinge4e555262013-03-28 19:04:25 +00007393void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7394 const InputInfo &Output,
7395 const InputInfoList &Inputs,
7396 const ArgList &Args,
7397 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007398 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007399 static_cast<const toolchains::Linux&>(getToolChain());
7400 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007401 const bool isAndroid =
7402 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007403 const bool IsPIE =
7404 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007405 !Args.hasArg(options::OPT_static) &&
7406 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7407 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007408 // Cannot use isPIEDefault here since otherwise
7409 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007410 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007411
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007412 ArgStringList CmdArgs;
7413
Rafael Espindolad1002f62010-11-15 18:28:16 +00007414 // Silence warning for "clang -g foo.o -o foo"
7415 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007416 // and "clang -emit-llvm foo.o -o foo"
7417 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007418 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007419 // handled somewhere else.
7420 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007421
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007422 if (!D.SysRoot.empty())
7423 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007424
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007425 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007426 CmdArgs.push_back("-pie");
7427
Rafael Espindola1c76c592010-11-07 22:57:16 +00007428 if (Args.hasArg(options::OPT_rdynamic))
7429 CmdArgs.push_back("-export-dynamic");
7430
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007431 if (Args.hasArg(options::OPT_s))
7432 CmdArgs.push_back("-s");
7433
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007434 for (const auto &Opt : ToolChain.ExtraOpts)
7435 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007436
7437 if (!Args.hasArg(options::OPT_static)) {
7438 CmdArgs.push_back("--eh-frame-hdr");
7439 }
7440
7441 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007442 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007443
7444 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007445 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007446 ToolChain.getArch() == llvm::Triple::armeb ||
7447 ToolChain.getArch() == llvm::Triple::thumb ||
7448 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007449 CmdArgs.push_back("-Bstatic");
7450 else
7451 CmdArgs.push_back("-static");
7452 } else if (Args.hasArg(options::OPT_shared)) {
7453 CmdArgs.push_back("-shared");
7454 }
7455
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007456 if (ToolChain.getArch() == llvm::Triple::arm ||
7457 ToolChain.getArch() == llvm::Triple::armeb ||
7458 ToolChain.getArch() == llvm::Triple::thumb ||
7459 ToolChain.getArch() == llvm::Triple::thumbeb ||
7460 (!Args.hasArg(options::OPT_static) &&
7461 !Args.hasArg(options::OPT_shared))) {
7462 CmdArgs.push_back("-dynamic-linker");
7463 CmdArgs.push_back(Args.MakeArgString(
7464 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7465 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007466
7467 CmdArgs.push_back("-o");
7468 CmdArgs.push_back(Output.getFilename());
7469
Rafael Espindola81937ec2010-12-01 01:52:43 +00007470 if (!Args.hasArg(options::OPT_nostdlib) &&
7471 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007472 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007473 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007474 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007475 if (Args.hasArg(options::OPT_pg))
7476 crt1 = "gcrt1.o";
7477 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007478 crt1 = "Scrt1.o";
7479 else
7480 crt1 = "crt1.o";
7481 }
7482 if (crt1)
7483 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007484
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007485 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7486 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007487
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007488 const char *crtbegin;
7489 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007490 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007491 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007492 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007493 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007494 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007495 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007496 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007497 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007498
7499 // Add crtfastmath.o if available and fast math is enabled.
7500 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007501 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007502
7503 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007504 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007505
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007506 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007507
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007508 for (const auto &Path : Paths)
7509 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007510
Alp Tokerce365ca2013-12-02 12:43:03 +00007511 if (D.IsUsingLTO(Args))
7512 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007513
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007514 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7515 CmdArgs.push_back("--no-demangle");
7516
Alexey Samsonov52550342014-09-15 19:58:40 +00007517 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007518 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007519 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007520 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007521
Hans Wennborg70850d82013-07-18 20:29:38 +00007522 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007523 !Args.hasArg(options::OPT_nostdlib) &&
7524 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007525 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7526 !Args.hasArg(options::OPT_static);
7527 if (OnlyLibstdcxxStatic)
7528 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007529 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007530 if (OnlyLibstdcxxStatic)
7531 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007532 CmdArgs.push_back("-lm");
7533 }
7534
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007535 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007536 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7537 if (Args.hasArg(options::OPT_static))
7538 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007539
Alexey Samsonov52550342014-09-15 19:58:40 +00007540 if (NeedsSanitizerDeps)
7541 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7542
Alexey Bataev186b28a2014-03-06 05:43:53 +00007543 LibOpenMP UsedOpenMPLib = LibUnknown;
7544 if (Args.hasArg(options::OPT_fopenmp)) {
7545 UsedOpenMPLib = LibGOMP;
7546 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7547 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7548 .Case("libgomp", LibGOMP)
7549 .Case("libiomp5", LibIOMP5)
7550 .Default(LibUnknown);
7551 if (UsedOpenMPLib == LibUnknown)
7552 D.Diag(diag::err_drv_unsupported_option_argument)
7553 << A->getOption().getName() << A->getValue();
7554 }
7555 switch (UsedOpenMPLib) {
7556 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007557 CmdArgs.push_back("-lgomp");
7558
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007559 // FIXME: Exclude this for platforms with libgomp that don't require
7560 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007561 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007562 break;
7563 case LibIOMP5:
7564 CmdArgs.push_back("-liomp5");
7565 break;
7566 case LibUnknown:
7567 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007568 }
Renato Golinc4b49242014-02-13 10:01:16 +00007569 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007570
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007571 if ((Args.hasArg(options::OPT_pthread) ||
7572 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7573 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007574 CmdArgs.push_back("-lpthread");
7575
7576 CmdArgs.push_back("-lc");
7577
7578 if (Args.hasArg(options::OPT_static))
7579 CmdArgs.push_back("--end-group");
7580 else
Renato Golinc4b49242014-02-13 10:01:16 +00007581 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007582 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007583
Rafael Espindola81937ec2010-12-01 01:52:43 +00007584 if (!Args.hasArg(options::OPT_nostartfiles)) {
7585 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007586 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007587 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007588 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007589 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007590 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007591 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007592
Rafael Espindola81937ec2010-12-01 01:52:43 +00007593 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007594 if (!isAndroid)
7595 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007596 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007597 }
7598
David Blaikiec11bf802014-09-04 16:04:28 +00007599 C.addCommand(
7600 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007601}
7602
Chris Lattner3e2ee142010-07-07 16:01:42 +00007603void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007604 const InputInfo &Output,
7605 const InputInfoList &Inputs,
7606 const ArgList &Args,
7607 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007608 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007609 ArgStringList CmdArgs;
7610
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007611 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007612
7613 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007614 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007615
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007616 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007617 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007618
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007619 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007620 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007621}
7622
7623void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007624 const InputInfo &Output,
7625 const InputInfoList &Inputs,
7626 const ArgList &Args,
7627 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007628 const Driver &D = getToolChain().getDriver();
7629 ArgStringList CmdArgs;
7630
Daniel Dunbarb440f562010-08-02 02:38:21 +00007631 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007632 CmdArgs.push_back("-o");
7633 CmdArgs.push_back(Output.getFilename());
7634 } else {
7635 assert(Output.isNothing() && "Invalid output.");
7636 }
7637
7638 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007639 !Args.hasArg(options::OPT_nostartfiles)) {
7640 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7641 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7642 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7643 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7644 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007645
7646 Args.AddAllArgs(CmdArgs, options::OPT_L);
7647 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7648 Args.AddAllArgs(CmdArgs, options::OPT_e);
7649
Daniel Dunbar54423b22010-09-17 00:24:54 +00007650 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007651
Alexey Samsonov7811d192014-02-20 13:57:37 +00007652 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007653
Chris Lattner3e2ee142010-07-07 16:01:42 +00007654 if (!Args.hasArg(options::OPT_nostdlib) &&
7655 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007656 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007657 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007658 CmdArgs.push_back("-lm");
7659 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007660 }
7661
7662 if (!Args.hasArg(options::OPT_nostdlib) &&
7663 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007664 if (Args.hasArg(options::OPT_pthread))
7665 CmdArgs.push_back("-lpthread");
7666 CmdArgs.push_back("-lc");
7667 CmdArgs.push_back("-lCompilerRT-Generic");
7668 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7669 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007670 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007671 }
7672
Logan Chieneb9162f2014-06-26 14:23:45 +00007673 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007674 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007675}
7676
Daniel Dunbarcc912342009-05-02 18:28:39 +00007677/// DragonFly Tools
7678
7679// For now, DragonFly Assemble does just about the same as for
7680// FreeBSD, but this may change soon.
7681void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007682 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007683 const InputInfoList &Inputs,
7684 const ArgList &Args,
7685 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007686 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007687 ArgStringList CmdArgs;
7688
7689 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7690 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007691 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007692 CmdArgs.push_back("--32");
7693
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007694 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007695
7696 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007697 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007698
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007699 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007700 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007701
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007702 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007703 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007704}
7705
7706void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007707 const InputInfo &Output,
7708 const InputInfoList &Inputs,
7709 const ArgList &Args,
7710 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007711 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007712 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00007713 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00007714
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007715 if (!D.SysRoot.empty())
7716 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7717
John McCall65b8da02013-04-11 22:55:55 +00007718 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007719 if (Args.hasArg(options::OPT_static)) {
7720 CmdArgs.push_back("-Bstatic");
7721 } else {
John McCall65b8da02013-04-11 22:55:55 +00007722 if (Args.hasArg(options::OPT_rdynamic))
7723 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007724 if (Args.hasArg(options::OPT_shared))
7725 CmdArgs.push_back("-Bshareable");
7726 else {
7727 CmdArgs.push_back("-dynamic-linker");
7728 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7729 }
John McCall65b8da02013-04-11 22:55:55 +00007730 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007731 }
7732
7733 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7734 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007735 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007736 CmdArgs.push_back("-m");
7737 CmdArgs.push_back("elf_i386");
7738 }
7739
Daniel Dunbarb440f562010-08-02 02:38:21 +00007740 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007741 CmdArgs.push_back("-o");
7742 CmdArgs.push_back(Output.getFilename());
7743 } else {
7744 assert(Output.isNothing() && "Invalid output.");
7745 }
7746
7747 if (!Args.hasArg(options::OPT_nostdlib) &&
7748 !Args.hasArg(options::OPT_nostartfiles)) {
7749 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007750 if (Args.hasArg(options::OPT_pg))
7751 CmdArgs.push_back(Args.MakeArgString(
7752 getToolChain().GetFilePath("gcrt1.o")));
7753 else {
7754 if (Args.hasArg(options::OPT_pie))
7755 CmdArgs.push_back(Args.MakeArgString(
7756 getToolChain().GetFilePath("Scrt1.o")));
7757 else
7758 CmdArgs.push_back(Args.MakeArgString(
7759 getToolChain().GetFilePath("crt1.o")));
7760 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007761 }
John McCall65b8da02013-04-11 22:55:55 +00007762 CmdArgs.push_back(Args.MakeArgString(
7763 getToolChain().GetFilePath("crti.o")));
7764 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7765 CmdArgs.push_back(Args.MakeArgString(
7766 getToolChain().GetFilePath("crtbeginS.o")));
7767 else
7768 CmdArgs.push_back(Args.MakeArgString(
7769 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007770 }
7771
7772 Args.AddAllArgs(CmdArgs, options::OPT_L);
7773 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7774 Args.AddAllArgs(CmdArgs, options::OPT_e);
7775
Daniel Dunbar54423b22010-09-17 00:24:54 +00007776 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007777
7778 if (!Args.hasArg(options::OPT_nostdlib) &&
7779 !Args.hasArg(options::OPT_nodefaultlibs)) {
7780 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7781 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007782 if (UseGCC47)
7783 CmdArgs.push_back("-L/usr/lib/gcc47");
7784 else
7785 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007786
7787 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007788 if (UseGCC47) {
7789 CmdArgs.push_back("-rpath");
7790 CmdArgs.push_back("/usr/lib/gcc47");
7791 } else {
7792 CmdArgs.push_back("-rpath");
7793 CmdArgs.push_back("/usr/lib/gcc44");
7794 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007795 }
7796
Hans Wennborg70850d82013-07-18 20:29:38 +00007797 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007798 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007799 CmdArgs.push_back("-lm");
7800 }
7801
Daniel Dunbarcc912342009-05-02 18:28:39 +00007802 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007803 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007804
7805 if (!Args.hasArg(options::OPT_nolibc)) {
7806 CmdArgs.push_back("-lc");
7807 }
7808
John McCall65b8da02013-04-11 22:55:55 +00007809 if (UseGCC47) {
7810 if (Args.hasArg(options::OPT_static) ||
7811 Args.hasArg(options::OPT_static_libgcc)) {
7812 CmdArgs.push_back("-lgcc");
7813 CmdArgs.push_back("-lgcc_eh");
7814 } else {
7815 if (Args.hasArg(options::OPT_shared_libgcc)) {
7816 CmdArgs.push_back("-lgcc_pic");
7817 if (!Args.hasArg(options::OPT_shared))
7818 CmdArgs.push_back("-lgcc");
7819 } else {
7820 CmdArgs.push_back("-lgcc");
7821 CmdArgs.push_back("--as-needed");
7822 CmdArgs.push_back("-lgcc_pic");
7823 CmdArgs.push_back("--no-as-needed");
7824 }
7825 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007826 } else {
John McCall65b8da02013-04-11 22:55:55 +00007827 if (Args.hasArg(options::OPT_shared)) {
7828 CmdArgs.push_back("-lgcc_pic");
7829 } else {
7830 CmdArgs.push_back("-lgcc");
7831 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007832 }
7833 }
7834
7835 if (!Args.hasArg(options::OPT_nostdlib) &&
7836 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007837 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007838 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007839 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007840 else
7841 CmdArgs.push_back(Args.MakeArgString(
7842 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007843 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007844 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007845 }
7846
Alexey Samsonov7811d192014-02-20 13:57:37 +00007847 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007848
Logan Chieneb9162f2014-06-26 14:23:45 +00007849 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007850 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007851}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007852
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00007853// Try to find Exe from a Visual Studio distribution. This first tries to find
7854// an installed copy of Visual Studio and, failing that, looks in the PATH,
7855// making sure that whatever executable that's found is not a same-named exe
7856// from clang itself to prevent clang from falling back to itself.
7857static std::string FindVisualStudioExecutable(const ToolChain &TC,
7858 const char *Exe,
7859 const char *ClangProgramPath) {
7860 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
7861 std::string visualStudioBinDir;
7862 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
7863 visualStudioBinDir)) {
7864 SmallString<128> FilePath(visualStudioBinDir);
7865 llvm::sys::path::append(FilePath, Exe);
7866 if (llvm::sys::fs::can_execute(FilePath.c_str()))
7867 return FilePath.str();
7868 }
7869
7870 return Exe;
7871}
7872
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007873void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7874 const InputInfo &Output,
7875 const InputInfoList &Inputs,
7876 const ArgList &Args,
7877 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007878 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007879 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007880
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007881 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
7882 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007883 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7884 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007885
7886 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007887 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007888 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007889
Zachary Turner10d75b22014-10-22 20:40:43 +00007890 if (!llvm::sys::Process::GetEnv("LIB")) {
7891 // If the VC environment hasn't been configured (perhaps because the user
7892 // did not run vcvarsall), try to build a consistent link environment. If
7893 // the environment variable is set however, assume the user knows what he's
7894 // doing.
7895 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007896 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00007897 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
7898 SmallString<128> LibDir(VisualStudioDir);
7899 llvm::sys::path::append(LibDir, "VC", "lib");
7900 switch (MSVC.getArch()) {
7901 case llvm::Triple::x86:
7902 // x86 just puts the libraries directly in lib
7903 break;
7904 case llvm::Triple::x86_64:
7905 llvm::sys::path::append(LibDir, "amd64");
7906 break;
7907 case llvm::Triple::arm:
7908 llvm::sys::path::append(LibDir, "arm");
7909 break;
7910 default:
7911 break;
7912 }
7913 CmdArgs.push_back(
7914 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
7915 }
7916
7917 std::string WindowsSdkLibPath;
7918 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
7919 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
7920 WindowsSdkLibPath.c_str()));
7921 }
7922
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007923 CmdArgs.push_back("-nologo");
7924
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007925 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007926 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007927
Hans Wennborgf1a74252013-09-10 20:18:04 +00007928 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007929 if (DLL) {
7930 CmdArgs.push_back(Args.MakeArgString("-dll"));
7931
7932 SmallString<128> ImplibName(Output.getFilename());
7933 llvm::sys::path::replace_extension(ImplibName, "lib");
7934 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7935 ImplibName.str()));
7936 }
7937
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007938 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007939 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007940 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007941 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007942 static const char *CompilerRTComponents[] = {
7943 "asan_dynamic",
7944 "asan_dynamic_runtime_thunk",
7945 };
7946 for (const auto &Component : CompilerRTComponents)
7947 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00007948 // Make sure the dynamic runtime thunk is not optimized out at link time
7949 // to ensure proper SEH handling.
7950 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007951 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007952 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00007953 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007954 static const char *CompilerRTComponents[] = {
7955 "asan",
7956 "asan_cxx",
7957 };
7958 for (const auto &Component : CompilerRTComponents)
7959 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00007960 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007961 }
7962
Hans Wennborg2e274592013-08-13 23:38:57 +00007963 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007964
Reid Kleckner337188f2014-09-16 19:22:00 +00007965 // Add filenames, libraries, and other linker inputs.
7966 for (const auto &Input : Inputs) {
7967 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007968 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00007969 continue;
7970 }
7971
7972 const Arg &A = Input.getInputArg();
7973
7974 // Render -l options differently for the MSVC linker.
7975 if (A.getOption().matches(options::OPT_l)) {
7976 StringRef Lib = A.getValue();
7977 const char *LinkLibArg;
7978 if (Lib.endswith(".lib"))
7979 LinkLibArg = Args.MakeArgString(Lib);
7980 else
7981 LinkLibArg = Args.MakeArgString(Lib + ".lib");
7982 CmdArgs.push_back(LinkLibArg);
7983 continue;
7984 }
7985
7986 // Otherwise, this is some other kind of linker input option like -Wl, -z,
7987 // or -L. Render it, even if MSVC doesn't understand it.
7988 A.renderAsInput(Args, CmdArgs);
7989 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007990
Zachary Turner719f58c2014-12-01 23:06:47 +00007991 // We need to special case some linker paths. In the case of lld, we need to
7992 // translate 'lld' into 'lld-link', and in the case of the regular msvc
7993 // linker, we need to use a special search algorithm.
7994 llvm::SmallString<128> linkPath;
7995 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
7996 if (Linker.equals_lower("lld"))
7997 Linker = "lld-link";
7998
7999 if (Linker.equals_lower("link")) {
8000 // If we're using the MSVC linker, it's not sufficient to just use link
8001 // from the program PATH, because other environments like GnuWin32 install
8002 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008003 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008004 C.getDriver().getClangProgramPath());
8005 } else {
8006 linkPath = Linker;
8007 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008008 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008009 }
8010
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008011 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00008012 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008013}
Hans Wennborg87cfa712013-09-19 20:32:16 +00008014
8015void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
8016 const InputInfo &Output,
8017 const InputInfoList &Inputs,
8018 const ArgList &Args,
8019 const char *LinkingOutput) const {
8020 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8021}
8022
David Blaikiec11bf802014-09-04 16:04:28 +00008023std::unique_ptr<Command> visualstudio::Compile::GetCommand(
8024 Compilation &C, const JobAction &JA, const InputInfo &Output,
8025 const InputInfoList &Inputs, const ArgList &Args,
8026 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00008027 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00008028 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008029 CmdArgs.push_back("/c"); // Compile only.
8030 CmdArgs.push_back("/W0"); // No warnings.
8031
8032 // The goal is to be able to invoke this tool correctly based on
8033 // any flag accepted by clang-cl.
8034
8035 // These are spelled the same way in clang and cl.exe,.
8036 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8037 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008038
8039 // Optimization level.
8040 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8041 if (A->getOption().getID() == options::OPT_O0) {
8042 CmdArgs.push_back("/Od");
8043 } else {
8044 StringRef OptLevel = A->getValue();
8045 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8046 A->render(Args, CmdArgs);
8047 else if (OptLevel == "3")
8048 CmdArgs.push_back("/Ox");
8049 }
8050 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008051
8052 // Flags for which clang-cl have an alias.
8053 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8054
David Majnemerf6072342014-07-01 22:24:56 +00008055 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8056 /*default=*/false))
8057 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008058 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8059 options::OPT_fno_function_sections))
8060 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8061 ? "/Gy"
8062 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008063 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8064 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008065 CmdArgs.push_back(
8066 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008067 if (Args.hasArg(options::OPT_fsyntax_only))
8068 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008069 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8070 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008071
Hans Wennborg260ff402013-09-27 17:54:18 +00008072 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008073 for (const auto &Include : Includes)
8074 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008075
Hans Wennborg87cfa712013-09-19 20:32:16 +00008076 // Flags that can simply be passed through.
8077 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8078 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008079 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008080
8081 // The order of these flags is relevant, so pick the last one.
8082 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8083 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8084 A->render(Args, CmdArgs);
8085
8086
8087 // Input filename.
8088 assert(Inputs.size() == 1);
8089 const InputInfo &II = Inputs[0];
8090 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8091 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8092 if (II.isFilename())
8093 CmdArgs.push_back(II.getFilename());
8094 else
8095 II.getInputArg().renderAsInput(Args, CmdArgs);
8096
8097 // Output filename.
8098 assert(Output.getType() == types::TY_Object);
8099 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8100 Output.getFilename());
8101 CmdArgs.push_back(Fo);
8102
Hans Wennborg188382e2013-09-20 18:16:35 +00008103 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008104 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8105 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008106 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8107 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008108}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008109
8110
8111/// XCore Tools
8112// We pass assemble and link construction to the xcc tool.
8113
8114void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8115 const InputInfo &Output,
8116 const InputInfoList &Inputs,
8117 const ArgList &Args,
8118 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008119 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008120 ArgStringList CmdArgs;
8121
8122 CmdArgs.push_back("-o");
8123 CmdArgs.push_back(Output.getFilename());
8124
8125 CmdArgs.push_back("-c");
8126
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008127 if (Args.hasArg(options::OPT_v))
8128 CmdArgs.push_back("-v");
8129
Robert Lytton894d25c2014-05-02 09:33:25 +00008130 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8131 if (!A->getOption().matches(options::OPT_g0))
8132 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008133
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008134 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8135 false))
8136 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008137
8138 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8139 options::OPT_Xassembler);
8140
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008141 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008142 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008143
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008144 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008145 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008146}
8147
8148void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8149 const InputInfo &Output,
8150 const InputInfoList &Inputs,
8151 const ArgList &Args,
8152 const char *LinkingOutput) const {
8153 ArgStringList CmdArgs;
8154
8155 if (Output.isFilename()) {
8156 CmdArgs.push_back("-o");
8157 CmdArgs.push_back(Output.getFilename());
8158 } else {
8159 assert(Output.isNothing() && "Invalid output.");
8160 }
8161
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008162 if (Args.hasArg(options::OPT_v))
8163 CmdArgs.push_back("-v");
8164
David Majnemer8de68642014-12-05 08:11:58 +00008165 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008166 CmdArgs.push_back("-fexceptions");
8167
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008168 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8169
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008170 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008171 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008172}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008173
8174void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8175 const InputInfo &Output,
8176 const InputInfoList &Inputs,
8177 const ArgList &Args,
8178 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008179 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008180 const auto &TC =
8181 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8182 ArgStringList CmdArgs;
8183 const char *Exec;
8184
8185 switch (TC.getArch()) {
8186 default: llvm_unreachable("unsupported architecture");
8187 case llvm::Triple::arm:
8188 case llvm::Triple::thumb:
8189 break;
8190 case llvm::Triple::x86:
8191 CmdArgs.push_back("--32");
8192 break;
8193 case llvm::Triple::x86_64:
8194 CmdArgs.push_back("--64");
8195 break;
8196 }
8197
8198 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8199
8200 CmdArgs.push_back("-o");
8201 CmdArgs.push_back(Output.getFilename());
8202
8203 for (const auto &Input : Inputs)
8204 CmdArgs.push_back(Input.getFilename());
8205
8206 const std::string Assembler = TC.GetProgramPath("as");
8207 Exec = Args.MakeArgString(Assembler);
8208
8209 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8210}
8211
8212void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8213 const InputInfo &Output,
8214 const InputInfoList &Inputs,
8215 const ArgList &Args,
8216 const char *LinkingOutput) const {
8217 const auto &TC =
8218 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8219 const llvm::Triple &T = TC.getTriple();
8220 const Driver &D = TC.getDriver();
8221 SmallString<128> EntryPoint;
8222 ArgStringList CmdArgs;
8223 const char *Exec;
8224
8225 // Silence warning for "clang -g foo.o -o foo"
8226 Args.ClaimAllArgs(options::OPT_g_Group);
8227 // and "clang -emit-llvm foo.o -o foo"
8228 Args.ClaimAllArgs(options::OPT_emit_llvm);
8229 // and for "clang -w foo.o -o foo"
8230 Args.ClaimAllArgs(options::OPT_w);
8231 // Other warning options are already handled somewhere else.
8232
8233 if (!D.SysRoot.empty())
8234 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8235
8236 if (Args.hasArg(options::OPT_pie))
8237 CmdArgs.push_back("-pie");
8238 if (Args.hasArg(options::OPT_rdynamic))
8239 CmdArgs.push_back("-export-dynamic");
8240 if (Args.hasArg(options::OPT_s))
8241 CmdArgs.push_back("--strip-all");
8242
8243 CmdArgs.push_back("-m");
8244 switch (TC.getArch()) {
8245 default: llvm_unreachable("unsupported architecture");
8246 case llvm::Triple::arm:
8247 case llvm::Triple::thumb:
8248 // FIXME: this is incorrect for WinCE
8249 CmdArgs.push_back("thumb2pe");
8250 break;
8251 case llvm::Triple::x86:
8252 CmdArgs.push_back("i386pe");
8253 EntryPoint.append("_");
8254 break;
8255 case llvm::Triple::x86_64:
8256 CmdArgs.push_back("i386pep");
8257 break;
8258 }
8259
8260 if (Args.hasArg(options::OPT_shared)) {
8261 switch (T.getArch()) {
8262 default: llvm_unreachable("unsupported architecture");
8263 case llvm::Triple::arm:
8264 case llvm::Triple::thumb:
8265 case llvm::Triple::x86_64:
8266 EntryPoint.append("_DllMainCRTStartup");
8267 break;
8268 case llvm::Triple::x86:
8269 EntryPoint.append("_DllMainCRTStartup@12");
8270 break;
8271 }
8272
8273 CmdArgs.push_back("-shared");
8274 CmdArgs.push_back("-Bdynamic");
8275
8276 CmdArgs.push_back("--enable-auto-image-base");
8277
8278 CmdArgs.push_back("--entry");
8279 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8280 } else {
8281 EntryPoint.append("mainCRTStartup");
8282
8283 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
8284 : "-Bdynamic");
8285
8286 if (!Args.hasArg(options::OPT_nostdlib) &&
8287 !Args.hasArg(options::OPT_nostartfiles)) {
8288 CmdArgs.push_back("--entry");
8289 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8290 }
8291
8292 // FIXME: handle subsystem
8293 }
8294
8295 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00008296 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008297
8298 CmdArgs.push_back("-o");
8299 CmdArgs.push_back(Output.getFilename());
8300
8301 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
8302 SmallString<261> ImpLib(Output.getFilename());
8303 llvm::sys::path::replace_extension(ImpLib, ".lib");
8304
8305 CmdArgs.push_back("--out-implib");
8306 CmdArgs.push_back(Args.MakeArgString(ImpLib));
8307 }
8308
8309 if (!Args.hasArg(options::OPT_nostdlib) &&
8310 !Args.hasArg(options::OPT_nostartfiles)) {
8311 const std::string CRTPath(D.SysRoot + "/usr/lib/");
8312 const char *CRTBegin;
8313
8314 CRTBegin =
8315 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
8316 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
8317 }
8318
8319 Args.AddAllArgs(CmdArgs, options::OPT_L);
8320
8321 const auto &Paths = TC.getFilePaths();
8322 for (const auto &Path : Paths)
8323 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8324
8325 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
8326
8327 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8328 !Args.hasArg(options::OPT_nodefaultlibs)) {
8329 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
8330 !Args.hasArg(options::OPT_static);
8331 if (StaticCXX)
8332 CmdArgs.push_back("-Bstatic");
8333 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
8334 if (StaticCXX)
8335 CmdArgs.push_back("-Bdynamic");
8336 }
8337
8338 if (!Args.hasArg(options::OPT_nostdlib)) {
8339 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8340 // TODO handle /MT[d] /MD[d]
8341 CmdArgs.push_back("-lmsvcrt");
8342 AddRunTimeLibs(TC, D, CmdArgs, Args);
8343 }
8344 }
8345
8346 const std::string Linker = TC.GetProgramPath("ld");
8347 Exec = Args.MakeArgString(Linker);
8348
8349 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8350}