blob: 6c19cc7ce4ff8d094f6535d5daaac06e4b62d1d7 [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
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000980 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000981 options::OPT_mcpu_EQ))
982 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000983
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000984 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000985 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000986 // Convert a GNU style Mips ABI name to the name
987 // accepted by LLVM Mips backend.
988 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
989 .Case("32", "o32")
990 .Case("64", "n64")
991 .Default(ABIName);
992 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000993
994 // Setup default CPU and ABI names.
995 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000996 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000997 default:
998 llvm_unreachable("Unexpected triple arch name");
999 case llvm::Triple::mips:
1000 case llvm::Triple::mipsel:
1001 CPUName = DefMips32CPU;
1002 break;
1003 case llvm::Triple::mips64:
1004 case llvm::Triple::mips64el:
1005 CPUName = DefMips64CPU;
1006 break;
1007 }
1008 }
1009
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001010 if (ABIName.empty()) {
1011 // Deduce ABI name from the target triple.
1012 if (Triple.getArch() == llvm::Triple::mips ||
1013 Triple.getArch() == llvm::Triple::mipsel)
1014 ABIName = "o32";
1015 else
1016 ABIName = "n64";
1017 }
1018
1019 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001020 // Deduce CPU name from ABI name.
1021 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +00001022 .Cases("o32", "eabi", DefMips32CPU)
1023 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001024 .Default("");
1025 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001026
1027 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001028}
1029
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001030// Convert ABI name to the GNU tools acceptable variant.
1031static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1032 return llvm::StringSwitch<llvm::StringRef>(ABI)
1033 .Case("o32", "32")
1034 .Case("n64", "64")
1035 .Default(ABI);
1036}
1037
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001038// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1039// and -mfloat-abi=.
1040static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001041 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001042 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001043 options::OPT_mhard_float,
1044 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001045 if (A->getOption().matches(options::OPT_msoft_float))
1046 FloatABI = "soft";
1047 else if (A->getOption().matches(options::OPT_mhard_float))
1048 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001049 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001050 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001051 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001052 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001053 FloatABI = "hard";
1054 }
1055 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001056 }
1057
1058 // If unspecified, choose the default based on the platform.
1059 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001060 // Assume "hard", because it's a default value used by gcc.
1061 // When we start to recognize specific target MIPS processors,
1062 // we will be able to select the default more correctly.
1063 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001064 }
1065
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001066 return FloatABI;
1067}
1068
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001069static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001070 std::vector<const char *> &Features,
1071 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001072 StringRef FeatureName) {
1073 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001074 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001075 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001076 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001077 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001078 }
1079}
1080
Daniel Sanders379d44b2014-07-16 11:52:23 +00001081static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1082 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001083 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001084 StringRef CPUName;
1085 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001086 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001087 ABIName = getGnuCompatibleMipsABIName(ABIName);
1088
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001089 // Always override the backend's default ABI.
Aaron Ballman9eef74232014-07-17 13:28:50 +00001090 std::string ABIFeature = llvm::StringSwitch<StringRef>(ABIName)
1091 .Case("32", "+o32")
1092 .Case("n32", "+n32")
1093 .Case("64", "+n64")
1094 .Case("eabi", "+eabi")
1095 .Default(("+" + ABIName).str());
Daniel Sanders4dcbe812014-07-17 09:46:40 +00001096 Features.push_back("-o32");
1097 Features.push_back("-n64");
1098 Features.push_back(Args.MakeArgString(ABIFeature));
1099
Daniel Sandersfeb61302014-08-08 15:47:17 +00001100 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1101 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001102
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001103 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001104 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001105 // FIXME: Note, this is a hack. We need to pass the selected float
1106 // mode to the MipsTargetInfoBase to define appropriate macros there.
1107 // Now it is the only method.
1108 Features.push_back("+soft-float");
1109 }
1110
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001111 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001112 StringRef Val = StringRef(A->getValue());
1113 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001114 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001115 else if (Val == "legacy")
1116 Features.push_back("-nan2008");
1117 else
1118 D.Diag(diag::err_drv_unsupported_option_argument)
1119 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001120 }
1121
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001122 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1123 options::OPT_mdouble_float, "single-float");
1124 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1125 "mips16");
1126 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1127 options::OPT_mno_micromips, "micromips");
1128 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1129 "dsp");
1130 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1131 "dspr2");
1132 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1133 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001134
1135 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1136 // pass -mfpxx
1137 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1138 options::OPT_mfp64)) {
1139 if (A->getOption().matches(options::OPT_mfp32))
1140 Features.push_back(Args.MakeArgString("-fp64"));
1141 else if (A->getOption().matches(options::OPT_mfpxx)) {
1142 Features.push_back(Args.MakeArgString("+fpxx"));
1143 Features.push_back(Args.MakeArgString("+nooddspreg"));
1144 } else
1145 Features.push_back(Args.MakeArgString("+fp64"));
1146 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001147 Features.push_back(Args.MakeArgString("+fpxx"));
1148 Features.push_back(Args.MakeArgString("+nooddspreg"));
1149 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001150
Daniel Sanders28e5d392014-07-10 10:39:51 +00001151 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1152 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001153}
1154
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001155void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001156 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001157 const Driver &D = getToolChain().getDriver();
1158 StringRef CPUName;
1159 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001160 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001161 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001162
1163 CmdArgs.push_back("-target-abi");
1164 CmdArgs.push_back(ABIName.data());
1165
1166 StringRef FloatABI = getMipsFloatABI(D, Args);
1167
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001168 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001169 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001170 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001171 CmdArgs.push_back("-mfloat-abi");
1172 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001173 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001174 else {
1175 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001176 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001177 CmdArgs.push_back("-mfloat-abi");
1178 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001179 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001180
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001181 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1182 if (A->getOption().matches(options::OPT_mxgot)) {
1183 CmdArgs.push_back("-mllvm");
1184 CmdArgs.push_back("-mxgot");
1185 }
1186 }
1187
Simon Atanasyanc580b322013-05-11 06:33:44 +00001188 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1189 options::OPT_mno_ldc1_sdc1)) {
1190 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1191 CmdArgs.push_back("-mllvm");
1192 CmdArgs.push_back("-mno-ldc1-sdc1");
1193 }
1194 }
1195
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001196 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1197 options::OPT_mno_check_zero_division)) {
1198 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1199 CmdArgs.push_back("-mllvm");
1200 CmdArgs.push_back("-mno-check-zero-division");
1201 }
1202 }
1203
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001204 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001205 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001206 CmdArgs.push_back("-mllvm");
1207 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1208 A->claim();
1209 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001210}
1211
Hal Finkel8eb59282012-06-11 22:35:19 +00001212/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1213static std::string getPPCTargetCPU(const ArgList &Args) {
1214 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001215 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001216
1217 if (CPUName == "native") {
1218 std::string CPU = llvm::sys::getHostCPUName();
1219 if (!CPU.empty() && CPU != "generic")
1220 return CPU;
1221 else
1222 return "";
1223 }
1224
1225 return llvm::StringSwitch<const char *>(CPUName)
1226 .Case("common", "generic")
1227 .Case("440", "440")
1228 .Case("440fp", "440")
1229 .Case("450", "450")
1230 .Case("601", "601")
1231 .Case("602", "602")
1232 .Case("603", "603")
1233 .Case("603e", "603e")
1234 .Case("603ev", "603ev")
1235 .Case("604", "604")
1236 .Case("604e", "604e")
1237 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001238 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001239 .Case("G3", "g3")
1240 .Case("7400", "7400")
1241 .Case("G4", "g4")
1242 .Case("7450", "7450")
1243 .Case("G4+", "g4+")
1244 .Case("750", "750")
1245 .Case("970", "970")
1246 .Case("G5", "g5")
1247 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001248 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001249 .Case("e500mc", "e500mc")
1250 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001251 .Case("power3", "pwr3")
1252 .Case("power4", "pwr4")
1253 .Case("power5", "pwr5")
1254 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001255 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001256 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001257 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001258 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001259 .Case("pwr3", "pwr3")
1260 .Case("pwr4", "pwr4")
1261 .Case("pwr5", "pwr5")
1262 .Case("pwr5x", "pwr5x")
1263 .Case("pwr6", "pwr6")
1264 .Case("pwr6x", "pwr6x")
1265 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001266 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001267 .Case("powerpc", "ppc")
1268 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001269 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001270 .Default("");
1271 }
1272
1273 return "";
1274}
1275
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001276static void getPPCTargetFeatures(const ArgList &Args,
1277 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001278 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1279 ie = Args.filtered_end();
1280 it != ie; ++it) {
1281 StringRef Name = (*it)->getOption().getName();
1282 (*it)->claim();
1283
1284 // Skip over "-m".
1285 assert(Name.startswith("m") && "Invalid feature name.");
1286 Name = Name.substr(1);
1287
1288 bool IsNegative = Name.startswith("no-");
1289 if (IsNegative)
1290 Name = Name.substr(3);
1291
1292 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1293 // pass the correct option to the backend while calling the frontend
1294 // option the same.
1295 // TODO: Change the LLVM backend option maybe?
1296 if (Name == "mfcrf")
1297 Name = "mfocrf";
1298
1299 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1300 }
1301
1302 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001303 AddTargetFeature(Args, Features, options::OPT_faltivec,
1304 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001305}
1306
Ulrich Weigand8afad612014-07-28 13:17:52 +00001307void Clang::AddPPCTargetArgs(const ArgList &Args,
1308 ArgStringList &CmdArgs) const {
1309 // Select the ABI to use.
1310 const char *ABIName = nullptr;
1311 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1312 ABIName = A->getValue();
1313 } else if (getToolChain().getTriple().isOSLinux())
1314 switch(getToolChain().getArch()) {
1315 case llvm::Triple::ppc64:
1316 ABIName = "elfv1";
1317 break;
1318 case llvm::Triple::ppc64le:
1319 ABIName = "elfv2";
1320 break;
1321 default:
1322 break;
1323 }
1324
1325 if (ABIName) {
1326 CmdArgs.push_back("-target-abi");
1327 CmdArgs.push_back(ABIName);
1328 }
1329}
1330
1331bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1332 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1333 return A && (A->getValue() == StringRef(Value));
1334}
1335
Tom Stellard6674c702013-04-01 20:56:53 +00001336/// Get the (LLVM) name of the R600 gpu we are targeting.
1337static std::string getR600TargetGPU(const ArgList &Args) {
1338 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001339 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001340 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001341 .Cases("rv630", "rv635", "r600")
1342 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001343 .Case("rv740", "rv770")
1344 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001345 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001346 .Case("hemlock", "cypress")
1347 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001348 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001349 }
1350 return "";
1351}
1352
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001353static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001354 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001355 bool SoftFloatABI = true;
1356 if (Arg *A =
1357 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1358 if (A->getOption().matches(options::OPT_mhard_float))
1359 SoftFloatABI = false;
1360 }
1361 if (SoftFloatABI)
1362 Features.push_back("+soft-float");
1363}
1364
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001365void Clang::AddSparcTargetArgs(const ArgList &Args,
1366 ArgStringList &CmdArgs) const {
1367 const Driver &D = getToolChain().getDriver();
1368
Brad Smith10cd0f42014-07-11 20:12:08 +00001369 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001370 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001371 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1372 options::OPT_mhard_float)) {
1373 if (A->getOption().matches(options::OPT_msoft_float))
1374 FloatABI = "soft";
1375 else if (A->getOption().matches(options::OPT_mhard_float))
1376 FloatABI = "hard";
1377 }
1378
1379 // If unspecified, choose the default based on the platform.
1380 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001381 // Assume "soft", but warn the user we are guessing.
1382 FloatABI = "soft";
1383 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001384 }
1385
1386 if (FloatABI == "soft") {
1387 // Floating point operations and argument passing are soft.
1388 //
1389 // FIXME: This changes CPP defines, we need -target-soft-float.
1390 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001391 } else {
1392 assert(FloatABI == "hard" && "Invalid float abi!");
1393 CmdArgs.push_back("-mhard-float");
1394 }
1395}
1396
Richard Sandiford4652d892013-07-19 16:51:51 +00001397static const char *getSystemZTargetCPU(const ArgList &Args) {
1398 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1399 return A->getValue();
1400 return "z10";
1401}
1402
Chandler Carruth953fb082013-01-13 11:46:33 +00001403static const char *getX86TargetCPU(const ArgList &Args,
1404 const llvm::Triple &Triple) {
1405 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001406 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001407 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001408 return "core-avx2";
1409
Chandler Carruth953fb082013-01-13 11:46:33 +00001410 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001411 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001412
1413 // FIXME: Reject attempts to use -march=native unless the target matches
1414 // the host.
1415 //
1416 // FIXME: We should also incorporate the detected target features for use
1417 // with -native.
1418 std::string CPU = llvm::sys::getHostCPUName();
1419 if (!CPU.empty() && CPU != "generic")
1420 return Args.MakeArgString(CPU);
1421 }
1422
1423 // Select the default CPU if none was given (or detection failed).
1424
1425 if (Triple.getArch() != llvm::Triple::x86_64 &&
1426 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001427 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001428
1429 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1430
1431 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001432 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001433 if (Triple.getArchName() == "x86_64h")
1434 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001435 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001436 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001437
Alexey Bataev286d1b92014-01-31 04:07:13 +00001438 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001439 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001440 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001441
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001442 // Everything else goes to x86-64 in 64-bit mode.
1443 if (Is64Bit)
1444 return "x86-64";
1445
1446 switch (Triple.getOS()) {
1447 case llvm::Triple::FreeBSD:
1448 case llvm::Triple::NetBSD:
1449 case llvm::Triple::OpenBSD:
1450 return "i486";
1451 case llvm::Triple::Haiku:
1452 return "i586";
1453 case llvm::Triple::Bitrig:
1454 return "i686";
1455 default:
1456 // Fallback to p4.
1457 return "pentium4";
1458 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001459}
1460
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001461static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1462 switch(T.getArch()) {
1463 default:
1464 return "";
1465
Amara Emerson703da2e2013-10-31 09:32:33 +00001466 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001467 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001468 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001469
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001470 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001471 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001472 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001473 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001474 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001475
1476 case llvm::Triple::mips:
1477 case llvm::Triple::mipsel:
1478 case llvm::Triple::mips64:
1479 case llvm::Triple::mips64el: {
1480 StringRef CPUName;
1481 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001482 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001483 return CPUName;
1484 }
1485
1486 case llvm::Triple::ppc:
1487 case llvm::Triple::ppc64:
1488 case llvm::Triple::ppc64le: {
1489 std::string TargetCPUName = getPPCTargetCPU(Args);
1490 // LLVM may default to generating code for the native CPU,
1491 // but, like gcc, we default to a more generic option for
1492 // each architecture. (except on Darwin)
1493 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1494 if (T.getArch() == llvm::Triple::ppc64)
1495 TargetCPUName = "ppc64";
1496 else if (T.getArch() == llvm::Triple::ppc64le)
1497 TargetCPUName = "ppc64le";
1498 else
1499 TargetCPUName = "ppc";
1500 }
1501 return TargetCPUName;
1502 }
1503
1504 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001505 case llvm::Triple::sparcv9:
1506 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001507 return A->getValue();
1508 return "";
1509
1510 case llvm::Triple::x86:
1511 case llvm::Triple::x86_64:
1512 return getX86TargetCPU(Args, T);
1513
1514 case llvm::Triple::hexagon:
1515 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1516
1517 case llvm::Triple::systemz:
1518 return getSystemZTargetCPU(Args);
1519
1520 case llvm::Triple::r600:
1521 return getR600TargetGPU(Args);
1522 }
1523}
1524
Alp Tokerce365ca2013-12-02 12:43:03 +00001525static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1526 ArgStringList &CmdArgs) {
1527 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1528 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1529 // forward.
1530 CmdArgs.push_back("-plugin");
1531 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1532 CmdArgs.push_back(Args.MakeArgString(Plugin));
1533
1534 // Try to pass driver level flags relevant to LTO code generation down to
1535 // the plugin.
1536
1537 // Handle flags for selecting CPU variants.
1538 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1539 if (!CPU.empty())
1540 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1541}
1542
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001543static void getX86TargetFeatures(const Driver & D,
1544 const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001545 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001546 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001547 if (Triple.getArchName() == "x86_64h") {
1548 // x86_64h implies quite a few of the more modern subtarget features
1549 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1550 Features.push_back("-rdrnd");
1551 Features.push_back("-aes");
1552 Features.push_back("-pclmul");
1553 Features.push_back("-rtm");
1554 Features.push_back("-hle");
1555 Features.push_back("-fsgsbase");
1556 }
1557
Alexey Volkov54ff0802014-06-25 12:15:36 +00001558 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001559 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001560 if (Triple.getArch() == llvm::Triple::x86_64) {
1561 Features.push_back("+sse4.2");
1562 Features.push_back("+popcnt");
1563 } else
1564 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001565 }
1566
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001567 // Set features according to the -arch flag on MSVC
1568 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1569 StringRef Arch = A->getValue();
1570 bool ArchUsed = false;
1571 // First, look for flags that are shared in x86 and x86-64.
1572 if (Triple.getArch() == llvm::Triple::x86_64 ||
1573 Triple.getArch() == llvm::Triple::x86) {
1574 if (Arch == "AVX" || Arch == "AVX2") {
1575 ArchUsed = true;
1576 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1577 }
1578 }
1579 // Then, look for x86-specific flags.
1580 if (Triple.getArch() == llvm::Triple::x86) {
1581 if (Arch == "IA32") {
1582 ArchUsed = true;
1583 } else if (Arch == "SSE" || Arch == "SSE2") {
1584 ArchUsed = true;
1585 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1586 }
1587 }
1588 if (!ArchUsed)
1589 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1590 }
1591
Jim Grosbach82eee262013-11-16 00:53:35 +00001592 // Now add any that the user explicitly requested on the command line,
1593 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001594 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1595 ie = Args.filtered_end();
1596 it != ie; ++it) {
1597 StringRef Name = (*it)->getOption().getName();
1598 (*it)->claim();
1599
1600 // Skip over "-m".
1601 assert(Name.startswith("m") && "Invalid feature name.");
1602 Name = Name.substr(1);
1603
1604 bool IsNegative = Name.startswith("no-");
1605 if (IsNegative)
1606 Name = Name.substr(3);
1607
1608 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1609 }
1610}
1611
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001612void Clang::AddX86TargetArgs(const ArgList &Args,
1613 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001614 if (!Args.hasFlag(options::OPT_mred_zone,
1615 options::OPT_mno_red_zone,
1616 true) ||
1617 Args.hasArg(options::OPT_mkernel) ||
1618 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001619 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001620
Bob Wilson2616e2e2013-02-10 16:01:41 +00001621 // Default to avoid implicit floating-point for kernel/kext code, but allow
1622 // that to be overridden with -mno-soft-float.
1623 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1624 Args.hasArg(options::OPT_fapple_kext));
1625 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1626 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001627 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001628 options::OPT_mno_implicit_float)) {
1629 const Option &O = A->getOption();
1630 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1631 O.matches(options::OPT_msoft_float));
1632 }
1633 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001634 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001635
1636 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1637 StringRef Value = A->getValue();
1638 if (Value == "intel" || Value == "att") {
1639 CmdArgs.push_back("-mllvm");
1640 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1641 } else {
1642 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1643 << A->getOption().getName() << Value;
1644 }
1645 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001646}
1647
Matthew Curtise8f80a12012-12-06 17:49:03 +00001648static inline bool HasPICArg(const ArgList &Args) {
1649 return Args.hasArg(options::OPT_fPIC)
1650 || Args.hasArg(options::OPT_fpic);
1651}
1652
1653static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1654 return Args.getLastArg(options::OPT_G,
1655 options::OPT_G_EQ,
1656 options::OPT_msmall_data_threshold_EQ);
1657}
1658
1659static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1660 std::string value;
1661 if (HasPICArg(Args))
1662 value = "0";
1663 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1664 value = A->getValue();
1665 A->claim();
1666 }
1667 return value;
1668}
1669
Tony Linthicum76329bf2011-12-12 21:14:55 +00001670void Clang::AddHexagonTargetArgs(const ArgList &Args,
1671 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001672 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001673 CmdArgs.push_back("-mqdsp6-compat");
1674 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001675
Matthew Curtise8f80a12012-12-06 17:49:03 +00001676 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1677 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001678 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001679 CmdArgs.push_back(Args.MakeArgString(
1680 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001681 }
1682
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001683 if (!Args.hasArg(options::OPT_fno_short_enums))
1684 CmdArgs.push_back("-fshort-enums");
1685 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1686 CmdArgs.push_back ("-mllvm");
1687 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1688 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001689 CmdArgs.push_back ("-mllvm");
1690 CmdArgs.push_back ("-machine-sink-split=0");
1691}
1692
Kevin Qin110db6f2014-07-18 07:03:22 +00001693// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001694static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001695 std::vector<const char *> &Features) {
1696 SmallVector<StringRef, 8> Split;
1697 text.split(Split, StringRef("+"), -1, false);
1698
1699 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1700 const char *result = llvm::StringSwitch<const char *>(Split[I])
1701 .Case("fp", "+fp-armv8")
1702 .Case("simd", "+neon")
1703 .Case("crc", "+crc")
1704 .Case("crypto", "+crypto")
1705 .Case("nofp", "-fp-armv8")
1706 .Case("nosimd", "-neon")
1707 .Case("nocrc", "-crc")
1708 .Case("nocrypto", "-crypto")
1709 .Default(nullptr);
1710 if (result)
1711 Features.push_back(result);
1712 else if (Split[I] == "neon" || Split[I] == "noneon")
1713 D.Diag(diag::err_drv_no_neon_modifier);
1714 else
1715 return false;
1716 }
1717 return true;
1718}
1719
1720// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1721// decode CPU and feature.
1722static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1723 std::vector<const char *> &Features) {
1724 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1725 CPU = Split.first;
1726 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57") {
1727 Features.push_back("+neon");
1728 Features.push_back("+crc");
1729 Features.push_back("+crypto");
1730 } else if (CPU == "generic") {
1731 Features.push_back("+neon");
1732 } else {
1733 return false;
1734 }
1735
1736 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1737 return false;
1738
1739 return true;
1740}
1741
1742static bool
1743getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1744 const ArgList &Args,
1745 std::vector<const char *> &Features) {
1746 std::pair<StringRef, StringRef> Split = March.split("+");
1747 if (Split.first != "armv8-a")
1748 return false;
1749
1750 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1751 return false;
1752
1753 return true;
1754}
1755
1756static bool
1757getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1758 const ArgList &Args,
1759 std::vector<const char *> &Features) {
1760 StringRef CPU;
1761 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1762 return false;
1763
1764 return true;
1765}
1766
1767static bool
1768getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1769 const ArgList &Args,
1770 std::vector<const char *> &Features) {
1771 // Handle CPU name is 'native'.
1772 if (Mtune == "native")
1773 Mtune = llvm::sys::getHostCPUName();
1774 if (Mtune == "cyclone") {
1775 Features.push_back("+zcm");
1776 Features.push_back("+zcz");
1777 }
1778 return true;
1779}
1780
1781static bool
1782getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1783 const ArgList &Args,
1784 std::vector<const char *> &Features) {
1785 StringRef CPU;
1786 std::vector<const char *> DecodedFeature;
1787 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1788 return false;
1789
1790 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1791}
1792
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001793static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1794 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001795 Arg *A;
1796 bool success = true;
1797 // Enable NEON by default.
1798 Features.push_back("+neon");
1799 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1800 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1801 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1802 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001803 else if (Args.hasArg(options::OPT_arch))
1804 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1805 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001806
1807 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1808 success =
1809 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1810 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1811 success =
1812 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001813 else if (Args.hasArg(options::OPT_arch))
1814 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1815 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001816
1817 if (!success)
1818 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001819
1820 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1821 Features.push_back("-fp-armv8");
1822 Features.push_back("-crypto");
1823 Features.push_back("-neon");
1824 }
Bradley Smith418c5932014-05-02 15:17:51 +00001825
1826 // En/disable crc
1827 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1828 options::OPT_mnocrc)) {
1829 if (A->getOption().matches(options::OPT_mcrc))
1830 Features.push_back("+crc");
1831 else
1832 Features.push_back("-crc");
1833 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001834}
1835
1836static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001837 const ArgList &Args, ArgStringList &CmdArgs,
1838 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001839 std::vector<const char *> Features;
1840 switch (Triple.getArch()) {
1841 default:
1842 break;
1843 case llvm::Triple::mips:
1844 case llvm::Triple::mipsel:
1845 case llvm::Triple::mips64:
1846 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001847 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001848 break;
1849
1850 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001851 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001852 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001853 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001854 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001855 break;
1856
1857 case llvm::Triple::ppc:
1858 case llvm::Triple::ppc64:
1859 case llvm::Triple::ppc64le:
1860 getPPCTargetFeatures(Args, Features);
1861 break;
1862 case llvm::Triple::sparc:
Brad Smithf436e9e2014-08-19 21:50:15 +00001863 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001864 getSparcTargetFeatures(Args, Features);
1865 break;
1866 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001867 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001868 getAArch64TargetFeatures(D, Args, Features);
1869 break;
1870 case llvm::Triple::x86:
1871 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001872 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001873 break;
1874 }
Rafael Espindola43964802013-08-21 17:34:32 +00001875
1876 // Find the last of each feature.
1877 llvm::StringMap<unsigned> LastOpt;
1878 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1879 const char *Name = Features[I];
1880 assert(Name[0] == '-' || Name[0] == '+');
1881 LastOpt[Name + 1] = I;
1882 }
1883
1884 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1885 // If this feature was overridden, ignore it.
1886 const char *Name = Features[I];
1887 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1888 assert(LastI != LastOpt.end());
1889 unsigned Last = LastI->second;
1890 if (Last != I)
1891 continue;
1892
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001893 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001894 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001895 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001896}
1897
David Majnemerae394812014-12-09 00:12:30 +00001898static bool
1899shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1900 const llvm::Triple &Triple) {
1901 // We use the zero-cost exception tables for Objective-C if the non-fragile
1902 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1903 // later.
1904 if (runtime.isNonFragile())
1905 return true;
1906
1907 if (!Triple.isMacOSX())
1908 return false;
1909
1910 return (!Triple.isMacOSXVersionLT(10,5) &&
1911 (Triple.getArch() == llvm::Triple::x86_64 ||
1912 Triple.getArch() == llvm::Triple::arm));
1913}
1914
Nico Webere8e53112014-05-11 01:04:02 +00001915// exceptionSettings() exists to share the logic between -cc1 and linker
1916// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00001917static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001918 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001919 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001920 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00001921 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001922
David Majnemer8de68642014-12-05 08:11:58 +00001923 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001924}
1925
Anders Carlssone96ab552011-02-28 02:27:16 +00001926/// addExceptionArgs - Adds exception related arguments to the driver command
1927/// arguments. There's a master flag, -fexceptions and also language specific
1928/// flags to enable/disable C++ and Objective-C exceptions.
1929/// This makes it possible to for example disable C++ exceptions but enable
1930/// Objective-C exceptions.
1931static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1932 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001933 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001934 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001935 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001936 if (KernelOrKext) {
1937 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1938 // arguments now to avoid warnings about unused arguments.
1939 Args.ClaimAllArgs(options::OPT_fexceptions);
1940 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1941 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1942 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1943 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1944 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001945 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001946 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001947
David Majnemer8de68642014-12-05 08:11:58 +00001948 // Gather the exception settings from the command line arguments.
1949 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001950
David Majnemerae394812014-12-09 00:12:30 +00001951 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1952 // is not necessarily sensible, but follows GCC.
1953 if (types::isObjC(InputType) &&
1954 Args.hasFlag(options::OPT_fobjc_exceptions,
1955 options::OPT_fno_objc_exceptions,
1956 true)) {
1957 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001958
David Majnemerae394812014-12-09 00:12:30 +00001959 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001960 }
1961
1962 if (types::isCXX(InputType)) {
David Majnemer8de68642014-12-05 08:11:58 +00001963 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore;
Eric Christopher84fbdb42011-08-19 00:30:14 +00001964 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1965 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001966 options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001967 options::OPT_fno_exceptions))
1968 CXXExceptionsEnabled =
1969 A->getOption().matches(options::OPT_fcxx_exceptions) ||
1970 A->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001971
1972 if (CXXExceptionsEnabled) {
1973 CmdArgs.push_back("-fcxx-exceptions");
1974
David Majnemer8de68642014-12-05 08:11:58 +00001975 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001976 }
1977 }
1978
David Majnemer8de68642014-12-05 08:11:58 +00001979 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00001980 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001981}
1982
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001983static bool ShouldDisableAutolink(const ArgList &Args,
1984 const ToolChain &TC) {
1985 bool Default = true;
1986 if (TC.getTriple().isOSDarwin()) {
1987 // The native darwin assembler doesn't support the linker_option directives,
1988 // so we disable them if we think the .s file will be passed to it.
1989 Default = TC.useIntegratedAs();
1990 }
1991 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1992 Default);
1993}
1994
Ted Kremenek62093662013-03-12 17:02:12 +00001995static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1996 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001997 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1998 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001999 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002000 return !UseDwarfDirectory;
2001}
2002
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002003/// \brief Check whether the given input tree contains any compilation actions.
2004static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002005 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002006 return true;
2007
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002008 for (const auto &Act : *A)
2009 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002010 return true;
2011
2012 return false;
2013}
2014
2015/// \brief Check if -relax-all should be passed to the internal assembler.
2016/// This is done by default when compiling non-assembler source with -O0.
2017static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2018 bool RelaxDefault = true;
2019
2020 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2021 RelaxDefault = A->getOption().matches(options::OPT_O0);
2022
2023 if (RelaxDefault) {
2024 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002025 for (const auto &Act : C.getActions()) {
2026 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002027 RelaxDefault = true;
2028 break;
2029 }
2030 }
2031 }
2032
2033 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2034 RelaxDefault);
2035}
2036
David Blaikie9260ed62013-07-25 21:19:01 +00002037static void CollectArgsForIntegratedAssembler(Compilation &C,
2038 const ArgList &Args,
2039 ArgStringList &CmdArgs,
2040 const Driver &D) {
2041 if (UseRelaxAll(C, Args))
2042 CmdArgs.push_back("-mrelax-all");
2043
David Peixottodfb66142013-11-14 22:52:58 +00002044 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002045 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002046 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2047 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2048 // arg after parsing the '-I' arg.
2049 bool TakeNextArg = false;
2050
David Blaikie9260ed62013-07-25 21:19:01 +00002051 // When using an integrated assembler, translate -Wa, and -Xassembler
2052 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002053 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00002054 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
2055 options::OPT_Xassembler),
2056 ie = Args.filtered_end(); it != ie; ++it) {
2057 const Arg *A = *it;
2058 A->claim();
2059
2060 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2061 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002062 if (TakeNextArg) {
2063 CmdArgs.push_back(Value.data());
2064 TakeNextArg = false;
2065 continue;
2066 }
David Blaikie9260ed62013-07-25 21:19:01 +00002067
2068 if (Value == "-force_cpusubtype_ALL") {
2069 // Do nothing, this is the default and we don't support anything else.
2070 } else if (Value == "-L") {
2071 CmdArgs.push_back("-msave-temp-labels");
2072 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002073 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002074 } else if (Value == "--noexecstack") {
2075 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002076 } else if (Value == "-compress-debug-sections" ||
2077 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002078 CompressDebugSections = true;
2079 } else if (Value == "-nocompress-debug-sections" ||
2080 Value == "--nocompress-debug-sections") {
2081 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002082 } else if (Value.startswith("-I")) {
2083 CmdArgs.push_back(Value.data());
2084 // We need to consume the next argument if the current arg is a plain
2085 // -I. The next arg will be the include directory.
2086 if (Value == "-I")
2087 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002088 } else if (Value.startswith("-gdwarf-")) {
2089 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002090 } else {
2091 D.Diag(diag::err_drv_unsupported_option_argument)
2092 << A->getOption().getName() << Value;
2093 }
2094 }
2095 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002096 if (CompressDebugSections) {
2097 if (llvm::zlib::isAvailable())
2098 CmdArgs.push_back("-compress-debug-sections");
2099 else
2100 D.Diag(diag::warn_debug_compression_unavailable);
2101 }
David Blaikie9260ed62013-07-25 21:19:01 +00002102}
2103
Renato Goline807c122014-01-31 11:47:28 +00002104// Until ARM libraries are build separately, we have them all in one library
2105static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002106 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002107 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002108 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002109}
2110
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002111static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2112 // The runtimes are located in the OS-specific resource directory.
2113 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002114 const llvm::Triple &Triple = TC.getTriple();
2115 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002116 StringRef OSLibName =
2117 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002118 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002119 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002120}
2121
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002122static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
2123 bool Shared = false,
2124 const char *Env = "") {
2125 bool IsOSWindows = TC.getTriple().isOSWindows();
2126 StringRef Arch = getArchNameForCompilerRTLib(TC);
2127 const char *Prefix = IsOSWindows ? "" : "lib";
2128 const char *Suffix =
2129 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2130
2131 SmallString<128> Path = getCompilerRTLibDir(TC);
2132 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2133 Arch + Env + Suffix);
2134
2135 return Path;
2136}
2137
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002138// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002139// FIXME: Make sure we can also emit shared objects if they're requested
2140// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002141static void addClangRT(const ToolChain &TC, const ArgList &Args,
2142 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002143 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002144
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002145 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002146 // FIXME: why do we link against gcc when we are using compiler-rt?
2147 CmdArgs.push_back("-lgcc_s");
2148 if (TC.getDriver().CCCIsCXX())
2149 CmdArgs.push_back("-lgcc_eh");
2150 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002151}
2152
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002153static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2154 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002155 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2156 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002157 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002158 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002159 Args.hasArg(options::OPT_fcreate_profile) ||
2160 Args.hasArg(options::OPT_coverage)))
2161 return;
2162
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002163 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002164}
2165
Alexey Samsonov52550342014-09-15 19:58:40 +00002166static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2167 ArgStringList &CmdArgs, StringRef Sanitizer,
2168 bool IsShared) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002169 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2170 ? "-android"
2171 : "";
2172
Alexey Samsonov52550342014-09-15 19:58:40 +00002173 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002174 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002175 if (!IsShared)
2176 CmdArgs.push_back("-whole-archive");
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002177 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared,
2178 Env)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002179 if (!IsShared)
2180 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002181}
2182
Alexey Samsonov52550342014-09-15 19:58:40 +00002183// Tries to use a file with the list of dynamic symbols that need to be exported
2184// from the runtime library. Returns true if the file was found.
2185static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2186 ArgStringList &CmdArgs,
2187 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002188 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2189 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2190 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002191 return true;
2192 }
2193 return false;
2194}
2195
2196static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2197 ArgStringList &CmdArgs) {
2198 // Force linking against the system libraries sanitizers depends on
2199 // (see PR15823 why this is necessary).
2200 CmdArgs.push_back("--no-as-needed");
2201 CmdArgs.push_back("-lpthread");
2202 CmdArgs.push_back("-lrt");
2203 CmdArgs.push_back("-lm");
2204 // There's no libdl on FreeBSD.
2205 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2206 CmdArgs.push_back("-ldl");
2207}
2208
2209static void
2210collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2211 SmallVectorImpl<StringRef> &SharedRuntimes,
2212 SmallVectorImpl<StringRef> &StaticRuntimes,
2213 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2214 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2215 // Collect shared runtimes.
2216 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2217 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002218 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002219
Alexey Samsonov52550342014-09-15 19:58:40 +00002220 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002221 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002222 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2223 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002224 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002225 }
2226 if (SanArgs.needsAsanRt()) {
2227 if (SanArgs.needsSharedAsanRt()) {
2228 HelperStaticRuntimes.push_back("asan-preinit");
2229 } else {
2230 StaticRuntimes.push_back("asan");
2231 if (SanArgs.linkCXXRuntimes())
2232 StaticRuntimes.push_back("asan_cxx");
2233 }
2234 }
2235 if (SanArgs.needsDfsanRt())
2236 StaticRuntimes.push_back("dfsan");
2237 if (SanArgs.needsLsanRt())
2238 StaticRuntimes.push_back("lsan");
2239 if (SanArgs.needsMsanRt())
2240 StaticRuntimes.push_back("msan");
2241 if (SanArgs.needsTsanRt())
2242 StaticRuntimes.push_back("tsan");
2243 // WARNING: UBSan should always go last.
2244 if (SanArgs.needsUbsanRt()) {
2245 // If UBSan is not combined with another sanitizer, we need to pull in
2246 // sanitizer_common explicitly.
2247 if (StaticRuntimes.empty())
2248 HelperStaticRuntimes.push_back("san");
2249 StaticRuntimes.push_back("ubsan");
2250 if (SanArgs.linkCXXRuntimes())
2251 StaticRuntimes.push_back("ubsan_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002252 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002253}
2254
Alexey Samsonov52550342014-09-15 19:58:40 +00002255// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2256// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2257static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002258 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002259 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2260 HelperStaticRuntimes;
2261 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2262 HelperStaticRuntimes);
2263 for (auto RT : SharedRuntimes)
2264 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2265 for (auto RT : HelperStaticRuntimes)
2266 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2267 bool AddExportDynamic = false;
2268 for (auto RT : StaticRuntimes) {
2269 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2270 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2271 }
2272 // If there is a static runtime with no dynamic list, force all the symbols
2273 // to be dynamic to be sure we export sanitizer interface functions.
2274 if (AddExportDynamic)
2275 CmdArgs.push_back("-export-dynamic");
2276 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002277}
2278
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002279static bool shouldUseFramePointerForTarget(const ArgList &Args,
2280 const llvm::Triple &Triple) {
2281 switch (Triple.getArch()) {
2282 // Don't use a frame pointer on linux if optimizing for certain targets.
2283 case llvm::Triple::mips64:
2284 case llvm::Triple::mips64el:
2285 case llvm::Triple::mips:
2286 case llvm::Triple::mipsel:
2287 case llvm::Triple::systemz:
2288 case llvm::Triple::x86:
2289 case llvm::Triple::x86_64:
2290 if (Triple.isOSLinux())
2291 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2292 if (!A->getOption().matches(options::OPT_O0))
2293 return false;
2294 return true;
2295 case llvm::Triple::xcore:
2296 return false;
2297 default:
2298 return true;
2299 }
2300}
2301
Rafael Espindola224dd632011-12-14 21:02:23 +00002302static bool shouldUseFramePointer(const ArgList &Args,
2303 const llvm::Triple &Triple) {
2304 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2305 options::OPT_fomit_frame_pointer))
2306 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2307
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002308 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002309}
2310
Eric Christopherb7d97e92013-04-03 01:58:53 +00002311static bool shouldUseLeafFramePointer(const ArgList &Args,
2312 const llvm::Triple &Triple) {
2313 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2314 options::OPT_momit_leaf_frame_pointer))
2315 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2316
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002317 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002318}
2319
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002320/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002321static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002322 SmallString<128> cwd;
2323 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002324 CmdArgs.push_back("-fdebug-compilation-dir");
2325 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002326 }
2327}
2328
Eric Christopherd3804002013-02-22 20:12:52 +00002329static const char *SplitDebugName(const ArgList &Args,
2330 const InputInfoList &Inputs) {
2331 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2332 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2333 SmallString<128> T(FinalOutput->getValue());
2334 llvm::sys::path::replace_extension(T, "dwo");
2335 return Args.MakeArgString(T);
2336 } else {
2337 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002338 SmallString<128> T(
2339 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002340 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2341 llvm::sys::path::replace_extension(F, "dwo");
2342 T += F;
2343 return Args.MakeArgString(F);
2344 }
2345}
2346
2347static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2348 const Tool &T, const JobAction &JA,
2349 const ArgList &Args, const InputInfo &Output,
2350 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002351 ArgStringList ExtractArgs;
2352 ExtractArgs.push_back("--extract-dwo");
2353
2354 ArgStringList StripArgs;
2355 StripArgs.push_back("--strip-dwo");
2356
2357 // Grabbing the output of the earlier compile step.
2358 StripArgs.push_back(Output.getFilename());
2359 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002360 ExtractArgs.push_back(OutFile);
2361
2362 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002363 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002364
2365 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002366 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002367
2368 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002369 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002370}
2371
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002372/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002373/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2374static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002375 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002376 if (A->getOption().matches(options::OPT_O4) ||
2377 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002378 return true;
2379
2380 if (A->getOption().matches(options::OPT_O0))
2381 return false;
2382
2383 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2384
Rafael Espindola91780de2013-08-26 14:05:41 +00002385 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002386 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002387 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002388 return true;
2389
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002390 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002391 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002392 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002393
2394 unsigned OptLevel = 0;
2395 if (S.getAsInteger(10, OptLevel))
2396 return false;
2397
2398 return OptLevel > 1;
2399 }
2400
2401 return false;
2402}
2403
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002404/// Add -x lang to \p CmdArgs for \p Input.
2405static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2406 ArgStringList &CmdArgs) {
2407 // When using -verify-pch, we don't want to provide the type
2408 // 'precompiled-header' if it was inferred from the file extension
2409 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2410 return;
2411
2412 CmdArgs.push_back("-x");
2413 if (Args.hasArg(options::OPT_rewrite_objc))
2414 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2415 else
2416 CmdArgs.push_back(types::getTypeName(Input.getType()));
2417}
2418
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002419static std::string getMSCompatibilityVersion(const char *VersionStr) {
2420 unsigned Version;
2421 if (StringRef(VersionStr).getAsInteger(10, Version))
2422 return "0";
2423
2424 if (Version < 100)
2425 return llvm::utostr_32(Version) + ".0";
2426
2427 if (Version < 10000)
2428 return llvm::utostr_32(Version / 100) + "." +
2429 llvm::utostr_32(Version % 100);
2430
2431 unsigned Build = 0, Factor = 1;
2432 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2433 Build = Build + (Version % 10) * Factor;
2434 return llvm::utostr_32(Version / 100) + "." +
2435 llvm::utostr_32(Version % 100) + "." +
2436 llvm::utostr_32(Build);
2437}
2438
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002439void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002440 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002441 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002442 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002443 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002444 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2445 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002446 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002447 ArgStringList CmdArgs;
2448
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002449 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002450 bool IsWindowsCygnus =
2451 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002452 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2453
Daniel Dunbare521a892009-03-31 20:53:55 +00002454 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2455
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002456 // Invoke ourselves in -cc1 mode.
2457 //
2458 // FIXME: Implement custom jobs for internal actions.
2459 CmdArgs.push_back("-cc1");
2460
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002461 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002462 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002463 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002464 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002465
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002466 const llvm::Triple TT(TripleStr);
2467 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2468 TT.getArch() == llvm::Triple::thumb)) {
2469 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2470 unsigned Version;
2471 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2472 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002473 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2474 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002475 }
2476
Tim Northover336f1892014-03-29 13:16:12 +00002477 // Push all default warning arguments that are specific to
2478 // the given target. These come before user provided warning options
2479 // are provided.
2480 getToolChain().addClangWarningOptions(CmdArgs);
2481
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002482 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002483 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002484
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002485 if (isa<AnalyzeJobAction>(JA)) {
2486 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2487 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002488 } else if (isa<MigrateJobAction>(JA)) {
2489 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002490 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002491 if (Output.getType() == types::TY_Dependencies)
2492 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002493 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002494 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002495 if (Args.hasArg(options::OPT_rewrite_objc) &&
2496 !Args.hasArg(options::OPT_g_Group))
2497 CmdArgs.push_back("-P");
2498 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002499 } else if (isa<AssembleJobAction>(JA)) {
2500 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002501
David Blaikie9260ed62013-07-25 21:19:01 +00002502 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002503
2504 // Also ignore explicit -force_cpusubtype_ALL option.
2505 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002506 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002507 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002508 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002509
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002510 if (JA.getType() == types::TY_Nothing)
2511 CmdArgs.push_back("-fsyntax-only");
2512 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002513 CmdArgs.push_back("-emit-pch");
2514 else
2515 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002516 } else if (isa<VerifyPCHJobAction>(JA)) {
2517 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002518 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002519 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2520 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002521
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002522 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002523 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002524 } else if (JA.getType() == types::TY_LLVM_IR ||
2525 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002526 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002527 } else if (JA.getType() == types::TY_LLVM_BC ||
2528 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002529 CmdArgs.push_back("-emit-llvm-bc");
2530 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002531 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002532 } else if (JA.getType() == types::TY_AST) {
2533 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002534 } else if (JA.getType() == types::TY_ModuleFile) {
2535 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002536 } else if (JA.getType() == types::TY_RewrittenObjC) {
2537 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002538 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002539 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2540 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002541 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002542 } else {
2543 assert(JA.getType() == types::TY_PP_Asm &&
2544 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002545 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002546 }
2547
Justin Bognera88f0122014-06-20 22:59:50 +00002548 // We normally speed up the clang process a bit by skipping destructors at
2549 // exit, but when we're generating diagnostics we can rely on some of the
2550 // cleanup.
2551 if (!C.isForDiagnostics())
2552 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002553
John McCallbb79b5f2010-02-13 03:50:24 +00002554 // Disable the verification pass in -asserts builds.
2555#ifdef NDEBUG
2556 CmdArgs.push_back("-disable-llvm-verifier");
2557#endif
2558
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002559 // Set the main file name, so that debug info works even with
2560 // -save-temps.
2561 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002562 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002563
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002564 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002565 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002566 if (Args.hasArg(options::OPT_static))
2567 CmdArgs.push_back("-static-define");
2568
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002569 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002570 // Enable region store model by default.
2571 CmdArgs.push_back("-analyzer-store=region");
2572
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002573 // Treat blocks as analysis entry points.
2574 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2575
Ted Kremenek49c79792011-03-24 00:28:47 +00002576 CmdArgs.push_back("-analyzer-eagerly-assume");
2577
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002578 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002579 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002580 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002581
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002582 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002583 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002584
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002585 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002586 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002587
2588 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002589
Jordan Rose10ad0812013-04-05 17:55:07 +00002590 if (types::isCXX(Inputs[0].getType()))
2591 CmdArgs.push_back("-analyzer-checker=cplusplus");
2592
Nico Webere8e53112014-05-11 01:04:02 +00002593 // Enable the following experimental checkers for testing.
2594 CmdArgs.push_back(
2595 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002596 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2597 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2598 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2599 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2600 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002601 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002602
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002603 // Set the output format. The default is plist, for (lame) historical
2604 // reasons.
2605 CmdArgs.push_back("-analyzer-output");
2606 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002607 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002608 else
2609 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002610
Ted Kremenekfe449a22010-03-22 22:32:05 +00002611 // Disable the presentation of standard compiler warnings when
2612 // using --analyze. We only want to show static analyzer diagnostics
2613 // or frontend errors.
2614 CmdArgs.push_back("-w");
2615
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002616 // Add -Xanalyzer arguments when running as analyzer.
2617 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002618 }
2619
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002620 CheckCodeGenerationOptions(D, Args);
2621
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002622 bool PIE = getToolChain().isPIEDefault();
2623 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002624 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002625
Alexey Bataev40e75222014-01-28 06:30:35 +00002626 // Android-specific defaults for PIC/PIE
2627 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2628 switch (getToolChain().getTriple().getArch()) {
2629 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002630 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002631 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002632 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002633 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002634 case llvm::Triple::mips:
2635 case llvm::Triple::mipsel:
2636 case llvm::Triple::mips64:
2637 case llvm::Triple::mips64el:
2638 PIC = true; // "-fpic"
2639 break;
2640
2641 case llvm::Triple::x86:
2642 case llvm::Triple::x86_64:
2643 PIC = true; // "-fPIC"
2644 IsPICLevelTwo = true;
2645 break;
2646
2647 default:
2648 break;
2649 }
2650 }
2651
Brad Smith5b05db82014-06-24 19:51:29 +00002652 // OpenBSD-specific defaults for PIE
2653 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2654 switch (getToolChain().getTriple().getArch()) {
2655 case llvm::Triple::mips64:
2656 case llvm::Triple::mips64el:
2657 case llvm::Triple::sparc:
2658 case llvm::Triple::x86:
2659 case llvm::Triple::x86_64:
2660 IsPICLevelTwo = false; // "-fpie"
2661 break;
2662
2663 case llvm::Triple::ppc:
2664 case llvm::Triple::sparcv9:
2665 IsPICLevelTwo = true; // "-fPIE"
2666 break;
2667
2668 default:
2669 break;
2670 }
2671 }
2672
Alexey Samsonov090301e2013-04-09 12:28:19 +00002673 // For the PIC and PIE flag options, this logic is different from the
2674 // legacy logic in very old versions of GCC, as that logic was just
2675 // a bug no one had ever fixed. This logic is both more rational and
2676 // consistent with GCC's new logic now that the bugs are fixed. The last
2677 // argument relating to either PIC or PIE wins, and no other argument is
2678 // used. If the last argument is any flavor of the '-fno-...' arguments,
2679 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2680 // at the same level.
2681 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2682 options::OPT_fpic, options::OPT_fno_pic,
2683 options::OPT_fPIE, options::OPT_fno_PIE,
2684 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002685 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2686 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002687 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002688 if (LastPICArg) {
2689 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002690 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2691 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2692 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2693 PIC = PIE || O.matches(options::OPT_fPIC) ||
2694 O.matches(options::OPT_fpic);
2695 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2696 O.matches(options::OPT_fPIC);
2697 } else {
2698 PIE = PIC = false;
2699 }
2700 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002701 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002702
Nick Lewycky609dd662013-10-11 03:33:53 +00002703 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002704 // specified while enabling PIC enabled level 1 PIC, just force it back to
2705 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2706 // informal testing).
2707 if (PIC && getToolChain().getTriple().isOSDarwin())
2708 IsPICLevelTwo |= getToolChain().isPICDefault();
2709
Chandler Carruthc0c04552012-04-08 16:40:35 +00002710 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2711 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002712 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00002713 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002714 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002715 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002716 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002717
Chandler Carruth76a943b2012-11-19 03:52:03 +00002718 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2719 // This is a very special mode. It trumps the other modes, almost no one
2720 // uses it, and it isn't even valid on any OS but Darwin.
2721 if (!getToolChain().getTriple().isOSDarwin())
2722 D.Diag(diag::err_drv_unsupported_opt_for_target)
2723 << A->getSpelling() << getToolChain().getTriple().str();
2724
2725 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2726
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002727 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002728 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002729
Chandler Carruth76a943b2012-11-19 03:52:03 +00002730 // Only a forced PIC mode can cause the actual compile to have PIC defines
2731 // etc., no flags are sufficient. This behavior was selected to closely
2732 // match that of llvm-gcc and Apple GCC before that.
2733 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2734 CmdArgs.push_back("-pic-level");
2735 CmdArgs.push_back("2");
2736 }
2737 } else {
2738 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2739 // handled in Clang's IRGen by the -pie-level flag.
2740 CmdArgs.push_back("-mrelocation-model");
2741 CmdArgs.push_back(PIC ? "pic" : "static");
2742
2743 if (PIC) {
2744 CmdArgs.push_back("-pic-level");
2745 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2746 if (PIE) {
2747 CmdArgs.push_back("-pie-level");
2748 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2749 }
2750 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002751 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002752
Jonathan Roelofsb140a102014-10-03 21:57:44 +00002753 CmdArgs.push_back("-mthread-model");
2754 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2755 CmdArgs.push_back(A->getValue());
2756 else
2757 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2758
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002759 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2760 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002761 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002762
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002763 // LLVM Code Generator Options.
2764
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002765 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2766 StringRef v = A->getValue();
2767 CmdArgs.push_back("-mllvm");
2768 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2769 A->claim();
2770 }
2771
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002772 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2773 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002774 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002775 }
2776
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002777 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2778 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002779 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002780 D.Diag(diag::err_drv_unsupported_opt_for_target)
2781 << A->getSpelling() << getToolChain().getTriple().str();
2782 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2783 CmdArgs.push_back("-fpcc-struct-return");
2784 } else {
2785 assert(A->getOption().matches(options::OPT_freg_struct_return));
2786 CmdArgs.push_back("-freg-struct-return");
2787 }
2788 }
2789
Roman Divacky65b88cd2011-03-01 17:40:53 +00002790 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2791 CmdArgs.push_back("-mrtd");
2792
Rafael Espindola224dd632011-12-14 21:02:23 +00002793 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002794 CmdArgs.push_back("-mdisable-fp-elim");
2795 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2796 options::OPT_fno_zero_initialized_in_bss))
2797 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002798
2799 bool OFastEnabled = isOptimizationLevelFast(Args);
2800 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2801 // enabled. This alias option is being used to simplify the hasFlag logic.
2802 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2803 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002804 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2805 // doesn't do any TBAA.
2806 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002807 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002808 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002809 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002810 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2811 options::OPT_fno_struct_path_tbaa))
2812 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002813 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2814 false))
2815 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002816 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2817 options::OPT_fno_optimize_sibling_calls))
2818 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002819
Eric Christopher006208c2013-04-04 06:29:47 +00002820 // Handle segmented stacks.
2821 if (Args.hasArg(options::OPT_fsplit_stack))
2822 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002823
2824 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2825 // This alias option is being used to simplify the getLastArg logic.
2826 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2827 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002828
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002829 // Handle various floating point optimization flags, mapping them to the
2830 // appropriate LLVM code generation flags. The pattern for all of these is to
2831 // default off the codegen optimizations, and if any flag enables them and no
2832 // flag disables them after the flag enabling them, enable the codegen
2833 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002834 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002835 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002836 options::OPT_ffinite_math_only,
2837 options::OPT_fno_finite_math_only,
2838 options::OPT_fhonor_infinities,
2839 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002840 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2841 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002842 A->getOption().getID() != options::OPT_fhonor_infinities)
2843 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002844 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002845 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002846 options::OPT_ffinite_math_only,
2847 options::OPT_fno_finite_math_only,
2848 options::OPT_fhonor_nans,
2849 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002850 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2851 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002852 A->getOption().getID() != options::OPT_fhonor_nans)
2853 CmdArgs.push_back("-menable-no-nans");
2854
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002855 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2856 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002857 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002858 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002859 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002860 options::OPT_fno_math_errno)) {
2861 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2862 // However, turning *off* -ffast_math merely restores the toolchain default
2863 // (which may be false).
2864 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2865 A->getOption().getID() == options::OPT_ffast_math ||
2866 A->getOption().getID() == options::OPT_Ofast)
2867 MathErrno = false;
2868 else if (A->getOption().getID() == options::OPT_fmath_errno)
2869 MathErrno = true;
2870 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002871 if (MathErrno)
2872 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002873
2874 // There are several flags which require disabling very specific
2875 // optimizations. Any of these being disabled forces us to turn off the
2876 // entire set of LLVM optimizations, so collect them through all the flag
2877 // madness.
2878 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002879 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002880 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002881 options::OPT_funsafe_math_optimizations,
2882 options::OPT_fno_unsafe_math_optimizations,
2883 options::OPT_fassociative_math,
2884 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002885 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2886 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002887 A->getOption().getID() != options::OPT_fno_associative_math)
2888 AssociativeMath = true;
2889 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002890 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002891 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002892 options::OPT_funsafe_math_optimizations,
2893 options::OPT_fno_unsafe_math_optimizations,
2894 options::OPT_freciprocal_math,
2895 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002896 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2897 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002898 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2899 ReciprocalMath = true;
2900 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002901 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002902 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002903 options::OPT_funsafe_math_optimizations,
2904 options::OPT_fno_unsafe_math_optimizations,
2905 options::OPT_fsigned_zeros,
2906 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002907 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2908 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002909 A->getOption().getID() != options::OPT_fsigned_zeros)
2910 SignedZeros = false;
2911 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002912 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002913 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002914 options::OPT_funsafe_math_optimizations,
2915 options::OPT_fno_unsafe_math_optimizations,
2916 options::OPT_ftrapping_math,
2917 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002918 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2919 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002920 A->getOption().getID() != options::OPT_ftrapping_math)
2921 TrappingMath = false;
2922 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2923 !TrappingMath)
2924 CmdArgs.push_back("-menable-unsafe-fp-math");
2925
Lang Hamesaa53b932012-07-06 00:59:19 +00002926
2927 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002928 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002929 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002930 options::OPT_ffp_contract)) {
2931 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002932 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002933 if (Val == "fast" || Val == "on" || Val == "off") {
2934 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2935 } else {
2936 D.Diag(diag::err_drv_unsupported_option_argument)
2937 << A->getOption().getName() << Val;
2938 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002939 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2940 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002941 // If fast-math is set then set the fp-contract mode to fast.
2942 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2943 }
2944 }
2945
Bob Wilson6a039162012-07-19 03:52:53 +00002946 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2947 // and if we find them, tell the frontend to provide the appropriate
2948 // preprocessor macros. This is distinct from enabling any optimizations as
2949 // these options induce language changes which must survive serialization
2950 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002951 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2952 options::OPT_fno_fast_math))
2953 if (!A->getOption().matches(options::OPT_fno_fast_math))
2954 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002955 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2956 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002957 if (A->getOption().matches(options::OPT_ffinite_math_only))
2958 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002959
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002960 // Decide whether to use verbose asm. Verbose assembly is the default on
2961 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002962 bool IsIntegratedAssemblerDefault =
2963 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002964 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002965 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002966 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002967 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002968
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002969 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002970 IsIntegratedAssemblerDefault))
2971 CmdArgs.push_back("-no-integrated-as");
2972
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002973 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2974 CmdArgs.push_back("-mdebug-pass");
2975 CmdArgs.push_back("Structure");
2976 }
2977 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2978 CmdArgs.push_back("-mdebug-pass");
2979 CmdArgs.push_back("Arguments");
2980 }
2981
John McCall8517abc2010-02-19 02:45:38 +00002982 // Enable -mconstructor-aliases except on darwin, where we have to
2983 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002984 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002985 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002986
John McCall7ef5cb32011-03-18 02:56:14 +00002987 // Darwin's kernel doesn't support guard variables; just die if we
2988 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002989 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002990 CmdArgs.push_back("-fforbid-guard-variables");
2991
Douglas Gregordbe39272011-02-01 15:15:22 +00002992 if (Args.hasArg(options::OPT_mms_bitfields)) {
2993 CmdArgs.push_back("-mms-bitfields");
2994 }
John McCall8517abc2010-02-19 02:45:38 +00002995
Daniel Dunbar306945d2009-09-16 06:17:29 +00002996 // This is a coarse approximation of what llvm-gcc actually does, both
2997 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2998 // complicated ways.
2999 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003000 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3001 options::OPT_fno_asynchronous_unwind_tables,
3002 (getToolChain().IsUnwindTablesDefault() ||
3003 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3004 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003005 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3006 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003007 CmdArgs.push_back("-munwind-tables");
3008
Chandler Carruth05fb5852012-11-21 23:40:23 +00003009 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003010
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003011 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3012 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003013 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003014 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003015
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003016 // FIXME: Handle -mtune=.
3017 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003018
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003019 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003020 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003021 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003022 }
3023
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003024 // Add the target cpu
3025 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3026 llvm::Triple ETriple(ETripleStr);
3027 std::string CPU = getCPUName(Args, ETriple);
3028 if (!CPU.empty()) {
3029 CmdArgs.push_back("-target-cpu");
3030 CmdArgs.push_back(Args.MakeArgString(CPU));
3031 }
3032
Rafael Espindolaeb265472013-08-21 21:59:03 +00003033 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3034 CmdArgs.push_back("-mfpmath");
3035 CmdArgs.push_back(A->getValue());
3036 }
3037
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003038 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003039 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003040
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003041 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003042 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003043 default:
3044 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003045
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003046 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003047 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003048 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003049 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003050 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003051 break;
3052
Tim Northover573cbee2014-05-24 12:52:07 +00003053 case llvm::Triple::aarch64:
3054 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003055 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003056 break;
3057
Eric Christopher0b26a612010-03-02 02:41:08 +00003058 case llvm::Triple::mips:
3059 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003060 case llvm::Triple::mips64:
3061 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003062 AddMIPSTargetArgs(Args, CmdArgs);
3063 break;
3064
Ulrich Weigand8afad612014-07-28 13:17:52 +00003065 case llvm::Triple::ppc:
3066 case llvm::Triple::ppc64:
3067 case llvm::Triple::ppc64le:
3068 AddPPCTargetArgs(Args, CmdArgs);
3069 break;
3070
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003071 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003072 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003073 AddSparcTargetArgs(Args, CmdArgs);
3074 break;
3075
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003076 case llvm::Triple::x86:
3077 case llvm::Triple::x86_64:
3078 AddX86TargetArgs(Args, CmdArgs);
3079 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003080
3081 case llvm::Triple::hexagon:
3082 AddHexagonTargetArgs(Args, CmdArgs);
3083 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003084 }
3085
Hans Wennborg75958c42013-08-08 00:17:41 +00003086 // Add clang-cl arguments.
3087 if (getToolChain().getDriver().IsCLMode())
3088 AddClangCLArgs(Args, CmdArgs);
3089
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003090 // Pass the linker version in use.
3091 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3092 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003093 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003094 }
3095
Eric Christopherb7d97e92013-04-03 01:58:53 +00003096 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003097 CmdArgs.push_back("-momit-leaf-frame-pointer");
3098
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003099 // Explicitly error on some things we know we don't support and can't just
3100 // ignore.
3101 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003102 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3103 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003104 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003105 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003106 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003107 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3108 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003109 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003110 << Unsupported->getOption().getName();
3111 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003112 }
3113
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003114 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003115 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003116 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003117 CmdArgs.push_back("-header-include-file");
3118 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3119 D.CCPrintHeadersFilename : "-");
3120 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003121 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003122 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003123
Chad Rosierbe10f982011-08-02 17:58:04 +00003124 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003125 CmdArgs.push_back("-diagnostic-log-file");
3126 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3127 D.CCLogDiagnosticsFilename : "-");
3128 }
3129
Manman Ren17bdb0f2013-11-20 20:22:14 +00003130 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3131 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003132 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003133 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003134 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3135 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003136 // FIXME: we should support specifying dwarf version with
3137 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003138 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003139 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003140 const llvm::Triple &Triple = getToolChain().getTriple();
3141 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003142 Triple.getOS() == llvm::Triple::FreeBSD ||
3143 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003144 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003145 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003146 CmdArgs.push_back("-gdwarf-2");
3147 else if (A->getOption().matches(options::OPT_gdwarf_3))
3148 CmdArgs.push_back("-gdwarf-3");
3149 else if (A->getOption().matches(options::OPT_gdwarf_4))
3150 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003151 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003152 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003153 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003154 const llvm::Triple &Triple = getToolChain().getTriple();
3155 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003156 Triple.getOS() == llvm::Triple::FreeBSD ||
3157 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003158 CmdArgs.push_back("-gdwarf-2");
3159 else
3160 CmdArgs.push_back("-g");
3161 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003162 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003163
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003164 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3165 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003166 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3167 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003168 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003169
Eric Christopher138c32b2013-09-13 22:37:55 +00003170 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003171 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3172 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003173 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003174 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003175 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003176 CmdArgs.push_back("-g");
3177 CmdArgs.push_back("-backend-option");
3178 CmdArgs.push_back("-split-dwarf=Enable");
3179 }
3180
Eric Christopher138c32b2013-09-13 22:37:55 +00003181 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3182 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3183 CmdArgs.push_back("-backend-option");
3184 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3185 }
Eric Christophereec89c22013-06-18 00:03:50 +00003186
Eric Christopher0d403d22014-02-14 01:27:03 +00003187 // -gdwarf-aranges turns on the emission of the aranges section in the
3188 // backend.
3189 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3190 CmdArgs.push_back("-backend-option");
3191 CmdArgs.push_back("-generate-arange-section");
3192 }
3193
David Blaikief36d9ba2014-01-27 18:52:43 +00003194 if (Args.hasFlag(options::OPT_fdebug_types_section,
3195 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003196 CmdArgs.push_back("-backend-option");
3197 CmdArgs.push_back("-generate-type-units");
3198 }
Eric Christophereec89c22013-06-18 00:03:50 +00003199
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003200 if (Args.hasFlag(options::OPT_ffunction_sections,
3201 options::OPT_fno_function_sections, false)) {
3202 CmdArgs.push_back("-ffunction-sections");
3203 }
3204
3205 if (Args.hasFlag(options::OPT_fdata_sections,
3206 options::OPT_fno_data_sections, false)) {
3207 CmdArgs.push_back("-fdata-sections");
3208 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003209
Chris Lattner3c77a352010-06-22 00:03:40 +00003210 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3211
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003212 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3213 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3214 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3215 D.Diag(diag::err_drv_argument_not_allowed_with)
3216 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3217
3218 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3219
3220 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3221 A->render(Args, CmdArgs);
3222 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3223 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3224
Nick Lewycky207bce32011-04-21 23:44:07 +00003225 if (Args.hasArg(options::OPT_ftest_coverage) ||
3226 Args.hasArg(options::OPT_coverage))
3227 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003228 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3229 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003230 Args.hasArg(options::OPT_coverage))
3231 CmdArgs.push_back("-femit-coverage-data");
3232
Alex Lorenzee024992014-08-04 18:41:51 +00003233 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
3234 !Args.hasArg(options::OPT_fprofile_instr_generate))
3235 D.Diag(diag::err_drv_argument_only_allowed_with)
3236 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3237
3238 if (Args.hasArg(options::OPT_fcoverage_mapping))
3239 CmdArgs.push_back("-fcoverage-mapping");
3240
Nick Lewycky480cb992011-05-04 20:46:58 +00003241 if (C.getArgs().hasArg(options::OPT_c) ||
3242 C.getArgs().hasArg(options::OPT_S)) {
3243 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003244 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003245 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003246 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003247 CoverageFilename = FinalOutput->getValue();
3248 } else {
3249 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3250 }
Nick Lewycky737a4522013-03-07 08:28:53 +00003251 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003252 SmallString<128> Pwd;
3253 if (!llvm::sys::fs::current_path(Pwd)) {
3254 llvm::sys::path::append(Pwd, CoverageFilename.str());
3255 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003256 }
3257 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003258 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003259 }
3260 }
3261
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003262 // Pass options for controlling the default header search paths.
3263 if (Args.hasArg(options::OPT_nostdinc)) {
3264 CmdArgs.push_back("-nostdsysteminc");
3265 CmdArgs.push_back("-nobuiltininc");
3266 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003267 if (Args.hasArg(options::OPT_nostdlibinc))
3268 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003269 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3270 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3271 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003272
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003273 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003274 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003275 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003276
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003277 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3278
Ted Kremenekf7639e12012-03-06 20:06:33 +00003279 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003280 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003281 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003282 options::OPT_ccc_arcmt_modify,
3283 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003284 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003285 switch (A->getOption().getID()) {
3286 default:
3287 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003288 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003289 CmdArgs.push_back("-arcmt-check");
3290 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003291 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003292 CmdArgs.push_back("-arcmt-modify");
3293 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003294 case options::OPT_ccc_arcmt_migrate:
3295 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003296 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003297 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003298
3299 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3300 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003301 break;
John McCalld70fb982011-06-15 23:25:17 +00003302 }
3303 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003304 } else {
3305 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3306 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3307 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003308 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003309
Ted Kremenekf7639e12012-03-06 20:06:33 +00003310 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3311 if (ARCMTEnabled) {
3312 D.Diag(diag::err_drv_argument_not_allowed_with)
3313 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3314 }
3315 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003316 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003317
3318 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003319 options::OPT_objcmt_migrate_subscripting,
3320 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003321 // None specified, means enable them all.
3322 CmdArgs.push_back("-objcmt-migrate-literals");
3323 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003324 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003325 } else {
3326 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3327 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003328 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003329 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003330 } else {
3331 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3332 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3333 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3334 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3335 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3336 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3337 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3338 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3339 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3340 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3341 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3342 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3343 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003344 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003345 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003346 }
3347
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003348 // Add preprocessing options like -I, -D, etc. if we are using the
3349 // preprocessor.
3350 //
3351 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003352 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003353 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003354
Rafael Espindolaa7431922011-07-21 23:40:37 +00003355 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3356 // that "The compiler can only warn and ignore the option if not recognized".
3357 // When building with ccache, it will pass -D options to clang even on
3358 // preprocessed inputs and configure concludes that -fPIC is not supported.
3359 Args.ClaimAllArgs(options::OPT_D);
3360
Alp Toker7874bdc2013-11-15 20:40:58 +00003361 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003362 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3363 if (A->getOption().matches(options::OPT_O4)) {
3364 CmdArgs.push_back("-O3");
3365 D.Diag(diag::warn_O4_is_O3);
3366 } else {
3367 A->render(Args, CmdArgs);
3368 }
3369 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003370
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003371 // Warn about ignored options to clang.
3372 for (arg_iterator it = Args.filtered_begin(
3373 options::OPT_clang_ignored_gcc_optimization_f_Group),
3374 ie = Args.filtered_end(); it != ie; ++it) {
3375 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3376 }
3377
Chad Rosier86b82082012-12-12 20:06:31 +00003378 // Don't warn about unused -flto. This can happen when we're preprocessing or
3379 // precompiling.
3380 Args.ClaimAllArgs(options::OPT_flto);
3381
Richard Smith3be1cb22014-08-07 00:24:21 +00003382 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003383 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003384 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3385 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003386 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003387 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003388
3389 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003390 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003391 //
3392 // If a std is supplied, only add -trigraphs if it follows the
3393 // option.
3394 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3395 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003396 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003397 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003398 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003399 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003400 else
3401 Std->render(Args, CmdArgs);
3402
Nico Weber00721502014-12-23 22:32:37 +00003403 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003404 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003405 options::OPT_ftrigraphs,
3406 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003407 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003408 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003409 } else {
3410 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003411 //
3412 // FIXME: Clang doesn't correctly handle -std= when the input language
3413 // doesn't match. For the time being just ignore this for C++ inputs;
3414 // eventually we want to do all the standard defaulting here instead of
3415 // splitting it between the driver and clang -cc1.
3416 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003417 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3418 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003419 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003420 CmdArgs.push_back("-std=c++11");
3421
Nico Weber00721502014-12-23 22:32:37 +00003422 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3423 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003424 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003425
Richard Smith282b4492013-09-04 22:50:31 +00003426 // GCC's behavior for -Wwrite-strings is a bit strange:
3427 // * In C, this "warning flag" changes the types of string literals from
3428 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3429 // for the discarded qualifier.
3430 // * In C++, this is just a normal warning flag.
3431 //
3432 // Implementing this warning correctly in C is hard, so we follow GCC's
3433 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3434 // a non-const char* in C, rather than using this crude hack.
3435 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003436 // FIXME: This should behave just like a warning flag, and thus should also
3437 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3438 Arg *WriteStrings =
3439 Args.getLastArg(options::OPT_Wwrite_strings,
3440 options::OPT_Wno_write_strings, options::OPT_w);
3441 if (WriteStrings &&
3442 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003443 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003444 }
3445
Chandler Carruth61fbf622011-04-23 09:27:53 +00003446 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003447 // during C++ compilation, which it is by default. GCC keeps this define even
3448 // in the presence of '-w', match this behavior bug-for-bug.
3449 if (types::isCXX(InputType) &&
3450 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3451 true)) {
3452 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003453 }
3454
Chandler Carruthe0391482010-05-22 02:21:53 +00003455 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3456 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3457 if (Asm->getOption().matches(options::OPT_fasm))
3458 CmdArgs.push_back("-fgnu-keywords");
3459 else
3460 CmdArgs.push_back("-fno-gnu-keywords");
3461 }
3462
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003463 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3464 CmdArgs.push_back("-fno-dwarf-directory-asm");
3465
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003466 if (ShouldDisableAutolink(Args, getToolChain()))
3467 CmdArgs.push_back("-fno-autolink");
3468
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003469 // Add in -fdebug-compilation-dir if necessary.
3470 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003471
Richard Smith9a568822011-11-21 19:36:32 +00003472 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3473 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003474 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003475 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003476 }
3477
Richard Smith79c927b2013-11-06 19:31:51 +00003478 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3479 CmdArgs.push_back("-foperator-arrow-depth");
3480 CmdArgs.push_back(A->getValue());
3481 }
3482
Richard Smith9a568822011-11-21 19:36:32 +00003483 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3484 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003485 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003486 }
3487
Richard Smitha3d3bd22013-05-08 02:12:03 +00003488 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3489 CmdArgs.push_back("-fconstexpr-steps");
3490 CmdArgs.push_back(A->getValue());
3491 }
3492
Richard Smithb3a14522013-02-22 01:59:51 +00003493 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3494 CmdArgs.push_back("-fbracket-depth");
3495 CmdArgs.push_back(A->getValue());
3496 }
3497
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003498 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3499 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003500 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003501 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003502 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3503 } else
3504 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003505 }
3506
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003507
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003508 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003509 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003510
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003511 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3512 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003513 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003514 }
David Chisnall5778fce2009-08-31 16:41:57 +00003515
Chris Lattnere23003d2010-01-09 21:54:33 +00003516 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3517 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003518 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003519 }
3520
Chris Lattnerb35583d2010-04-07 20:49:23 +00003521 CmdArgs.push_back("-ferror-limit");
3522 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003523 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003524 else
3525 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003526
Chandler Carrutha77a7272010-05-06 04:55:18 +00003527 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3528 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003529 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003530 }
3531
3532 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3533 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003534 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003535 }
3536
Richard Smithf6f003a2011-12-16 19:06:07 +00003537 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3538 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003539 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003540 }
3541
Nick Lewycky24653262014-12-16 21:39:02 +00003542 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3543 CmdArgs.push_back("-fspell-checking-limit");
3544 CmdArgs.push_back(A->getValue());
3545 }
3546
Daniel Dunbar2c978472009-11-04 06:24:47 +00003547 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003548 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003549 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003550 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003551 } else {
3552 // If -fmessage-length=N was not specified, determine whether this is a
3553 // terminal and, if so, implicitly define -fmessage-length appropriately.
3554 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003555 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003556 }
3557
John McCallb4a99d32013-02-19 01:57:35 +00003558 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3559 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3560 options::OPT_fvisibility_ms_compat)) {
3561 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3562 CmdArgs.push_back("-fvisibility");
3563 CmdArgs.push_back(A->getValue());
3564 } else {
3565 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3566 CmdArgs.push_back("-fvisibility");
3567 CmdArgs.push_back("hidden");
3568 CmdArgs.push_back("-ftype-visibility");
3569 CmdArgs.push_back("default");
3570 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003571 }
3572
Douglas Gregor08329632010-06-15 17:05:35 +00003573 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003574
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003575 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3576
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003577 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003578 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3579 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003580 CmdArgs.push_back("-ffreestanding");
3581
Daniel Dunbare357d562009-12-03 18:42:11 +00003582 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003583 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003584 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003585 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3586 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003587 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003588 // AltiVec language extensions aren't relevant for assembling.
3589 if (!isa<PreprocessJobAction>(JA) ||
3590 Output.getType() != types::TY_PP_Asm)
3591 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003592 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3593 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003594
Peter Collingbourne32701642013-11-01 18:16:25 +00003595 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3596 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003597
Eric Christopher459d2712013-02-19 06:16:53 +00003598 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003599 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003600 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003601 getToolChain().getArch() == llvm::Triple::ppc64 ||
3602 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003603 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003604 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003605
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003606 if (getToolChain().SupportsProfiling())
3607 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003608
3609 // -flax-vector-conversions is default.
3610 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3611 options::OPT_fno_lax_vector_conversions))
3612 CmdArgs.push_back("-fno-lax-vector-conversions");
3613
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003614 if (Args.getLastArg(options::OPT_fapple_kext))
3615 CmdArgs.push_back("-fapple-kext");
3616
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003617 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003618 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003619 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003620 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3621 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003622
3623 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3624 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003625 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003626 }
3627
Bob Wilson14adb362012-02-03 06:27:22 +00003628 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003629
Chandler Carruth6e501032011-03-27 00:04:55 +00003630 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3631 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3632 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3633 options::OPT_fno_wrapv)) {
3634 if (A->getOption().matches(options::OPT_fwrapv))
3635 CmdArgs.push_back("-fwrapv");
3636 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3637 options::OPT_fno_strict_overflow)) {
3638 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3639 CmdArgs.push_back("-fwrapv");
3640 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003641
3642 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3643 options::OPT_fno_reroll_loops))
3644 if (A->getOption().matches(options::OPT_freroll_loops))
3645 CmdArgs.push_back("-freroll-loops");
3646
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003647 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003648 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3649 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003650
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003651 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3652
Mahesha S6a682be42012-10-27 07:47:56 +00003653
Daniel Dunbar4930e332009-11-17 08:07:36 +00003654 // -stack-protector=0 is default.
3655 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003656 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3657 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003658 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003659 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003660 if (A->getOption().matches(options::OPT_fstack_protector)) {
3661 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3662 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3663 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003664 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003665 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003666 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003667 } else {
3668 StackProtectorLevel =
3669 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3670 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003671 if (StackProtectorLevel) {
3672 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003673 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003674 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003675
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003676 // --param ssp-buffer-size=
3677 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3678 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003679 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003680 if (Str.startswith("ssp-buffer-size=")) {
3681 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003682 CmdArgs.push_back("-stack-protector-buffer-size");
3683 // FIXME: Verify the argument is a valid integer.
3684 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003685 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003686 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003687 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003688 }
3689
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003690 // Translate -mstackrealign
3691 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3692 false)) {
3693 CmdArgs.push_back("-backend-option");
3694 CmdArgs.push_back("-force-align-stack");
3695 }
3696 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3697 false)) {
3698 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3699 }
3700
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003701 if (Args.hasArg(options::OPT_mstack_alignment)) {
3702 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3703 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003704 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003705
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003706 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3707 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
3708 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3709
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003710 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3711 options::OPT_mno_restrict_it)) {
3712 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3713 CmdArgs.push_back("-backend-option");
3714 CmdArgs.push_back("-arm-restrict-it");
3715 } else {
3716 CmdArgs.push_back("-backend-option");
3717 CmdArgs.push_back("-arm-no-restrict-it");
3718 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003719 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3720 TT.getArch() == llvm::Triple::thumb)) {
3721 // Windows on ARM expects restricted IT blocks
3722 CmdArgs.push_back("-backend-option");
3723 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003724 }
3725
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003726 if (TT.getArch() == llvm::Triple::arm ||
3727 TT.getArch() == llvm::Triple::thumb) {
3728 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3729 options::OPT_mno_long_calls)) {
3730 if (A->getOption().matches(options::OPT_mlong_calls)) {
3731 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003732 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003733 }
3734 }
3735 }
3736
Daniel Dunbard18049a2009-04-07 21:16:11 +00003737 // Forward -f options with positive and negative forms; we translate
3738 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003739 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3740 StringRef fname = A->getValue();
3741 if (!llvm::sys::fs::exists(fname))
3742 D.Diag(diag::err_drv_no_such_file) << fname;
3743 else
3744 A->render(Args, CmdArgs);
3745 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003746
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003747 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003748 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003749 CmdArgs.push_back("-fapple-kext");
3750 if (!Args.hasArg(options::OPT_fbuiltin))
3751 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003752 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003753 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003754 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003755 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003756 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003757
Nuno Lopes13c88c72009-12-16 16:59:22 +00003758 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3759 options::OPT_fno_assume_sane_operator_new))
3760 CmdArgs.push_back("-fno-assume-sane-operator-new");
3761
Daniel Dunbar4930e332009-11-17 08:07:36 +00003762 // -fblocks=0 is default.
3763 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003764 getToolChain().IsBlocksDefault()) ||
3765 (Args.hasArg(options::OPT_fgnu_runtime) &&
3766 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3767 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003768 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003769
3770 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3771 !getToolChain().hasBlocksRuntime())
3772 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003773 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003774
Richard Smithffb65082014-09-30 23:10:19 +00003775 // -fmodules enables modules (off by default).
3776 // Users can pass -fno-cxx-modules to turn off modules support for
3777 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003778 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003779 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3780 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3781 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00003782 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003783 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003784 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003785 HaveModules = true;
3786 }
3787 }
3788
Daniel Jasper07e6c402013-08-05 20:26:17 +00003789 // -fmodule-maps enables module map processing (off by default) for header
3790 // checking. It is implied by -fmodules.
3791 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3792 false)) {
3793 CmdArgs.push_back("-fmodule-maps");
3794 }
3795
Daniel Jasperac42b752013-10-21 06:34:34 +00003796 // -fmodules-decluse checks that modules used are declared so (off by
3797 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003798 if (Args.hasFlag(options::OPT_fmodules_decluse,
3799 options::OPT_fno_modules_decluse,
3800 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003801 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003802 }
3803
Daniel Jasper962b38e2014-04-11 11:47:45 +00003804 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3805 // all #included headers are part of modules.
3806 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3807 options::OPT_fno_modules_strict_decluse,
3808 false)) {
3809 CmdArgs.push_back("-fmodules-strict-decluse");
3810 }
3811
Daniel Jasperac42b752013-10-21 06:34:34 +00003812 // -fmodule-name specifies the module that is currently being built (or
3813 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00003814 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00003815
Richard Smith9887d792014-10-17 01:42:53 +00003816 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00003817 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00003818 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00003819
Richard Smithe842a472014-10-22 02:05:46 +00003820 // -fmodule-file can be used to specify files containing precompiled modules.
3821 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3822
3823 // -fmodule-cache-path specifies where our implicitly-built module files
3824 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00003825 SmallString<128> ModuleCachePath;
3826 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3827 ModuleCachePath = A->getValue();
3828 if (HaveModules) {
3829 if (C.isForDiagnostics()) {
3830 // When generating crash reports, we want to emit the modules along with
3831 // the reproduction sources, so we ignore any provided module path.
3832 ModuleCachePath = Output.getFilename();
3833 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3834 llvm::sys::path::append(ModuleCachePath, "modules");
3835 } else if (ModuleCachePath.empty()) {
3836 // No module path was provided: use the default.
3837 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3838 ModuleCachePath);
3839 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3840 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3841 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003842 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003843 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3844 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3845 }
3846
3847 // When building modules and generating crashdumps, we need to dump a module
3848 // dependency VFS alongside the output.
3849 if (HaveModules && C.isForDiagnostics()) {
3850 SmallString<128> VFSDir(Output.getFilename());
3851 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00003852 // Add the cache directory as a temp so the crash diagnostics pick it up.
3853 C.addTempFile(Args.MakeArgString(VFSDir));
3854
Justin Bognera88f0122014-06-20 22:59:50 +00003855 llvm::sys::path::append(VFSDir, "vfs");
3856 CmdArgs.push_back("-module-dependency-dir");
3857 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003858 }
3859
Richard Smith9887d792014-10-17 01:42:53 +00003860 if (HaveModules)
3861 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003862
Douglas Gregor35b04d62013-02-07 19:01:24 +00003863 // Pass through all -fmodules-ignore-macro arguments.
3864 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003865 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3866 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003867
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003868 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3869
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003870 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3871 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3872 D.Diag(diag::err_drv_argument_not_allowed_with)
3873 << A->getAsString(Args) << "-fbuild-session-timestamp";
3874
3875 llvm::sys::fs::file_status Status;
3876 if (llvm::sys::fs::status(A->getValue(), Status))
3877 D.Diag(diag::err_drv_no_such_file) << A->getValue();
NAKAMURA Takumi0f9447d2014-08-03 01:11:44 +00003878 char TimeStamp[48];
3879 snprintf(TimeStamp, sizeof(TimeStamp), "-fbuild-session-timestamp=%" PRIu64,
3880 (uint64_t)Status.getLastModificationTime().toEpochTime());
3881 CmdArgs.push_back(Args.MakeArgString(TimeStamp));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003882 }
3883
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003884 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003885 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3886 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003887 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3888
3889 Args.AddLastArg(CmdArgs,
3890 options::OPT_fmodules_validate_once_per_build_session);
3891 }
3892
Ben Langmuirdcf73862014-03-12 00:06:17 +00003893 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3894
John McCalldfea9982010-04-09 19:12:06 +00003895 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003896 if (Args.hasFlag(options::OPT_fno_access_control,
3897 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003898 false))
John McCall3155f572010-04-09 19:03:51 +00003899 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003900
Anders Carlssond470fef2010-11-21 00:09:52 +00003901 // -felide-constructors is the default.
3902 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3903 options::OPT_felide_constructors,
3904 false))
3905 CmdArgs.push_back("-fno-elide-constructors");
3906
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003907 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003908 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003909 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003910 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003911
Richard Smith52be6192012-11-05 22:04:41 +00003912 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003913 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003914 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003915 Args.getLastArg(options::OPT_mkernel,
3916 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003917 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003918 D.Diag(diag::err_drv_argument_not_allowed_with)
3919 << "-fsanitize=vptr" << NoRttiArg;
3920 }
3921 }
3922
Tony Linthicum76329bf2011-12-12 21:14:55 +00003923 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003924 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003925 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003926 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003927 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003928 CmdArgs.push_back("-fshort-enums");
3929
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003930 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003931 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003932 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003933 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003934
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003935 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003936 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003937 options::OPT_fno_threadsafe_statics))
3938 CmdArgs.push_back("-fno-threadsafe-statics");
3939
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003940 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003941 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3942 options::OPT_fno_use_cxa_atexit,
3943 !IsWindowsCygnus && !IsWindowsGNU &&
3944 getToolChain().getArch() != llvm::Triple::hexagon &&
3945 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003946 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003947 CmdArgs.push_back("-fno-use-cxa-atexit");
3948
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003949 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003950 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003951 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003952 CmdArgs.push_back("-fms-extensions");
3953
Francois Pichet1b4f1632011-09-17 04:32:15 +00003954 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003955 if (Args.hasFlag(options::OPT_fms_compatibility,
3956 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003957 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3958 options::OPT_fno_ms_extensions,
3959 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003960 CmdArgs.push_back("-fms-compatibility");
3961
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003962 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003963 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003964 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3965 Args.hasArg(options::OPT_fms_compatibility_version)) {
3966 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3967 const Arg *MSCompatibilityVersion =
3968 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003969
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003970 if (MSCVersion && MSCompatibilityVersion)
3971 D.Diag(diag::err_drv_argument_not_allowed_with)
3972 << MSCVersion->getAsString(Args)
3973 << MSCompatibilityVersion->getAsString(Args);
3974
3975 std::string Ver;
3976 if (MSCompatibilityVersion)
3977 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
3978 else if (MSCVersion)
3979 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
3980
3981 if (Ver.empty())
3982 CmdArgs.push_back("-fms-compatibility-version=17.00");
3983 else
3984 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
3985 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003986
Eric Christopher5ecce122013-02-18 00:38:31 +00003987 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003988 if (Args.hasFlag(options::OPT_fborland_extensions,
3989 options::OPT_fno_borland_extensions, false))
3990 CmdArgs.push_back("-fborland-extensions");
3991
Francois Pichet02744872011-09-01 16:38:08 +00003992 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3993 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003994 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003995 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003996 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003997
Chandler Carruthe03aa552010-04-17 20:17:31 +00003998 // -fgnu-keywords default varies depending on language; only pass if
3999 // specified.
4000 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004001 options::OPT_fno_gnu_keywords))
4002 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004003
Rafael Espindola922a6242011-06-02 17:30:53 +00004004 if (Args.hasFlag(options::OPT_fgnu89_inline,
4005 options::OPT_fno_gnu89_inline,
4006 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004007 CmdArgs.push_back("-fgnu89-inline");
4008
Chad Rosier9c76d242012-03-15 22:31:42 +00004009 if (Args.hasArg(options::OPT_fno_inline))
4010 CmdArgs.push_back("-fno-inline");
4011
Chad Rosier64d6be92012-03-06 21:17:19 +00004012 if (Args.hasArg(options::OPT_fno_inline_functions))
4013 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004014
John McCall5fb5df92012-06-20 06:18:46 +00004015 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004016
John McCall5fb5df92012-06-20 06:18:46 +00004017 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004018 // legacy is the default. Except for deployment taget of 10.5,
4019 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4020 // gets ignored silently.
4021 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004022 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4023 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004024 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004025 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004026 if (getToolChain().UseObjCMixedDispatch())
4027 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4028 else
4029 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4030 }
4031 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004032
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004033 // When ObjectiveC legacy runtime is in effect on MacOSX,
4034 // turn on the option to do Array/Dictionary subscripting
4035 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004036 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
4037 getToolChain().getTriple().isMacOSX() &&
4038 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4039 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004040 objcRuntime.isNeXTFamily())
4041 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4042
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004043 // -fencode-extended-block-signature=1 is default.
4044 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4045 CmdArgs.push_back("-fencode-extended-block-signature");
4046 }
4047
John McCall24fc0de2011-07-06 00:26:06 +00004048 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4049 // NOTE: This logic is duplicated in ToolChains.cpp.
4050 bool ARC = isObjCAutoRefCount(Args);
4051 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004052 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004053
John McCall24fc0de2011-07-06 00:26:06 +00004054 CmdArgs.push_back("-fobjc-arc");
4055
Chandler Carruth491db322011-11-04 07:34:47 +00004056 // FIXME: It seems like this entire block, and several around it should be
4057 // wrapped in isObjC, but for now we just use it here as this is where it
4058 // was being used previously.
4059 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4060 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4061 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4062 else
4063 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4064 }
4065
John McCall24fc0de2011-07-06 00:26:06 +00004066 // Allow the user to enable full exceptions code emission.
4067 // We define off for Objective-CC, on for Objective-C++.
4068 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4069 options::OPT_fno_objc_arc_exceptions,
4070 /*default*/ types::isCXX(InputType)))
4071 CmdArgs.push_back("-fobjc-arc-exceptions");
4072 }
4073
4074 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4075 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004076 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004077 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004078
John McCall24fc0de2011-07-06 00:26:06 +00004079 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4080 // takes precedence.
4081 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4082 if (!GCArg)
4083 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4084 if (GCArg) {
4085 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004086 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004087 << GCArg->getAsString(Args);
4088 } else if (getToolChain().SupportsObjCGC()) {
4089 GCArg->render(Args, CmdArgs);
4090 } else {
4091 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004092 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004093 << GCArg->getAsString(Args);
4094 }
4095 }
4096
Reid Klecknerc542d372014-06-27 17:02:02 +00004097 // Handle GCC-style exception args.
4098 if (!C.getDriver().IsCLMode())
4099 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
4100 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004101
4102 if (getToolChain().UseSjLjExceptions())
4103 CmdArgs.push_back("-fsjlj-exceptions");
4104
4105 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004106 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4107 options::OPT_fno_assume_sane_operator_new))
4108 CmdArgs.push_back("-fno-assume-sane-operator-new");
4109
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004110 // -fconstant-cfstrings is default, and may be subject to argument translation
4111 // on Darwin.
4112 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4113 options::OPT_fno_constant_cfstrings) ||
4114 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4115 options::OPT_mno_constant_cfstrings))
4116 CmdArgs.push_back("-fno-constant-cfstrings");
4117
John Thompsoned4e2952009-11-05 20:14:16 +00004118 // -fshort-wchar default varies depending on platform; only
4119 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004120 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4121 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004122 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004123
Hans Wennborg28c96312013-07-31 23:39:13 +00004124 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004125 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004126 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004127 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004128 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004129
Daniel Dunbar096ed292011-10-05 21:04:55 +00004130 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4131 // -fno-pack-struct doesn't apply to -fpack-struct=.
4132 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004133 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004134 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004135 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004136 } else if (Args.hasFlag(options::OPT_fpack_struct,
4137 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004138 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004139 }
4140
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004141 // Handle -fmax-type-align=N and -fno-type-align
4142 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4143 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4144 if (!SkipMaxTypeAlign) {
4145 std::string MaxTypeAlignStr = "-fmax-type-align=";
4146 MaxTypeAlignStr += A->getValue();
4147 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4148 }
4149 } else if (getToolChain().getTriple().isOSDarwin()) {
4150 if (!SkipMaxTypeAlign) {
4151 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4152 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4153 }
4154 }
4155
Robert Lytton0e076492013-08-13 09:43:10 +00004156 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004157 if (!Args.hasArg(options::OPT_fcommon))
4158 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004159 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004160 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004161
Daniel Dunbard18049a2009-04-07 21:16:11 +00004162 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004163 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004164 CmdArgs.push_back("-fno-common");
4165
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004166 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004167 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004168 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004169 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004170 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004171 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4172
Daniel Dunbar6358d682010-10-15 22:30:42 +00004173 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4174 if (!Args.hasFlag(options::OPT_ffor_scope,
4175 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004176 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004177 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4178
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004179 // -finput_charset=UTF-8 is default. Reject others
4180 if (Arg *inputCharset = Args.getLastArg(
4181 options::OPT_finput_charset_EQ)) {
4182 StringRef value = inputCharset->getValue();
4183 if (value != "UTF-8")
4184 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4185 }
4186
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004187 // -fexec_charset=UTF-8 is default. Reject others
4188 if (Arg *execCharset = Args.getLastArg(
4189 options::OPT_fexec_charset_EQ)) {
4190 StringRef value = execCharset->getValue();
4191 if (value != "UTF-8")
4192 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4193 }
4194
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004195 // -fcaret-diagnostics is default.
4196 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4197 options::OPT_fno_caret_diagnostics, true))
4198 CmdArgs.push_back("-fno-caret-diagnostics");
4199
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004200 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004201 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004202 options::OPT_fno_diagnostics_fixit_info))
4203 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004204
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004205 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004206 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004207 options::OPT_fno_diagnostics_show_option))
4208 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004209
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004210 if (const Arg *A =
4211 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4212 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004213 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004214 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004215
Douglas Gregor643c9222011-05-21 17:07:29 +00004216 if (const Arg *A =
4217 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4218 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004219 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004220 }
4221
Chandler Carruthb6766f02011-03-27 01:50:55 +00004222 if (Arg *A = Args.getLastArg(
4223 options::OPT_fdiagnostics_show_note_include_stack,
4224 options::OPT_fno_diagnostics_show_note_include_stack)) {
4225 if (A->getOption().matches(
4226 options::OPT_fdiagnostics_show_note_include_stack))
4227 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4228 else
4229 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4230 }
4231
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004232 // Color diagnostics are the default, unless the terminal doesn't support
4233 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004234 // Support both clang's -f[no-]color-diagnostics and gcc's
4235 // -f[no-]diagnostics-colors[=never|always|auto].
4236 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004237 for (const auto &Arg : Args) {
4238 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004239 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4240 !O.matches(options::OPT_fdiagnostics_color) &&
4241 !O.matches(options::OPT_fno_color_diagnostics) &&
4242 !O.matches(options::OPT_fno_diagnostics_color) &&
4243 !O.matches(options::OPT_fdiagnostics_color_EQ))
4244 continue;
4245
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004246 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004247 if (O.matches(options::OPT_fcolor_diagnostics) ||
4248 O.matches(options::OPT_fdiagnostics_color)) {
4249 ShowColors = Colors_On;
4250 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4251 O.matches(options::OPT_fno_diagnostics_color)) {
4252 ShowColors = Colors_Off;
4253 } else {
4254 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004255 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004256 if (value == "always")
4257 ShowColors = Colors_On;
4258 else if (value == "never")
4259 ShowColors = Colors_Off;
4260 else if (value == "auto")
4261 ShowColors = Colors_Auto;
4262 else
4263 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4264 << ("-fdiagnostics-color=" + value).str();
4265 }
4266 }
4267 if (ShowColors == Colors_On ||
4268 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004269 CmdArgs.push_back("-fcolor-diagnostics");
4270
Nico Rieck7857d462013-09-11 00:38:02 +00004271 if (Args.hasArg(options::OPT_fansi_escape_codes))
4272 CmdArgs.push_back("-fansi-escape-codes");
4273
Daniel Dunbardb097022009-06-08 21:13:54 +00004274 if (!Args.hasFlag(options::OPT_fshow_source_location,
4275 options::OPT_fno_show_source_location))
4276 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004277
Douglas Gregor643c9222011-05-21 17:07:29 +00004278 if (!Args.hasFlag(options::OPT_fshow_column,
4279 options::OPT_fno_show_column,
4280 true))
4281 CmdArgs.push_back("-fno-show-column");
4282
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004283 if (!Args.hasFlag(options::OPT_fspell_checking,
4284 options::OPT_fno_spell_checking))
4285 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004286
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004287
Chad Rosierc8e56e82012-12-05 21:08:21 +00004288 // -fno-asm-blocks is default.
4289 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4290 false))
4291 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004292
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004293 // Enable vectorization per default according to the optimization level
4294 // selected. For optimization levels that want vectorization we use the alias
4295 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004296 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004297 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004298 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004299 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004300 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004301 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004302
Chad Rosier136d67d2014-04-28 19:30:57 +00004303 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004304 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4305 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004306 options::OPT_fslp_vectorize;
4307 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004308 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004309 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004310
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004311 // -fno-slp-vectorize-aggressive is default.
4312 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004313 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004314 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004315
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004316 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4317 A->render(Args, CmdArgs);
4318
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004319 // -fdollars-in-identifiers default varies depending on platform and
4320 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004321 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004322 options::OPT_fno_dollars_in_identifiers)) {
4323 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004324 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004325 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004326 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004327 }
4328
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004329 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4330 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004331 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004332 options::OPT_fno_unit_at_a_time)) {
4333 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004334 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004335 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004336
Eli Friedman055c9702011-11-02 01:53:16 +00004337 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4338 options::OPT_fno_apple_pragma_pack, false))
4339 CmdArgs.push_back("-fapple-pragma-pack");
4340
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004341 // le32-specific flags:
4342 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4343 // by default.
4344 if (getToolChain().getArch() == llvm::Triple::le32) {
4345 CmdArgs.push_back("-fno-math-builtin");
4346 }
4347
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004348 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004349 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004350 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004351#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004352 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004353 (getToolChain().getArch() == llvm::Triple::arm ||
4354 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004355 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4356 CmdArgs.push_back("-fno-builtin-strcat");
4357 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4358 CmdArgs.push_back("-fno-builtin-strcpy");
4359 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004360#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004361
Justin Bognera88f0122014-06-20 22:59:50 +00004362 // Enable rewrite includes if the user's asked for it or if we're generating
4363 // diagnostics.
4364 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4365 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004366 if (Args.hasFlag(options::OPT_frewrite_includes,
4367 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004368 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004369 CmdArgs.push_back("-frewrite-includes");
4370
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004371 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004372 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004373 options::OPT_traditional_cpp)) {
4374 if (isa<PreprocessJobAction>(JA))
4375 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004376 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004377 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004378 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004379
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004380 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004381 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004382
4383 // Handle serialized diagnostics.
4384 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4385 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004386 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004387 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004388
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004389 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4390 CmdArgs.push_back("-fretain-comments-from-system-headers");
4391
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004392 // Forward -fcomment-block-commands to -cc1.
4393 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004394 // Forward -fparse-all-comments to -cc1.
4395 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004396
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004397 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4398 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004399 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004400 bool OptDisabled = false;
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004401 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4402 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004403 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004404
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004405 // We translate this by hand to the -cc1 argument, since nightly test uses
4406 // it and developers have been trained to spell it with -mllvm.
Bob Wilson23a55f12014-12-21 07:00:00 +00004407 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004408 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004409 OptDisabled = true;
4410 } else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004411 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004412 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004413
Bob Wilson23a55f12014-12-21 07:00:00 +00004414 // With -save-temps, we want to save the unoptimized bitcode output from the
4415 // CompileJobAction, so disable optimizations if they are not already
4416 // disabled.
4417 if (Args.hasArg(options::OPT_save_temps) && !OptDisabled &&
4418 isa<CompileJobAction>(JA))
4419 CmdArgs.push_back("-disable-llvm-optzns");
4420
Daniel Dunbard67a3222009-03-30 06:36:42 +00004421 if (Output.getType() == types::TY_Dependencies) {
4422 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004423 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004424 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004425 CmdArgs.push_back(Output.getFilename());
4426 } else {
4427 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004428 }
4429
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004430 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004431 addDashXForInput(Args, II, CmdArgs);
4432
Daniel Dunbarb440f562010-08-02 02:38:21 +00004433 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004434 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004435 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004436 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004437 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004438
Chris Lattnere9d7d782009-11-03 19:50:27 +00004439 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4440
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004441 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004442
4443 // Optionally embed the -cc1 level arguments into the debug info, for build
4444 // analysis.
4445 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004446 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004447 for (const auto &Arg : Args)
4448 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004449
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004450 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004451 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004452 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004453 SmallString<128> EscapedArg;
4454 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004455 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004456 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004457 }
4458 CmdArgs.push_back("-dwarf-debug-flags");
4459 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4460 }
4461
Eric Christopherd3804002013-02-22 20:12:52 +00004462 // Add the split debug info name to the command lines here so we
4463 // can propagate it to the backend.
4464 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004465 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004466 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4467 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004468 const char *SplitDwarfOut;
4469 if (SplitDwarf) {
4470 CmdArgs.push_back("-split-dwarf-file");
4471 SplitDwarfOut = SplitDebugName(Args, Inputs);
4472 CmdArgs.push_back(SplitDwarfOut);
4473 }
4474
4475 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004476 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004477 Output.getType() == types::TY_Object &&
4478 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004479 auto CLCommand =
4480 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4481 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4482 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004483 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004484 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004485 }
4486
Daniel Dunbar17731772009-03-23 19:03:36 +00004487
Eric Christopherf1545832013-02-22 23:50:16 +00004488 // Handle the debug info splitting at object creation time if we're
4489 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004490 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004491 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004492 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004493
Roman Divacky178e01602011-02-10 16:52:03 +00004494 if (Arg *A = Args.getLastArg(options::OPT_pg))
4495 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004496 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004497 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004498
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004499 // Claim some arguments which clang supports automatically.
4500
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004501 // -fpch-preprocess is used with gcc to add a special marker in the output to
4502 // include the PCH file. Clang's PTH solution is completely transparent, so we
4503 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004504 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004505
Daniel Dunbar17731772009-03-23 19:03:36 +00004506 // Claim some arguments which clang doesn't support, but we don't
4507 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004508 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4509 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004510
Rafael Espindolab0092d72013-09-04 19:37:35 +00004511 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004512 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004513}
4514
John McCall5fb5df92012-06-20 06:18:46 +00004515/// Add options related to the Objective-C runtime/ABI.
4516///
4517/// Returns true if the runtime is non-fragile.
4518ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4519 ArgStringList &cmdArgs,
4520 RewriteKind rewriteKind) const {
4521 // Look for the controlling runtime option.
4522 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4523 options::OPT_fgnu_runtime,
4524 options::OPT_fobjc_runtime_EQ);
4525
4526 // Just forward -fobjc-runtime= to the frontend. This supercedes
4527 // options about fragility.
4528 if (runtimeArg &&
4529 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4530 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004531 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004532 if (runtime.tryParse(value)) {
4533 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4534 << value;
4535 }
4536
4537 runtimeArg->render(args, cmdArgs);
4538 return runtime;
4539 }
4540
4541 // Otherwise, we'll need the ABI "version". Version numbers are
4542 // slightly confusing for historical reasons:
4543 // 1 - Traditional "fragile" ABI
4544 // 2 - Non-fragile ABI, version 1
4545 // 3 - Non-fragile ABI, version 2
4546 unsigned objcABIVersion = 1;
4547 // If -fobjc-abi-version= is present, use that to set the version.
4548 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004549 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004550 if (value == "1")
4551 objcABIVersion = 1;
4552 else if (value == "2")
4553 objcABIVersion = 2;
4554 else if (value == "3")
4555 objcABIVersion = 3;
4556 else
4557 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4558 << value;
4559 } else {
4560 // Otherwise, determine if we are using the non-fragile ABI.
4561 bool nonFragileABIIsDefault =
4562 (rewriteKind == RK_NonFragile ||
4563 (rewriteKind == RK_None &&
4564 getToolChain().IsObjCNonFragileABIDefault()));
4565 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4566 options::OPT_fno_objc_nonfragile_abi,
4567 nonFragileABIIsDefault)) {
4568 // Determine the non-fragile ABI version to use.
4569#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4570 unsigned nonFragileABIVersion = 1;
4571#else
4572 unsigned nonFragileABIVersion = 2;
4573#endif
4574
4575 if (Arg *abiArg = args.getLastArg(
4576 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004577 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004578 if (value == "1")
4579 nonFragileABIVersion = 1;
4580 else if (value == "2")
4581 nonFragileABIVersion = 2;
4582 else
4583 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4584 << value;
4585 }
4586
4587 objcABIVersion = 1 + nonFragileABIVersion;
4588 } else {
4589 objcABIVersion = 1;
4590 }
4591 }
4592
4593 // We don't actually care about the ABI version other than whether
4594 // it's non-fragile.
4595 bool isNonFragile = objcABIVersion != 1;
4596
4597 // If we have no runtime argument, ask the toolchain for its default runtime.
4598 // However, the rewriter only really supports the Mac runtime, so assume that.
4599 ObjCRuntime runtime;
4600 if (!runtimeArg) {
4601 switch (rewriteKind) {
4602 case RK_None:
4603 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4604 break;
4605 case RK_Fragile:
4606 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4607 break;
4608 case RK_NonFragile:
4609 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4610 break;
4611 }
4612
4613 // -fnext-runtime
4614 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4615 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004616 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004617 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4618
4619 // Otherwise, build for a generic macosx port.
4620 } else {
4621 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4622 }
4623
4624 // -fgnu-runtime
4625 } else {
4626 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004627 // Legacy behaviour is to target the gnustep runtime if we are i
4628 // non-fragile mode or the GCC runtime in fragile mode.
4629 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004630 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004631 else
4632 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004633 }
4634
4635 cmdArgs.push_back(args.MakeArgString(
4636 "-fobjc-runtime=" + runtime.getAsString()));
4637 return runtime;
4638}
4639
Reid Klecknerc542d372014-06-27 17:02:02 +00004640static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4641 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4642 I += HaveDash;
4643 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004644}
Reid Klecknerc542d372014-06-27 17:02:02 +00004645
4646struct EHFlags {
4647 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4648 bool Synch;
4649 bool Asynch;
4650 bool NoExceptC;
4651};
4652
4653/// /EH controls whether to run destructor cleanups when exceptions are
4654/// thrown. There are three modifiers:
4655/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4656/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4657/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4658/// - c: Assume that extern "C" functions are implicitly noexcept. This
4659/// modifier is an optimization, so we ignore it for now.
4660/// The default is /EHs-c-, meaning cleanups are disabled.
4661static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4662 EHFlags EH;
4663 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4664 for (auto EHVal : EHArgs) {
4665 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4666 switch (EHVal[I]) {
4667 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4668 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4669 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4670 default: break;
4671 }
4672 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4673 break;
4674 }
4675 }
4676 return EH;
4677}
4678
Hans Wennborg75958c42013-08-08 00:17:41 +00004679void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4680 unsigned RTOptionID = options::OPT__SLASH_MT;
4681
Hans Wennborgf1a74252013-09-10 20:18:04 +00004682 if (Args.hasArg(options::OPT__SLASH_LDd))
4683 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4684 // but defining _DEBUG is sticky.
4685 RTOptionID = options::OPT__SLASH_MTd;
4686
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004687 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004688 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004689
Hans Wennborg75958c42013-08-08 00:17:41 +00004690 switch(RTOptionID) {
4691 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004692 if (Args.hasArg(options::OPT__SLASH_LDd))
4693 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004694 CmdArgs.push_back("-D_MT");
4695 CmdArgs.push_back("-D_DLL");
4696 CmdArgs.push_back("--dependent-lib=msvcrt");
4697 break;
4698 case options::OPT__SLASH_MDd:
4699 CmdArgs.push_back("-D_DEBUG");
4700 CmdArgs.push_back("-D_MT");
4701 CmdArgs.push_back("-D_DLL");
4702 CmdArgs.push_back("--dependent-lib=msvcrtd");
4703 break;
4704 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004705 if (Args.hasArg(options::OPT__SLASH_LDd))
4706 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004707 CmdArgs.push_back("-D_MT");
4708 CmdArgs.push_back("--dependent-lib=libcmt");
4709 break;
4710 case options::OPT__SLASH_MTd:
4711 CmdArgs.push_back("-D_DEBUG");
4712 CmdArgs.push_back("-D_MT");
4713 CmdArgs.push_back("--dependent-lib=libcmtd");
4714 break;
4715 default:
4716 llvm_unreachable("Unexpected option ID.");
4717 }
4718
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004719 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4720 // users want. The /Za flag to cl.exe turns this off, but it's not
4721 // implemented in clang.
4722 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004723
Hans Wennborg8858a032014-07-21 23:42:07 +00004724 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4725 // would produce interleaved output, so ignore /showIncludes in such cases.
4726 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4727 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4728 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004729
David Majnemerf6072342014-07-01 22:24:56 +00004730 // This controls whether or not we emit RTTI data for polymorphic types.
4731 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4732 /*default=*/false))
4733 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004734
Reid Klecknerc542d372014-06-27 17:02:02 +00004735 const Driver &D = getToolChain().getDriver();
4736 EHFlags EH = parseClangCLEHFlags(D, Args);
4737 // FIXME: Do something with NoExceptC.
4738 if (EH.Synch || EH.Asynch) {
4739 CmdArgs.push_back("-fexceptions");
4740 CmdArgs.push_back("-fcxx-exceptions");
4741 }
4742
Hans Wennborge50cec32014-06-13 20:59:54 +00004743 // /EP should expand to -E -P.
4744 if (Args.hasArg(options::OPT__SLASH_EP)) {
4745 CmdArgs.push_back("-E");
4746 CmdArgs.push_back("-P");
4747 }
4748
David Majnemer86c318f2014-02-11 21:05:00 +00004749 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4750 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4751 if (MostGeneralArg && BestCaseArg)
4752 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4753 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4754
4755 if (MostGeneralArg) {
4756 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4757 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4758 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4759
4760 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4761 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4762 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4763 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4764 << FirstConflict->getAsString(Args)
4765 << SecondConflict->getAsString(Args);
4766
4767 if (SingleArg)
4768 CmdArgs.push_back("-fms-memptr-rep=single");
4769 else if (MultipleArg)
4770 CmdArgs.push_back("-fms-memptr-rep=multiple");
4771 else
4772 CmdArgs.push_back("-fms-memptr-rep=virtual");
4773 }
4774
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004775 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4776 A->render(Args, CmdArgs);
4777
Hans Wennborg81f74482013-09-10 01:07:07 +00004778 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4779 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004780 if (Args.hasArg(options::OPT__SLASH_fallback))
4781 CmdArgs.push_back("msvc-fallback");
4782 else
4783 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004784 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004785}
4786
Hans Wennborg1da044a2014-06-26 19:59:02 +00004787visualstudio::Compile *Clang::getCLFallback() const {
4788 if (!CLFallback)
4789 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4790 return CLFallback.get();
4791}
4792
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004793void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004794 const InputInfo &Output,
4795 const InputInfoList &Inputs,
4796 const ArgList &Args,
4797 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004798 ArgStringList CmdArgs;
4799
4800 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4801 const InputInfo &Input = Inputs[0];
4802
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004803 // Don't warn about "clang -w -c foo.s"
4804 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004805 // and "clang -emit-llvm -c foo.s"
4806 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004807
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004808 // Invoke ourselves in -cc1as mode.
4809 //
4810 // FIXME: Implement custom jobs for internal actions.
4811 CmdArgs.push_back("-cc1as");
4812
4813 // Add the "effective" target triple.
4814 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004815 std::string TripleStr =
4816 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004817 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4818
4819 // Set the output mode, we currently only expect to be used as a real
4820 // assembler.
4821 CmdArgs.push_back("-filetype");
4822 CmdArgs.push_back("obj");
4823
Eric Christopher45f2e712012-12-18 00:31:10 +00004824 // Set the main file name, so that debug info works even with
4825 // -save-temps or preprocessed assembly.
4826 CmdArgs.push_back("-main-file-name");
4827 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4828
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004829 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004830 const llvm::Triple &Triple = getToolChain().getTriple();
4831 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004832 if (!CPU.empty()) {
4833 CmdArgs.push_back("-target-cpu");
4834 CmdArgs.push_back(Args.MakeArgString(CPU));
4835 }
4836
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004837 // Add the target features
4838 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004839 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004840
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004841 // Ignore explicit -force_cpusubtype_ALL option.
4842 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004843
Eric Christopherfc3ee562012-01-10 00:38:01 +00004844 // Determine the original source input.
4845 const Action *SourceAction = &JA;
4846 while (SourceAction->getKind() != Action::InputClass) {
4847 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4848 SourceAction = SourceAction->getInputs()[0];
4849 }
4850
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004851 // Forward -g and handle debug info related flags, assuming we are dealing
4852 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004853 if (SourceAction->getType() == types::TY_Asm ||
4854 SourceAction->getType() == types::TY_PP_Asm) {
4855 Args.ClaimAllArgs(options::OPT_g_Group);
4856 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4857 if (!A->getOption().matches(options::OPT_g0))
4858 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004859
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004860 if (Args.hasArg(options::OPT_gdwarf_2))
4861 CmdArgs.push_back("-gdwarf-2");
4862 if (Args.hasArg(options::OPT_gdwarf_3))
4863 CmdArgs.push_back("-gdwarf-3");
4864 if (Args.hasArg(options::OPT_gdwarf_4))
4865 CmdArgs.push_back("-gdwarf-4");
4866
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004867 // Add the -fdebug-compilation-dir flag if needed.
4868 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004869
4870 // Set the AT_producer to the clang version when using the integrated
4871 // assembler on assembly source files.
4872 CmdArgs.push_back("-dwarf-debug-producer");
4873 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004874 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004875
4876 // Optionally embed the -cc1as level arguments into the debug info, for build
4877 // analysis.
4878 if (getToolChain().UseDwarfDebugFlags()) {
4879 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004880 for (const auto &Arg : Args)
4881 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004882
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004883 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004884 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4885 Flags += Exec;
4886 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004887 SmallString<128> EscapedArg;
4888 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00004889 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004890 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00004891 }
4892 CmdArgs.push_back("-dwarf-debug-flags");
4893 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4894 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004895
4896 // FIXME: Add -static support, once we have it.
4897
David Blaikie372d9502014-01-17 03:17:40 +00004898 // Consume all the warning flags. Usually this would be handled more
4899 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4900 // doesn't handle that so rather than warning about unused flags that are
4901 // actually used, we'll lie by omission instead.
4902 // FIXME: Stop lying and consume only the appropriate driver flags
4903 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4904 ie = Args.filtered_end();
4905 it != ie; ++it)
4906 (*it)->claim();
4907
David Blaikie9260ed62013-07-25 21:19:01 +00004908 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4909 getToolChain().getDriver());
4910
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004911 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004912
4913 assert(Output.isFilename() && "Unexpected lipo output.");
4914 CmdArgs.push_back("-o");
4915 CmdArgs.push_back(Output.getFilename());
4916
Daniel Dunbarb440f562010-08-02 02:38:21 +00004917 assert(Input.isFilename() && "Invalid input.");
4918 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004919
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004920 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00004921 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004922
4923 // Handle the debug info splitting at object creation time if we're
4924 // creating an object.
4925 // TODO: Currently only works on linux with newer objcopy.
4926 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004927 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004928 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4929 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004930}
4931
Reid Kleckner0290c9c2014-09-15 17:45:39 +00004932void GnuTool::anchor() {}
4933
Daniel Dunbara3246a02009-03-18 08:07:30 +00004934void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004935 const InputInfo &Output,
4936 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004937 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004938 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004939 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004940 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004941
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004942 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004943 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004944 // Don't forward any -g arguments to assembly steps.
4945 if (isa<AssembleJobAction>(JA) &&
4946 A->getOption().matches(options::OPT_g_Group))
4947 continue;
4948
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004949 // Don't forward any -W arguments to assembly and link steps.
4950 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4951 A->getOption().matches(options::OPT_W_Group))
4952 continue;
4953
Daniel Dunbar2da02722009-03-19 07:55:12 +00004954 // It is unfortunate that we have to claim here, as this means
4955 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004956 // platforms using a generic gcc, even if we are just using gcc
4957 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004958 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004959 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004960 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004961 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004962
Daniel Dunbar4e295052010-01-25 22:35:08 +00004963 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004964
4965 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004966 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004967 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004968 CmdArgs.push_back(
4969 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004970 }
4971
Daniel Dunbar5716d872009-05-02 21:41:52 +00004972 // Try to force gcc to match the tool chain we want, if we recognize
4973 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004974 //
4975 // FIXME: The triple class should directly provide the information we want
4976 // here.
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004977 llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004978 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004979 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004980 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4981 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004982 CmdArgs.push_back("-m64");
4983
Daniel Dunbarb440f562010-08-02 02:38:21 +00004984 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004985 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004986 CmdArgs.push_back(Output.getFilename());
4987 } else {
4988 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004989 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004990 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004991
Tony Linthicum76329bf2011-12-12 21:14:55 +00004992 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4993 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004994
4995 // Only pass -x if gcc will understand it; otherwise hope gcc
4996 // understands the suffix correctly. The main use case this would go
4997 // wrong in is for linker inputs if they happened to have an odd
4998 // suffix; really the only way to get this to happen is a command
4999 // like '-x foobar a.c' which will treat a.c like a linker input.
5000 //
5001 // FIXME: For the linker case specifically, can we safely convert
5002 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005003 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005004 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005005 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5006 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005007 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005008 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005009 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005010 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005011 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005012 else if (II.getType() == types::TY_ModuleFile)
5013 D.Diag(diag::err_drv_no_module_support)
5014 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005015
Daniel Dunbara3246a02009-03-18 08:07:30 +00005016 if (types::canTypeBeUserSpecified(II.getType())) {
5017 CmdArgs.push_back("-x");
5018 CmdArgs.push_back(types::getTypeName(II.getType()));
5019 }
5020
Daniel Dunbarb440f562010-08-02 02:38:21 +00005021 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005022 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005023 else {
5024 const Arg &A = II.getInputArg();
5025
5026 // Reverse translate some rewritten options.
5027 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5028 CmdArgs.push_back("-lstdc++");
5029 continue;
5030 }
5031
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005032 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005033 A.render(Args, CmdArgs);
5034 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005035 }
5036
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005037 const std::string customGCCName = D.getCCCGenericGCCName();
5038 const char *GCCName;
5039 if (!customGCCName.empty())
5040 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005041 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005042 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005043 } else
5044 GCCName = "gcc";
5045
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005046 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005047 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005048 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005049}
5050
Daniel Dunbar4e295052010-01-25 22:35:08 +00005051void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5052 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005053 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005054}
5055
Daniel Dunbar4e295052010-01-25 22:35:08 +00005056void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5057 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005058 const Driver &D = getToolChain().getDriver();
5059
Daniel Dunbar4e295052010-01-25 22:35:08 +00005060 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005061 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
5062 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00005063 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005064 else {
5065 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005066 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005067 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005068
Daniel Dunbar4e295052010-01-25 22:35:08 +00005069 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005070 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005071}
5072
Daniel Dunbar4e295052010-01-25 22:35:08 +00005073void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5074 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005075 // The types are (hopefully) good enough.
5076}
5077
Tony Linthicum76329bf2011-12-12 21:14:55 +00005078// Hexagon tools start.
5079void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5080 ArgStringList &CmdArgs) const {
5081
5082}
5083void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5084 const InputInfo &Output,
5085 const InputInfoList &Inputs,
5086 const ArgList &Args,
5087 const char *LinkingOutput) const {
5088
5089 const Driver &D = getToolChain().getDriver();
5090 ArgStringList CmdArgs;
5091
5092 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005093 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005094 CmdArgs.push_back(Args.MakeArgString(MarchString));
5095
5096 RenderExtraToolArgs(JA, CmdArgs);
5097
5098 if (Output.isFilename()) {
5099 CmdArgs.push_back("-o");
5100 CmdArgs.push_back(Output.getFilename());
5101 } else {
5102 assert(Output.isNothing() && "Unexpected output");
5103 CmdArgs.push_back("-fsyntax-only");
5104 }
5105
Matthew Curtise8f80a12012-12-06 17:49:03 +00005106 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5107 if (!SmallDataThreshold.empty())
5108 CmdArgs.push_back(
5109 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005110
Matthew Curtise5df3812012-12-07 17:23:04 +00005111 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5112 options::OPT_Xassembler);
5113
Tony Linthicum76329bf2011-12-12 21:14:55 +00005114 // Only pass -x if gcc will understand it; otherwise hope gcc
5115 // understands the suffix correctly. The main use case this would go
5116 // wrong in is for linker inputs if they happened to have an odd
5117 // suffix; really the only way to get this to happen is a command
5118 // like '-x foobar a.c' which will treat a.c like a linker input.
5119 //
5120 // FIXME: For the linker case specifically, can we safely convert
5121 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005122 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005123 // Don't try to pass LLVM or AST inputs to a generic gcc.
5124 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5125 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5126 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5127 << getToolChain().getTripleString();
5128 else if (II.getType() == types::TY_AST)
5129 D.Diag(clang::diag::err_drv_no_ast_support)
5130 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005131 else if (II.getType() == types::TY_ModuleFile)
5132 D.Diag(diag::err_drv_no_module_support)
5133 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005134
5135 if (II.isFilename())
5136 CmdArgs.push_back(II.getFilename());
5137 else
5138 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5139 II.getInputArg().render(Args, CmdArgs);
5140 }
5141
5142 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005143 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005144 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005145}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005146
Tony Linthicum76329bf2011-12-12 21:14:55 +00005147void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5148 ArgStringList &CmdArgs) const {
5149 // The types are (hopefully) good enough.
5150}
5151
5152void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5153 const InputInfo &Output,
5154 const InputInfoList &Inputs,
5155 const ArgList &Args,
5156 const char *LinkingOutput) const {
5157
Matthew Curtise689b052012-12-06 15:46:07 +00005158 const toolchains::Hexagon_TC& ToolChain =
5159 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5160 const Driver &D = ToolChain.getDriver();
5161
Tony Linthicum76329bf2011-12-12 21:14:55 +00005162 ArgStringList CmdArgs;
5163
Matthew Curtise689b052012-12-06 15:46:07 +00005164 //----------------------------------------------------------------------------
5165 //
5166 //----------------------------------------------------------------------------
5167 bool hasStaticArg = Args.hasArg(options::OPT_static);
5168 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005169 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005170 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5171 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5172 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5173 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005174
Matthew Curtise689b052012-12-06 15:46:07 +00005175 //----------------------------------------------------------------------------
5176 // Silence warnings for various options
5177 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005178
Matthew Curtise689b052012-12-06 15:46:07 +00005179 Args.ClaimAllArgs(options::OPT_g_Group);
5180 Args.ClaimAllArgs(options::OPT_emit_llvm);
5181 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5182 // handled somewhere else.
5183 Args.ClaimAllArgs(options::OPT_static_libgcc);
5184
5185 //----------------------------------------------------------------------------
5186 //
5187 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005188 for (const auto &Opt : ToolChain.ExtraOpts)
5189 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005190
Matthew Curtisf10a5952012-12-06 14:16:43 +00005191 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5192 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005193
Matthew Curtise689b052012-12-06 15:46:07 +00005194 if (buildingLib) {
5195 CmdArgs.push_back("-shared");
5196 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5197 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005198 }
5199
Matthew Curtise689b052012-12-06 15:46:07 +00005200 if (hasStaticArg)
5201 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005202
Matthew Curtise8f80a12012-12-06 17:49:03 +00005203 if (buildPIE && !buildingLib)
5204 CmdArgs.push_back("-pie");
5205
5206 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5207 if (!SmallDataThreshold.empty()) {
5208 CmdArgs.push_back(
5209 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5210 }
5211
Matthew Curtise689b052012-12-06 15:46:07 +00005212 //----------------------------------------------------------------------------
5213 //
5214 //----------------------------------------------------------------------------
5215 CmdArgs.push_back("-o");
5216 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005217
Matthew Curtise689b052012-12-06 15:46:07 +00005218 const std::string MarchSuffix = "/" + MarchString;
5219 const std::string G0Suffix = "/G0";
5220 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005221 const std::string RootDir =
5222 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005223 const std::string StartFilesDir = RootDir
5224 + "hexagon/lib"
5225 + (buildingLib
5226 ? MarchG0Suffix : MarchSuffix);
5227
5228 //----------------------------------------------------------------------------
5229 // moslib
5230 //----------------------------------------------------------------------------
5231 std::vector<std::string> oslibs;
5232 bool hasStandalone= false;
5233
5234 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5235 ie = Args.filtered_end(); it != ie; ++it) {
5236 (*it)->claim();
5237 oslibs.push_back((*it)->getValue());
5238 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005239 }
Matthew Curtise689b052012-12-06 15:46:07 +00005240 if (oslibs.empty()) {
5241 oslibs.push_back("standalone");
5242 hasStandalone = true;
5243 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005244
Matthew Curtise689b052012-12-06 15:46:07 +00005245 //----------------------------------------------------------------------------
5246 // Start Files
5247 //----------------------------------------------------------------------------
5248 if (incStdLib && incStartFiles) {
5249
5250 if (!buildingLib) {
5251 if (hasStandalone) {
5252 CmdArgs.push_back(
5253 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5254 }
5255 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5256 }
5257 std::string initObj = useShared ? "/initS.o" : "/init.o";
5258 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5259 }
5260
5261 //----------------------------------------------------------------------------
5262 // Library Search Paths
5263 //----------------------------------------------------------------------------
5264 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005265 for (const auto &LibPath : LibPaths)
5266 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005267
5268 //----------------------------------------------------------------------------
5269 //
5270 //----------------------------------------------------------------------------
5271 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5272 Args.AddAllArgs(CmdArgs, options::OPT_e);
5273 Args.AddAllArgs(CmdArgs, options::OPT_s);
5274 Args.AddAllArgs(CmdArgs, options::OPT_t);
5275 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5276
5277 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5278
5279 //----------------------------------------------------------------------------
5280 // Libraries
5281 //----------------------------------------------------------------------------
5282 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005283 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005284 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5285 CmdArgs.push_back("-lm");
5286 }
5287
5288 CmdArgs.push_back("--start-group");
5289
5290 if (!buildingLib) {
5291 for(std::vector<std::string>::iterator i = oslibs.begin(),
5292 e = oslibs.end(); i != e; ++i)
5293 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5294 CmdArgs.push_back("-lc");
5295 }
5296 CmdArgs.push_back("-lgcc");
5297
5298 CmdArgs.push_back("--end-group");
5299 }
5300
5301 //----------------------------------------------------------------------------
5302 // End files
5303 //----------------------------------------------------------------------------
5304 if (incStdLib && incStartFiles) {
5305 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5306 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5307 }
5308
5309 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005310 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5311 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005312}
5313// Hexagon tools end.
5314
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005315/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005316const char *arm::getARMCPUForMArch(const ArgList &Args,
5317 const llvm::Triple &Triple) {
5318 StringRef MArch;
5319 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5320 // Otherwise, if we have -march= choose the base CPU for that arch.
5321 MArch = A->getValue();
5322 } else {
5323 // Otherwise, use the Arch from the triple.
5324 MArch = Triple.getArchName();
5325 }
5326
5327 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005328 if (MArch == "native") {
5329 std::string CPU = llvm::sys::getHostCPUName();
5330 if (CPU != "generic") {
5331 // Translate the native cpu into the architecture. The switch below will
5332 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005333 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005334 }
5335 }
5336
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005337 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005338}
5339
5340/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005341StringRef arm::getARMTargetCPU(const ArgList &Args,
5342 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005343 // FIXME: Warn on inconsistent use of -mcpu and -march.
5344 // If we have -mcpu=, use that.
5345 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5346 StringRef MCPU = A->getValue();
5347 // Handle -mcpu=native.
5348 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005349 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005350 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005351 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005352 }
5353
5354 return getARMCPUForMArch(Args, Triple);
5355}
5356
5357/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5358/// CPU.
5359//
5360// FIXME: This is redundant with -mcpu, why does LLVM use this.
5361// FIXME: tblgen this, or kill it!
5362const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5363 return llvm::StringSwitch<const char *>(CPU)
5364 .Case("strongarm", "v4")
5365 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5366 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5367 .Cases("arm920", "arm920t", "arm922t", "v4t")
5368 .Cases("arm940t", "ep9312","v4t")
5369 .Cases("arm10tdmi", "arm1020t", "v5")
5370 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5371 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5372 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5373 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5374 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5375 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Charlie Turner2919cbd2014-11-06 14:59:30 +00005376 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
Renato Golin5886bc32014-10-13 10:22:48 +00005377 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005378 .Cases("cortex-r4", "cortex-r5", "v7r")
5379 .Case("cortex-m0", "v6m")
5380 .Case("cortex-m3", "v7m")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00005381 .Cases("cortex-m4", "cortex-m7", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005382 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005383 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005384 .Cases("cortex-a53", "cortex-a57", "v8")
5385 .Default("");
5386}
5387
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005388bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5389 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5390 return A && (A->getValue() == StringRef(Value));
5391}
5392
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005393bool mips::isUCLibc(const ArgList &Args) {
5394 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005395 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005396}
5397
Daniel Sanders2bf13662014-07-10 14:40:57 +00005398bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005399 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5400 return llvm::StringSwitch<bool>(NaNArg->getValue())
5401 .Case("2008", true)
5402 .Case("legacy", false)
5403 .Default(false);
5404
5405 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005406 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5407 .Cases("mips32r6", "mips64r6", true)
5408 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005409
5410 return false;
5411}
5412
Daniel Sanders379d44b2014-07-16 11:52:23 +00005413bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5414 StringRef ABIName) {
5415 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005416 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005417 return false;
5418
5419 if (ABIName != "32")
5420 return false;
5421
5422 return llvm::StringSwitch<bool>(CPUName)
5423 .Cases("mips2", "mips3", "mips4", "mips5", true)
5424 .Cases("mips32", "mips32r2", true)
5425 .Cases("mips64", "mips64r2", true)
5426 .Default(false);
5427}
5428
Tim Northover157d9112014-01-16 08:48:16 +00005429llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005430 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5431 // archs which Darwin doesn't use.
5432
5433 // The matching this routine does is fairly pointless, since it is neither the
5434 // complete architecture list, nor a reasonable subset. The problem is that
5435 // historically the driver driver accepts this and also ties its -march=
5436 // handling to the architecture name, so we need to be careful before removing
5437 // support for it.
5438
5439 // This code must be kept in sync with Clang's Darwin specific argument
5440 // translation.
5441
5442 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5443 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5444 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5445 .Case("ppc64", llvm::Triple::ppc64)
5446 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5447 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5448 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005449 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005450 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005451 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005452 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005453 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005454 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005455 .Case("r600", llvm::Triple::r600)
5456 .Case("nvptx", llvm::Triple::nvptx)
5457 .Case("nvptx64", llvm::Triple::nvptx64)
5458 .Case("amdil", llvm::Triple::amdil)
5459 .Case("spir", llvm::Triple::spir)
5460 .Default(llvm::Triple::UnknownArch);
5461}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005462
Tim Northover157d9112014-01-16 08:48:16 +00005463void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5464 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5465 T.setArch(Arch);
5466
5467 if (Str == "x86_64h")
5468 T.setArchName(Str);
5469 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5470 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005471 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005472 }
5473}
5474
Bob Wilsondecc03e2012-11-23 06:14:39 +00005475const char *Clang::getBaseInputName(const ArgList &Args,
5476 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005477 return Args.MakeArgString(
5478 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005479}
5480
Bob Wilsondecc03e2012-11-23 06:14:39 +00005481const char *Clang::getBaseInputStem(const ArgList &Args,
5482 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005483 const char *Str = getBaseInputName(Args, Inputs);
5484
Chris Lattner906bb902011-01-16 08:14:11 +00005485 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005486 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005487
5488 return Str;
5489}
5490
Bob Wilsondecc03e2012-11-23 06:14:39 +00005491const char *Clang::getDependencyFileName(const ArgList &Args,
5492 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005493 // FIXME: Think about this more.
5494 std::string Res;
5495
5496 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005497 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005498 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005499 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005500 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005501 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005502 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005503}
5504
Daniel Dunbarbe220842009-03-20 16:06:39 +00005505void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005506 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005507 const InputInfoList &Inputs,
5508 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005509 const char *LinkingOutput) const {
5510 ArgStringList CmdArgs;
5511
5512 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5513 const InputInfo &Input = Inputs[0];
5514
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005515 // Determine the original source input.
5516 const Action *SourceAction = &JA;
5517 while (SourceAction->getKind() != Action::InputClass) {
5518 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5519 SourceAction = SourceAction->getInputs()[0];
5520 }
5521
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005522 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005523 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005524 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5525 // FIXME: at run-time detect assembler capabilities or rely on version
5526 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005527 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005528 const llvm::Triple &T(getToolChain().getTriple());
5529 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005530 CmdArgs.push_back("-Q");
5531 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005532
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005533 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005534 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005535 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005536 if (Args.hasArg(options::OPT_gstabs))
5537 CmdArgs.push_back("--gstabs");
5538 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005539 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005540 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005541
Daniel Dunbarbe220842009-03-20 16:06:39 +00005542 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005543 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005544
Daniel Dunbar6d484762010-07-22 01:47:22 +00005545 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005546 if (getToolChain().getArch() == llvm::Triple::x86 ||
5547 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005548 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5549 CmdArgs.push_back("-force_cpusubtype_ALL");
5550
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005551 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005552 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005553 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005554 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005555 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005556 CmdArgs.push_back("-static");
5557
Daniel Dunbarbe220842009-03-20 16:06:39 +00005558 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5559 options::OPT_Xassembler);
5560
5561 assert(Output.isFilename() && "Unexpected lipo output.");
5562 CmdArgs.push_back("-o");
5563 CmdArgs.push_back(Output.getFilename());
5564
Daniel Dunbarb440f562010-08-02 02:38:21 +00005565 assert(Input.isFilename() && "Invalid input.");
5566 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005567
5568 // asm_final spec is empty.
5569
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005570 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005571 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005572 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005573}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005574
Tim Northover157d9112014-01-16 08:48:16 +00005575void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005576
Tim Northover157d9112014-01-16 08:48:16 +00005577void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5578 ArgStringList &CmdArgs) const {
5579 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005580
Daniel Dunbarc1964212009-03-26 16:23:12 +00005581 // Derived from darwin_arch spec.
5582 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005583 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005584
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005585 // FIXME: Is this needed anymore?
5586 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005587 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005588}
5589
Bill Wendling3b2000f2012-10-02 18:02:50 +00005590bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5591 // We only need to generate a temp path for LTO if we aren't compiling object
5592 // files. When compiling source files, we run 'dsymutil' after linking. We
5593 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005594 for (const auto &Input : Inputs)
5595 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005596 return true;
5597
5598 return false;
5599}
5600
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005601void darwin::Link::AddLinkArgs(Compilation &C,
5602 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005603 ArgStringList &CmdArgs,
5604 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005605 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005606 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005607
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005608 unsigned Version[3] = { 0, 0, 0 };
5609 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5610 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005611 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005612 Version[1], Version[2], HadExtra) ||
5613 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005614 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005615 << A->getAsString(Args);
5616 }
5617
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005618 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005619 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005620 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5621 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005622
Bob Wilson3d27dad2013-08-02 22:25:34 +00005623 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5624 CmdArgs.push_back("-export_dynamic");
5625
Bill Wendling313b6bf2012-11-16 23:03:00 +00005626 // If we are using LTO, then automatically create a temporary file path for
5627 // the linker to use, so that it's lifetime will extend past a possible
5628 // dsymutil step.
5629 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5630 const char *TmpPath = C.getArgs().MakeArgString(
5631 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5632 C.addTempFile(TmpPath);
5633 CmdArgs.push_back("-object_path_lto");
5634 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005635 }
5636
Daniel Dunbarc1964212009-03-26 16:23:12 +00005637 // Derived from the "link" spec.
5638 Args.AddAllArgs(CmdArgs, options::OPT_static);
5639 if (!Args.hasArg(options::OPT_static))
5640 CmdArgs.push_back("-dynamic");
5641 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5642 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5643 // here. How do we wish to handle such things?
5644 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005645
Daniel Dunbarc1964212009-03-26 16:23:12 +00005646 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005647 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005648 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005649 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005650
5651 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5652 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5653 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5654
5655 Arg *A;
5656 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5657 (A = Args.getLastArg(options::OPT_current__version)) ||
5658 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005659 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005660 << A->getAsString(Args) << "-dynamiclib";
5661
5662 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5663 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5664 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5665 } else {
5666 CmdArgs.push_back("-dylib");
5667
5668 Arg *A;
5669 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5670 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5671 (A = Args.getLastArg(options::OPT_client__name)) ||
5672 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5673 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5674 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005675 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005676 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005677
Daniel Dunbarc1964212009-03-26 16:23:12 +00005678 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5679 "-dylib_compatibility_version");
5680 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5681 "-dylib_current_version");
5682
Tim Northover157d9112014-01-16 08:48:16 +00005683 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005684
5685 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5686 "-dylib_install_name");
5687 }
5688
5689 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5690 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5691 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005692 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005693 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005694 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5695 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5696 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5697 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5698 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5699 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005700 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005701 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5702 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5703 Args.AddAllArgs(CmdArgs, options::OPT_init);
5704
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005705 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005706 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005707
Daniel Dunbarc1964212009-03-26 16:23:12 +00005708 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5709 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5710 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5711 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5712 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005713
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005714 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5715 options::OPT_fno_pie,
5716 options::OPT_fno_PIE)) {
5717 if (A->getOption().matches(options::OPT_fpie) ||
5718 A->getOption().matches(options::OPT_fPIE))
5719 CmdArgs.push_back("-pie");
5720 else
5721 CmdArgs.push_back("-no_pie");
5722 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005723
5724 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5725 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5726 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5727 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5728 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5729 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5730 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5731 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5732 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5733 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5734 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5735 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5736 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5737 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5738 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5739 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005740
Daniel Dunbar84384642011-05-02 21:03:47 +00005741 // Give --sysroot= preference, over the Apple specific behavior to also use
5742 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005743 StringRef sysroot = C.getSysRoot();
5744 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005745 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005746 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005747 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5748 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005749 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005750 }
5751
Daniel Dunbarc1964212009-03-26 16:23:12 +00005752 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5753 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5754 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5755 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5756 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005757 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005758 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5759 Args.AddAllArgs(CmdArgs, options::OPT_y);
5760 Args.AddLastArg(CmdArgs, options::OPT_w);
5761 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5762 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5763 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5764 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5765 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5766 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5767 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5768 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5769 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5770 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5771 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5772 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5773}
5774
Alexey Bataev186b28a2014-03-06 05:43:53 +00005775enum LibOpenMP {
5776 LibUnknown,
5777 LibGOMP,
5778 LibIOMP5
5779};
5780
Daniel Dunbarc1964212009-03-26 16:23:12 +00005781void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005782 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005783 const InputInfoList &Inputs,
5784 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005785 const char *LinkingOutput) const {
5786 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005787
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005788 // If the number of arguments surpasses the system limits, we will encode the
5789 // input files in a separate file, shortening the command line. To this end,
5790 // build a list of input file names that can be passed via a file with the
5791 // -filelist linker option.
5792 llvm::opt::ArgStringList InputFileList;
5793
Daniel Dunbarc1964212009-03-26 16:23:12 +00005794 // The logic here is derived from gcc's behavior; most of which
5795 // comes from specs (starting with link_command). Consult gcc for
5796 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005797 ArgStringList CmdArgs;
5798
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005799 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5800 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5801 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005802 for (const auto &Arg : Args)
5803 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005804 const char *Exec =
5805 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5806 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00005807 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005808 return;
5809 }
5810
Daniel Dunbarc1964212009-03-26 16:23:12 +00005811 // I'm not sure why this particular decomposition exists in gcc, but
5812 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005813 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005814
Daniel Dunbarc1964212009-03-26 16:23:12 +00005815 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5816 Args.AddAllArgs(CmdArgs, options::OPT_s);
5817 Args.AddAllArgs(CmdArgs, options::OPT_t);
5818 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5819 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005820 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005821 Args.AddAllArgs(CmdArgs, options::OPT_r);
5822
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005823 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5824 // members of static archive libraries which implement Objective-C classes or
5825 // categories.
5826 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5827 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005828
Daniel Dunbarc1964212009-03-26 16:23:12 +00005829 CmdArgs.push_back("-o");
5830 CmdArgs.push_back(Output.getFilename());
5831
Chad Rosier06fd3c62012-05-16 23:45:12 +00005832 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005833 !Args.hasArg(options::OPT_nostartfiles))
5834 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005835
5836 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005837
Alexey Bataev186b28a2014-03-06 05:43:53 +00005838 LibOpenMP UsedOpenMPLib = LibUnknown;
5839 if (Args.hasArg(options::OPT_fopenmp)) {
5840 UsedOpenMPLib = LibGOMP;
5841 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5842 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5843 .Case("libgomp", LibGOMP)
5844 .Case("libiomp5", LibIOMP5)
5845 .Default(LibUnknown);
5846 if (UsedOpenMPLib == LibUnknown)
5847 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5848 << A->getOption().getName() << A->getValue();
5849 }
5850 switch (UsedOpenMPLib) {
5851 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005852 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005853 break;
5854 case LibIOMP5:
5855 CmdArgs.push_back("-liomp5");
5856 break;
5857 case LibUnknown:
5858 break;
5859 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005860
Douglas Gregor9295df02012-05-15 21:00:27 +00005861 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005862 // Build the input file for -filelist (list of linker input files) in case we
5863 // need it later
5864 for (const auto &II : Inputs) {
5865 if (!II.isFilename()) {
5866 // This is a linker input argument.
5867 // We cannot mix input arguments and file names in a -filelist input, thus
5868 // we prematurely stop our list (remaining files shall be passed as
5869 // arguments).
5870 if (InputFileList.size() > 0)
5871 break;
5872
5873 continue;
5874 }
5875
5876 InputFileList.push_back(II.getFilename());
5877 }
5878
Bob Wilson16d93952012-05-15 18:57:39 +00005879 if (isObjCRuntimeLinked(Args) &&
5880 !Args.hasArg(options::OPT_nostdlib) &&
5881 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005882 // We use arclite library for both ARC and subscripting support.
5883 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5884
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005885 CmdArgs.push_back("-framework");
5886 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005887 // Link libobj.
5888 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005889 }
John McCall31168b02011-06-15 23:02:42 +00005890
Daniel Dunbarc1964212009-03-26 16:23:12 +00005891 if (LinkingOutput) {
5892 CmdArgs.push_back("-arch_multiple");
5893 CmdArgs.push_back("-final_output");
5894 CmdArgs.push_back(LinkingOutput);
5895 }
5896
Daniel Dunbarc1964212009-03-26 16:23:12 +00005897 if (Args.hasArg(options::OPT_fnested_functions))
5898 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005899
Daniel Dunbarc1964212009-03-26 16:23:12 +00005900 if (!Args.hasArg(options::OPT_nostdlib) &&
5901 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005902 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005903 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005904
Daniel Dunbarc1964212009-03-26 16:23:12 +00005905 // link_ssp spec is empty.
5906
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005907 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005908 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005909 }
5910
Chad Rosier06fd3c62012-05-16 23:45:12 +00005911 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005912 !Args.hasArg(options::OPT_nostartfiles)) {
5913 // endfile_spec is empty.
5914 }
5915
5916 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5917 Args.AddAllArgs(CmdArgs, options::OPT_F);
5918
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005919 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005920 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005921 std::unique_ptr<Command> Cmd =
5922 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
5923 Cmd->setInputFileList(std::move(InputFileList));
5924 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005925}
5926
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005927void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005928 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005929 const InputInfoList &Inputs,
5930 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005931 const char *LinkingOutput) const {
5932 ArgStringList CmdArgs;
5933
5934 CmdArgs.push_back("-create");
5935 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005936
5937 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005938 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005939
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005940 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005941 assert(II.isFilename() && "Unexpected lipo input.");
5942 CmdArgs.push_back(II.getFilename());
5943 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005944
5945 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00005946 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005947}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005948
Daniel Dunbar88299622010-06-04 18:28:36 +00005949void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005950 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005951 const InputInfoList &Inputs,
5952 const ArgList &Args,
5953 const char *LinkingOutput) const {
5954 ArgStringList CmdArgs;
5955
Daniel Dunbareb86b042011-05-09 17:23:16 +00005956 CmdArgs.push_back("-o");
5957 CmdArgs.push_back(Output.getFilename());
5958
Daniel Dunbar88299622010-06-04 18:28:36 +00005959 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5960 const InputInfo &Input = Inputs[0];
5961 assert(Input.isFilename() && "Unexpected dsymutil input.");
5962 CmdArgs.push_back(Input.getFilename());
5963
Daniel Dunbar88299622010-06-04 18:28:36 +00005964 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005965 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00005966 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005967}
5968
Eric Christopher551ef452011-08-23 17:56:55 +00005969void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005970 const InputInfo &Output,
5971 const InputInfoList &Inputs,
5972 const ArgList &Args,
5973 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005974 ArgStringList CmdArgs;
5975 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005976 CmdArgs.push_back("--debug-info");
5977 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005978 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005979
5980 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5981 const InputInfo &Input = Inputs[0];
5982 assert(Input.isFilename() && "Unexpected verify input");
5983
5984 // Grabbing the output of the earlier dsymutil run.
5985 CmdArgs.push_back(Input.getFilename());
5986
5987 const char *Exec =
5988 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00005989 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00005990}
5991
David Chisnallf571cde2012-02-15 13:39:01 +00005992void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5993 const InputInfo &Output,
5994 const InputInfoList &Inputs,
5995 const ArgList &Args,
5996 const char *LinkingOutput) const {
5997 ArgStringList CmdArgs;
5998
5999 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6000 options::OPT_Xassembler);
6001
6002 CmdArgs.push_back("-o");
6003 CmdArgs.push_back(Output.getFilename());
6004
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006005 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006006 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006007
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006008 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006009 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006010}
6011
David Chisnallf571cde2012-02-15 13:39:01 +00006012void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6013 const InputInfo &Output,
6014 const InputInfoList &Inputs,
6015 const ArgList &Args,
6016 const char *LinkingOutput) const {
6017 // FIXME: Find a real GCC, don't hard-code versions here
6018 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6019 const llvm::Triple &T = getToolChain().getTriple();
6020 std::string LibPath = "/usr/lib/";
6021 llvm::Triple::ArchType Arch = T.getArch();
6022 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006023 case llvm::Triple::x86:
6024 GCCLibPath +=
6025 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6026 break;
6027 case llvm::Triple::x86_64:
6028 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6029 GCCLibPath += "/4.5.2/amd64/";
6030 LibPath += "amd64/";
6031 break;
6032 default:
6033 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006034 }
6035
6036 ArgStringList CmdArgs;
6037
David Chisnall272a0712012-02-29 15:06:12 +00006038 // Demangle C++ names in errors
6039 CmdArgs.push_back("-C");
6040
David Chisnallf571cde2012-02-15 13:39:01 +00006041 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6042 (!Args.hasArg(options::OPT_shared))) {
6043 CmdArgs.push_back("-e");
6044 CmdArgs.push_back("_start");
6045 }
6046
6047 if (Args.hasArg(options::OPT_static)) {
6048 CmdArgs.push_back("-Bstatic");
6049 CmdArgs.push_back("-dn");
6050 } else {
6051 CmdArgs.push_back("-Bdynamic");
6052 if (Args.hasArg(options::OPT_shared)) {
6053 CmdArgs.push_back("-shared");
6054 } else {
6055 CmdArgs.push_back("--dynamic-linker");
6056 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6057 }
6058 }
6059
6060 if (Output.isFilename()) {
6061 CmdArgs.push_back("-o");
6062 CmdArgs.push_back(Output.getFilename());
6063 } else {
6064 assert(Output.isNothing() && "Invalid output.");
6065 }
6066
6067 if (!Args.hasArg(options::OPT_nostdlib) &&
6068 !Args.hasArg(options::OPT_nostartfiles)) {
6069 if (!Args.hasArg(options::OPT_shared)) {
6070 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6071 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006072 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006073 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6074 } else {
6075 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006076 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6077 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006078 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006079 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006080 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006081 }
6082
6083 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6084
6085 Args.AddAllArgs(CmdArgs, options::OPT_L);
6086 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6087 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006088 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006089
6090 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6091
6092 if (!Args.hasArg(options::OPT_nostdlib) &&
6093 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006094 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006095 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006096 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006097 if (!Args.hasArg(options::OPT_shared)) {
6098 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006099 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006100 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006101 }
David Chisnallf571cde2012-02-15 13:39:01 +00006102 }
6103
6104 if (!Args.hasArg(options::OPT_nostdlib) &&
6105 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006106 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006107 }
David Chisnall96de9932012-02-16 16:00:47 +00006108 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006109
Alexey Samsonov7811d192014-02-20 13:57:37 +00006110 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006111
6112 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006113 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006114 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006115}
6116
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006117void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006118 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006119 const InputInfoList &Inputs,
6120 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006121 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006122 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006123 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006124
Rafael Espindolacc126272014-02-28 01:55:21 +00006125 switch (getToolChain().getArch()) {
6126 case llvm::Triple::x86:
6127 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6128 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006129 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006130 break;
6131
6132 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006133 CmdArgs.push_back("-mppc");
6134 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006135 break;
6136
6137 case llvm::Triple::sparc:
6138 CmdArgs.push_back("-32");
6139 NeedsKPIC = true;
6140 break;
6141
6142 case llvm::Triple::sparcv9:
6143 CmdArgs.push_back("-64");
6144 CmdArgs.push_back("-Av9a");
6145 NeedsKPIC = true;
6146 break;
6147
6148 case llvm::Triple::mips64:
6149 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006150 StringRef CPUName;
6151 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006152 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006153
6154 CmdArgs.push_back("-mabi");
6155 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6156
6157 if (getToolChain().getArch() == llvm::Triple::mips64)
6158 CmdArgs.push_back("-EB");
6159 else
6160 CmdArgs.push_back("-EL");
6161
Rafael Espindolacc126272014-02-28 01:55:21 +00006162 NeedsKPIC = true;
6163 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006164 }
6165
Rafael Espindolacc126272014-02-28 01:55:21 +00006166 default:
6167 break;
6168 }
6169
6170 if (NeedsKPIC)
6171 addAssemblerKPIC(Args, CmdArgs);
6172
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006173 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6174 options::OPT_Xassembler);
6175
6176 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006177 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006178
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006179 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006180 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006181
6182 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006183 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006184 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006185}
6186
6187void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006188 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006189 const InputInfoList &Inputs,
6190 const ArgList &Args,
6191 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006192 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006193 ArgStringList CmdArgs;
6194
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006195 // Silence warning for "clang -g foo.o -o foo"
6196 Args.ClaimAllArgs(options::OPT_g_Group);
6197 // and "clang -emit-llvm foo.o -o foo"
6198 Args.ClaimAllArgs(options::OPT_emit_llvm);
6199 // and for "clang -w foo.o -o foo". Other warning options are already
6200 // handled somewhere else.
6201 Args.ClaimAllArgs(options::OPT_w);
6202
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006203 if (getToolChain().getArch() == llvm::Triple::mips64)
6204 CmdArgs.push_back("-EB");
6205 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6206 CmdArgs.push_back("-EL");
6207
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006208 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006209 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006210 CmdArgs.push_back("-e");
6211 CmdArgs.push_back("__start");
6212 }
6213
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006214 if (Args.hasArg(options::OPT_static)) {
6215 CmdArgs.push_back("-Bstatic");
6216 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006217 if (Args.hasArg(options::OPT_rdynamic))
6218 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006219 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006220 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006221 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006222 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006223 } else {
6224 CmdArgs.push_back("-dynamic-linker");
6225 CmdArgs.push_back("/usr/libexec/ld.so");
6226 }
6227 }
6228
Rafael Espindola044f7832013-06-05 04:28:55 +00006229 if (Args.hasArg(options::OPT_nopie))
6230 CmdArgs.push_back("-nopie");
6231
Daniel Dunbarb440f562010-08-02 02:38:21 +00006232 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006233 CmdArgs.push_back("-o");
6234 CmdArgs.push_back(Output.getFilename());
6235 } else {
6236 assert(Output.isNothing() && "Invalid output.");
6237 }
6238
6239 if (!Args.hasArg(options::OPT_nostdlib) &&
6240 !Args.hasArg(options::OPT_nostartfiles)) {
6241 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006242 if (Args.hasArg(options::OPT_pg))
6243 CmdArgs.push_back(Args.MakeArgString(
6244 getToolChain().GetFilePath("gcrt0.o")));
6245 else
6246 CmdArgs.push_back(Args.MakeArgString(
6247 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006248 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006249 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006250 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006251 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006252 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006253 }
6254 }
6255
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006256 std::string Triple = getToolChain().getTripleString();
6257 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006258 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006259 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006260 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006261
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006262 Args.AddAllArgs(CmdArgs, options::OPT_L);
6263 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6264 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006265 Args.AddAllArgs(CmdArgs, options::OPT_s);
6266 Args.AddAllArgs(CmdArgs, options::OPT_t);
6267 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6268 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006269
Daniel Dunbar54423b22010-09-17 00:24:54 +00006270 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006271
6272 if (!Args.hasArg(options::OPT_nostdlib) &&
6273 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006274 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006275 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006276 if (Args.hasArg(options::OPT_pg))
6277 CmdArgs.push_back("-lm_p");
6278 else
6279 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006280 }
6281
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006282 // FIXME: For some reason GCC passes -lgcc before adding
6283 // the default system libraries. Just mimic this for now.
6284 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006285
Eric Christopher17674ec2012-09-13 06:32:34 +00006286 if (Args.hasArg(options::OPT_pthread)) {
6287 if (!Args.hasArg(options::OPT_shared) &&
6288 Args.hasArg(options::OPT_pg))
6289 CmdArgs.push_back("-lpthread_p");
6290 else
6291 CmdArgs.push_back("-lpthread");
6292 }
6293
Chandler Carruth45661652011-12-17 22:32:42 +00006294 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006295 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006296 CmdArgs.push_back("-lc_p");
6297 else
6298 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006299 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006300
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006301 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006302 }
6303
6304 if (!Args.hasArg(options::OPT_nostdlib) &&
6305 !Args.hasArg(options::OPT_nostartfiles)) {
6306 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006307 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006308 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006309 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006310 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006311 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006312 }
6313
6314 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006315 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006316 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006317}
Ed Schoutene33194b2009-04-02 19:13:12 +00006318
Eli Friedman9fa28852012-08-08 23:57:20 +00006319void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6320 const InputInfo &Output,
6321 const InputInfoList &Inputs,
6322 const ArgList &Args,
6323 const char *LinkingOutput) const {
6324 ArgStringList CmdArgs;
6325
6326 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6327 options::OPT_Xassembler);
6328
6329 CmdArgs.push_back("-o");
6330 CmdArgs.push_back(Output.getFilename());
6331
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006332 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006333 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006334
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006335 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006336 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006337}
6338
6339void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6340 const InputInfo &Output,
6341 const InputInfoList &Inputs,
6342 const ArgList &Args,
6343 const char *LinkingOutput) const {
6344 const Driver &D = getToolChain().getDriver();
6345 ArgStringList CmdArgs;
6346
6347 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6348 (!Args.hasArg(options::OPT_shared))) {
6349 CmdArgs.push_back("-e");
6350 CmdArgs.push_back("__start");
6351 }
6352
6353 if (Args.hasArg(options::OPT_static)) {
6354 CmdArgs.push_back("-Bstatic");
6355 } else {
6356 if (Args.hasArg(options::OPT_rdynamic))
6357 CmdArgs.push_back("-export-dynamic");
6358 CmdArgs.push_back("--eh-frame-hdr");
6359 CmdArgs.push_back("-Bdynamic");
6360 if (Args.hasArg(options::OPT_shared)) {
6361 CmdArgs.push_back("-shared");
6362 } else {
6363 CmdArgs.push_back("-dynamic-linker");
6364 CmdArgs.push_back("/usr/libexec/ld.so");
6365 }
6366 }
6367
6368 if (Output.isFilename()) {
6369 CmdArgs.push_back("-o");
6370 CmdArgs.push_back(Output.getFilename());
6371 } else {
6372 assert(Output.isNothing() && "Invalid output.");
6373 }
6374
6375 if (!Args.hasArg(options::OPT_nostdlib) &&
6376 !Args.hasArg(options::OPT_nostartfiles)) {
6377 if (!Args.hasArg(options::OPT_shared)) {
6378 if (Args.hasArg(options::OPT_pg))
6379 CmdArgs.push_back(Args.MakeArgString(
6380 getToolChain().GetFilePath("gcrt0.o")));
6381 else
6382 CmdArgs.push_back(Args.MakeArgString(
6383 getToolChain().GetFilePath("crt0.o")));
6384 CmdArgs.push_back(Args.MakeArgString(
6385 getToolChain().GetFilePath("crtbegin.o")));
6386 } else {
6387 CmdArgs.push_back(Args.MakeArgString(
6388 getToolChain().GetFilePath("crtbeginS.o")));
6389 }
6390 }
6391
6392 Args.AddAllArgs(CmdArgs, options::OPT_L);
6393 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6394 Args.AddAllArgs(CmdArgs, options::OPT_e);
6395
6396 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6397
6398 if (!Args.hasArg(options::OPT_nostdlib) &&
6399 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006400 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006401 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6402 if (Args.hasArg(options::OPT_pg))
6403 CmdArgs.push_back("-lm_p");
6404 else
6405 CmdArgs.push_back("-lm");
6406 }
6407
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006408 if (Args.hasArg(options::OPT_pthread)) {
6409 if (!Args.hasArg(options::OPT_shared) &&
6410 Args.hasArg(options::OPT_pg))
6411 CmdArgs.push_back("-lpthread_p");
6412 else
6413 CmdArgs.push_back("-lpthread");
6414 }
6415
Eli Friedman9fa28852012-08-08 23:57:20 +00006416 if (!Args.hasArg(options::OPT_shared)) {
6417 if (Args.hasArg(options::OPT_pg))
6418 CmdArgs.push_back("-lc_p");
6419 else
6420 CmdArgs.push_back("-lc");
6421 }
6422
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006423 StringRef MyArch;
6424 switch (getToolChain().getTriple().getArch()) {
6425 case llvm::Triple::arm:
6426 MyArch = "arm";
6427 break;
6428 case llvm::Triple::x86:
6429 MyArch = "i386";
6430 break;
6431 case llvm::Triple::x86_64:
6432 MyArch = "amd64";
6433 break;
6434 default:
6435 llvm_unreachable("Unsupported architecture");
6436 }
6437 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006438 }
6439
6440 if (!Args.hasArg(options::OPT_nostdlib) &&
6441 !Args.hasArg(options::OPT_nostartfiles)) {
6442 if (!Args.hasArg(options::OPT_shared))
6443 CmdArgs.push_back(Args.MakeArgString(
6444 getToolChain().GetFilePath("crtend.o")));
6445 else
6446 CmdArgs.push_back(Args.MakeArgString(
6447 getToolChain().GetFilePath("crtendS.o")));
6448 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006449
6450 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006451 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006452 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006453}
6454
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006455void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006456 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006457 const InputInfoList &Inputs,
6458 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006459 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006460 ArgStringList CmdArgs;
6461
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006462 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6463 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006464 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006465 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006466 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006467 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006468 else if (getToolChain().getArch() == llvm::Triple::mips ||
6469 getToolChain().getArch() == llvm::Triple::mipsel ||
6470 getToolChain().getArch() == llvm::Triple::mips64 ||
6471 getToolChain().getArch() == llvm::Triple::mips64el) {
6472 StringRef CPUName;
6473 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006474 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006475
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006476 CmdArgs.push_back("-march");
6477 CmdArgs.push_back(CPUName.data());
6478
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006479 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006480 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006481
6482 if (getToolChain().getArch() == llvm::Triple::mips ||
6483 getToolChain().getArch() == llvm::Triple::mips64)
6484 CmdArgs.push_back("-EB");
6485 else
6486 CmdArgs.push_back("-EL");
6487
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006488 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006489 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006490 getToolChain().getArch() == llvm::Triple::armeb ||
6491 getToolChain().getArch() == llvm::Triple::thumb ||
6492 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006493 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006494 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006495 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6496
6497 if (FloatABI == "hard") {
6498 CmdArgs.push_back("-mfpu=vfp");
6499 } else {
6500 CmdArgs.push_back("-mfpu=softvfp");
6501 }
6502
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006503 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006504 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006505 case llvm::Triple::GNUEABI:
6506 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006507 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006508 break;
6509
6510 default:
6511 CmdArgs.push_back("-matpcs");
6512 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006513 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006514 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006515 if (getToolChain().getArch() == llvm::Triple::sparc)
6516 CmdArgs.push_back("-Av8plusa");
6517 else
6518 CmdArgs.push_back("-Av9a");
6519
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006520 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006521 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006522
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006523 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6524 options::OPT_Xassembler);
6525
6526 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006527 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006528
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006529 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006530 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006531
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006532 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006533 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006534}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006535
6536void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006537 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006538 const InputInfoList &Inputs,
6539 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006540 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006541 const toolchains::FreeBSD& ToolChain =
6542 static_cast<const toolchains::FreeBSD&>(getToolChain());
6543 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006544 const bool IsPIE =
6545 !Args.hasArg(options::OPT_shared) &&
6546 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006547 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006548
6549 // Silence warning for "clang -g foo.o -o foo"
6550 Args.ClaimAllArgs(options::OPT_g_Group);
6551 // and "clang -emit-llvm foo.o -o foo"
6552 Args.ClaimAllArgs(options::OPT_emit_llvm);
6553 // and for "clang -w foo.o -o foo". Other warning options are already
6554 // handled somewhere else.
6555 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006556
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006557 if (!D.SysRoot.empty())
6558 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6559
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006560 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006561 CmdArgs.push_back("-pie");
6562
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006563 if (Args.hasArg(options::OPT_static)) {
6564 CmdArgs.push_back("-Bstatic");
6565 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006566 if (Args.hasArg(options::OPT_rdynamic))
6567 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006568 CmdArgs.push_back("--eh-frame-hdr");
6569 if (Args.hasArg(options::OPT_shared)) {
6570 CmdArgs.push_back("-Bshareable");
6571 } else {
6572 CmdArgs.push_back("-dynamic-linker");
6573 CmdArgs.push_back("/libexec/ld-elf.so.1");
6574 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006575 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6576 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006577 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6578 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6579 CmdArgs.push_back("--hash-style=both");
6580 }
6581 }
6582 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006583 }
6584
6585 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6586 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006587 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006588 CmdArgs.push_back("-m");
6589 CmdArgs.push_back("elf_i386_fbsd");
6590 }
6591
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006592 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006593 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006594 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006595 }
6596
Daniel Dunbarb440f562010-08-02 02:38:21 +00006597 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006598 CmdArgs.push_back("-o");
6599 CmdArgs.push_back(Output.getFilename());
6600 } else {
6601 assert(Output.isNothing() && "Invalid output.");
6602 }
6603
6604 if (!Args.hasArg(options::OPT_nostdlib) &&
6605 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006606 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006607 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006608 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006609 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006610 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006611 crt1 = "Scrt1.o";
6612 else
6613 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006614 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006615 if (crt1)
6616 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6617
6618 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6619
Craig Topper92fc2df2014-05-17 16:56:41 +00006620 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006621 if (Args.hasArg(options::OPT_static))
6622 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006623 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006624 crtbegin = "crtbeginS.o";
6625 else
6626 crtbegin = "crtbegin.o";
6627
6628 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006629 }
6630
6631 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00006632 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006633 for (const auto &Path : Paths)
6634 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006635 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6636 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006637 Args.AddAllArgs(CmdArgs, options::OPT_s);
6638 Args.AddAllArgs(CmdArgs, options::OPT_t);
6639 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6640 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006641
Alp Tokerce365ca2013-12-02 12:43:03 +00006642 if (D.IsUsingLTO(Args))
6643 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006644
Alexey Samsonov52550342014-09-15 19:58:40 +00006645 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00006646 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006647
6648 if (!Args.hasArg(options::OPT_nostdlib) &&
6649 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006650 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006651 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006652 if (Args.hasArg(options::OPT_pg))
6653 CmdArgs.push_back("-lm_p");
6654 else
6655 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006656 }
Alexey Samsonov52550342014-09-15 19:58:40 +00006657 if (NeedsSanitizerDeps)
6658 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006659 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6660 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006661 if (Args.hasArg(options::OPT_pg))
6662 CmdArgs.push_back("-lgcc_p");
6663 else
6664 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006665 if (Args.hasArg(options::OPT_static)) {
6666 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006667 } else if (Args.hasArg(options::OPT_pg)) {
6668 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006669 } else {
6670 CmdArgs.push_back("--as-needed");
6671 CmdArgs.push_back("-lgcc_s");
6672 CmdArgs.push_back("--no-as-needed");
6673 }
6674
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006675 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006676 if (Args.hasArg(options::OPT_pg))
6677 CmdArgs.push_back("-lpthread_p");
6678 else
6679 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006680 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006681
Roman Divacky66f22762011-02-10 16:59:40 +00006682 if (Args.hasArg(options::OPT_pg)) {
6683 if (Args.hasArg(options::OPT_shared))
6684 CmdArgs.push_back("-lc");
6685 else
6686 CmdArgs.push_back("-lc_p");
6687 CmdArgs.push_back("-lgcc_p");
6688 } else {
6689 CmdArgs.push_back("-lc");
6690 CmdArgs.push_back("-lgcc");
6691 }
6692
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006693 if (Args.hasArg(options::OPT_static)) {
6694 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006695 } else if (Args.hasArg(options::OPT_pg)) {
6696 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006697 } else {
6698 CmdArgs.push_back("--as-needed");
6699 CmdArgs.push_back("-lgcc_s");
6700 CmdArgs.push_back("--no-as-needed");
6701 }
6702 }
6703
6704 if (!Args.hasArg(options::OPT_nostdlib) &&
6705 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006706 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006707 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006708 else
6709 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006710 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006711 }
6712
Alexey Samsonov7811d192014-02-20 13:57:37 +00006713 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006714
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006715 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006716 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006717 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006718}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006719
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006720void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6721 const InputInfo &Output,
6722 const InputInfoList &Inputs,
6723 const ArgList &Args,
6724 const char *LinkingOutput) const {
6725 ArgStringList CmdArgs;
6726
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006727 // GNU as needs different flags for creating the correct output format
6728 // on architectures with different ABIs or optional feature sets.
6729 switch (getToolChain().getArch()) {
6730 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006731 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006732 break;
6733 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006734 case llvm::Triple::armeb:
6735 case llvm::Triple::thumb:
6736 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006737 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006738 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006739 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006740 }
6741
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006742 case llvm::Triple::mips:
6743 case llvm::Triple::mipsel:
6744 case llvm::Triple::mips64:
6745 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006746 StringRef CPUName;
6747 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006748 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006749
6750 CmdArgs.push_back("-march");
6751 CmdArgs.push_back(CPUName.data());
6752
6753 CmdArgs.push_back("-mabi");
6754 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6755
6756 if (getToolChain().getArch() == llvm::Triple::mips ||
6757 getToolChain().getArch() == llvm::Triple::mips64)
6758 CmdArgs.push_back("-EB");
6759 else
6760 CmdArgs.push_back("-EL");
6761
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006762 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006763 break;
6764 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006765
6766 case llvm::Triple::sparc:
6767 CmdArgs.push_back("-32");
6768 addAssemblerKPIC(Args, CmdArgs);
6769 break;
6770
6771 case llvm::Triple::sparcv9:
6772 CmdArgs.push_back("-64");
6773 CmdArgs.push_back("-Av9");
6774 addAssemblerKPIC(Args, CmdArgs);
6775 break;
6776
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006777 default:
6778 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006779 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006780
6781 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6782 options::OPT_Xassembler);
6783
6784 CmdArgs.push_back("-o");
6785 CmdArgs.push_back(Output.getFilename());
6786
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006787 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006788 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006789
David Chisnallddbd68f2011-09-27 22:03:18 +00006790 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00006791 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006792}
6793
6794void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6795 const InputInfo &Output,
6796 const InputInfoList &Inputs,
6797 const ArgList &Args,
6798 const char *LinkingOutput) const {
6799 const Driver &D = getToolChain().getDriver();
6800 ArgStringList CmdArgs;
6801
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006802 if (!D.SysRoot.empty())
6803 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6804
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006805 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006806 if (Args.hasArg(options::OPT_static)) {
6807 CmdArgs.push_back("-Bstatic");
6808 } else {
6809 if (Args.hasArg(options::OPT_rdynamic))
6810 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006811 if (Args.hasArg(options::OPT_shared)) {
6812 CmdArgs.push_back("-Bshareable");
6813 } else {
6814 CmdArgs.push_back("-dynamic-linker");
6815 CmdArgs.push_back("/libexec/ld.elf_so");
6816 }
6817 }
6818
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006819 // Many NetBSD architectures support more than one ABI.
6820 // Determine the correct emulation for ld.
6821 switch (getToolChain().getArch()) {
6822 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006823 CmdArgs.push_back("-m");
6824 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006825 break;
6826 case llvm::Triple::arm:
6827 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006828 CmdArgs.push_back("-m");
6829 switch (getToolChain().getTriple().getEnvironment()) {
6830 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006831 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006832 CmdArgs.push_back("armelf_nbsd_eabi");
6833 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006834 case llvm::Triple::EABIHF:
6835 case llvm::Triple::GNUEABIHF:
6836 CmdArgs.push_back("armelf_nbsd_eabihf");
6837 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006838 default:
6839 CmdArgs.push_back("armelf_nbsd");
6840 break;
6841 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006842 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00006843 case llvm::Triple::armeb:
6844 case llvm::Triple::thumbeb:
6845 CmdArgs.push_back("-m");
6846 switch (getToolChain().getTriple().getEnvironment()) {
6847 case llvm::Triple::EABI:
6848 case llvm::Triple::GNUEABI:
6849 CmdArgs.push_back("armelfb_nbsd_eabi");
6850 break;
6851 case llvm::Triple::EABIHF:
6852 case llvm::Triple::GNUEABIHF:
6853 CmdArgs.push_back("armelfb_nbsd_eabihf");
6854 break;
6855 default:
6856 CmdArgs.push_back("armelfb_nbsd");
6857 break;
6858 }
6859 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006860 case llvm::Triple::mips64:
6861 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006862 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006863 CmdArgs.push_back("-m");
6864 if (getToolChain().getArch() == llvm::Triple::mips64)
6865 CmdArgs.push_back("elf32btsmip");
6866 else
6867 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006868 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006869 CmdArgs.push_back("-m");
6870 if (getToolChain().getArch() == llvm::Triple::mips64)
6871 CmdArgs.push_back("elf64btsmip");
6872 else
6873 CmdArgs.push_back("elf64ltsmip");
6874 }
6875 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006876 case llvm::Triple::ppc:
6877 CmdArgs.push_back("-m");
6878 CmdArgs.push_back("elf32ppc_nbsd");
6879 break;
6880
6881 case llvm::Triple::ppc64:
6882 case llvm::Triple::ppc64le:
6883 CmdArgs.push_back("-m");
6884 CmdArgs.push_back("elf64ppc");
6885 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006886
6887 case llvm::Triple::sparc:
6888 CmdArgs.push_back("-m");
6889 CmdArgs.push_back("elf32_sparc");
6890 break;
6891
6892 case llvm::Triple::sparcv9:
6893 CmdArgs.push_back("-m");
6894 CmdArgs.push_back("elf64_sparc");
6895 break;
6896
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006897 default:
6898 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006899 }
6900
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006901 if (Output.isFilename()) {
6902 CmdArgs.push_back("-o");
6903 CmdArgs.push_back(Output.getFilename());
6904 } else {
6905 assert(Output.isNothing() && "Invalid output.");
6906 }
6907
6908 if (!Args.hasArg(options::OPT_nostdlib) &&
6909 !Args.hasArg(options::OPT_nostartfiles)) {
6910 if (!Args.hasArg(options::OPT_shared)) {
6911 CmdArgs.push_back(Args.MakeArgString(
6912 getToolChain().GetFilePath("crt0.o")));
6913 CmdArgs.push_back(Args.MakeArgString(
6914 getToolChain().GetFilePath("crti.o")));
6915 CmdArgs.push_back(Args.MakeArgString(
6916 getToolChain().GetFilePath("crtbegin.o")));
6917 } else {
6918 CmdArgs.push_back(Args.MakeArgString(
6919 getToolChain().GetFilePath("crti.o")));
6920 CmdArgs.push_back(Args.MakeArgString(
6921 getToolChain().GetFilePath("crtbeginS.o")));
6922 }
6923 }
6924
6925 Args.AddAllArgs(CmdArgs, options::OPT_L);
6926 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6927 Args.AddAllArgs(CmdArgs, options::OPT_e);
6928 Args.AddAllArgs(CmdArgs, options::OPT_s);
6929 Args.AddAllArgs(CmdArgs, options::OPT_t);
6930 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6931 Args.AddAllArgs(CmdArgs, options::OPT_r);
6932
6933 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6934
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006935 unsigned Major, Minor, Micro;
6936 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6937 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006938 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006939 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00006940 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006941 case llvm::Triple::arm:
6942 case llvm::Triple::armeb:
6943 case llvm::Triple::thumb:
6944 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006945 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006946 case llvm::Triple::ppc64:
6947 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006948 case llvm::Triple::x86:
6949 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006950 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006951 break;
6952 default:
6953 break;
6954 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006955 }
6956
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006957 if (!Args.hasArg(options::OPT_nostdlib) &&
6958 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006959 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006960 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6961 CmdArgs.push_back("-lm");
6962 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006963 if (Args.hasArg(options::OPT_pthread))
6964 CmdArgs.push_back("-lpthread");
6965 CmdArgs.push_back("-lc");
6966
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006967 if (useLibgcc) {
6968 if (Args.hasArg(options::OPT_static)) {
6969 // libgcc_eh depends on libc, so resolve as much as possible,
6970 // pull in any new requirements from libc and then get the rest
6971 // of libgcc.
6972 CmdArgs.push_back("-lgcc_eh");
6973 CmdArgs.push_back("-lc");
6974 CmdArgs.push_back("-lgcc");
6975 } else {
6976 CmdArgs.push_back("-lgcc");
6977 CmdArgs.push_back("--as-needed");
6978 CmdArgs.push_back("-lgcc_s");
6979 CmdArgs.push_back("--no-as-needed");
6980 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006981 }
6982 }
6983
6984 if (!Args.hasArg(options::OPT_nostdlib) &&
6985 !Args.hasArg(options::OPT_nostartfiles)) {
6986 if (!Args.hasArg(options::OPT_shared))
6987 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6988 "crtend.o")));
6989 else
6990 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6991 "crtendS.o")));
6992 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6993 "crtn.o")));
6994 }
6995
Alexey Samsonov7811d192014-02-20 13:57:37 +00006996 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006997
Logan Chieneb9162f2014-06-26 14:23:45 +00006998 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006999 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007000}
7001
Thomas Schwinge4e555262013-03-28 19:04:25 +00007002void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7003 const InputInfo &Output,
7004 const InputInfoList &Inputs,
7005 const ArgList &Args,
7006 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00007007 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007008 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007009
7010 // Add --32/--64 to make sure we get the format we want.
7011 // This is incomplete
7012 if (getToolChain().getArch() == llvm::Triple::x86) {
7013 CmdArgs.push_back("--32");
7014 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00007015 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7016 CmdArgs.push_back("--x32");
7017 else
7018 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00007019 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
7020 CmdArgs.push_back("-a32");
7021 CmdArgs.push_back("-mppc");
7022 CmdArgs.push_back("-many");
7023 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
7024 CmdArgs.push_back("-a64");
7025 CmdArgs.push_back("-mppc64");
7026 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00007027 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
7028 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007029 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007030 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007031 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007032 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
7033 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007034 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007035 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007036 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
7037 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007038 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007039 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007040 } else if (getToolChain().getArch() == llvm::Triple::arm ||
7041 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007042 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00007043 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
7044 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007045 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
7046 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00007047 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007048
Tim Northover9c7e0352013-12-12 11:55:52 +00007049 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7050 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007051 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007052
7053 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007054
7055 // FIXME: remove krait check when GNU tools support krait cpu
7056 // for now replace it with -march=armv7-a to avoid a lower
7057 // march from being picked in the absence of a cpu flag.
7058 Arg *A;
7059 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7060 StringRef(A->getValue()) == "krait")
7061 CmdArgs.push_back("-march=armv7-a");
7062 else
7063 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007064 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007065 } else if (getToolChain().getArch() == llvm::Triple::mips ||
7066 getToolChain().getArch() == llvm::Triple::mipsel ||
7067 getToolChain().getArch() == llvm::Triple::mips64 ||
7068 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007069 StringRef CPUName;
7070 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007071 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007072 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007073
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007074 CmdArgs.push_back("-march");
7075 CmdArgs.push_back(CPUName.data());
7076
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007077 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007078 CmdArgs.push_back(ABIName.data());
7079
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007080 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7081 // or -mshared (not implemented) is in effect.
7082 bool IsPicOrPie = false;
7083 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7084 options::OPT_fpic, options::OPT_fno_pic,
7085 options::OPT_fPIE, options::OPT_fno_PIE,
7086 options::OPT_fpie, options::OPT_fno_pie)) {
7087 if (A->getOption().matches(options::OPT_fPIC) ||
7088 A->getOption().matches(options::OPT_fpic) ||
7089 A->getOption().matches(options::OPT_fPIE) ||
7090 A->getOption().matches(options::OPT_fpie))
7091 IsPicOrPie = true;
7092 }
7093 if (!IsPicOrPie)
7094 CmdArgs.push_back("-mno-shared");
7095
Daniel Sanders379d44b2014-07-16 11:52:23 +00007096 // LLVM doesn't support -mplt yet and acts as if it is always given.
7097 // However, -mplt has no effect with the N64 ABI.
7098 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007099
7100 if (getToolChain().getArch() == llvm::Triple::mips ||
7101 getToolChain().getArch() == llvm::Triple::mips64)
7102 CmdArgs.push_back("-EB");
7103 else
7104 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007105
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007106 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7107 if (StringRef(A->getValue()) == "2008")
7108 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7109 }
7110
Daniel Sanders379d44b2014-07-16 11:52:23 +00007111 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7112 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7113 options::OPT_mfp64)) {
7114 A->claim();
7115 A->render(Args, CmdArgs);
7116 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7117 ABIName))
7118 CmdArgs.push_back("-mfpxx");
7119
7120 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7121 // -mno-mips16 is actually -no-mips16.
7122 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7123 options::OPT_mno_mips16)) {
7124 if (A->getOption().matches(options::OPT_mips16)) {
7125 A->claim();
7126 A->render(Args, CmdArgs);
7127 } else {
7128 A->claim();
7129 CmdArgs.push_back("-no-mips16");
7130 }
7131 }
7132
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007133 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7134 options::OPT_mno_micromips);
7135 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7136 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7137
Simon Atanasyanbd986632013-11-26 11:58:04 +00007138 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7139 // Do not use AddLastArg because not all versions of MIPS assembler
7140 // support -mmsa / -mno-msa options.
7141 if (A->getOption().matches(options::OPT_mmsa))
7142 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7143 }
7144
Daniel Sanders379d44b2014-07-16 11:52:23 +00007145 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7146 options::OPT_msoft_float);
7147
7148 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7149 options::OPT_mno_odd_spreg);
7150
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007151 NeedsKPIC = true;
7152 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7153 // Always pass an -march option, since our default of z10 is later
7154 // than the GNU assembler's default.
7155 StringRef CPUName = getSystemZTargetCPU(Args);
7156 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7157 }
7158
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007159 if (NeedsKPIC)
7160 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007161
7162 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7163 options::OPT_Xassembler);
7164
7165 CmdArgs.push_back("-o");
7166 CmdArgs.push_back(Output.getFilename());
7167
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007168 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007169 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007170
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007171 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007172 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007173
7174 // Handle the debug info splitting at object creation time if we're
7175 // creating an object.
7176 // TODO: Currently only works on linux with newer objcopy.
7177 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007178 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007179 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7180 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007181}
7182
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007183static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007184 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007185 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007186 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7187 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007188 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007189 CmdArgs.push_back("-lgcc");
7190
Logan Chien3d3373c2012-11-19 12:04:11 +00007191 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007192 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007193 CmdArgs.push_back("-lgcc");
7194 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007195 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007196 CmdArgs.push_back("--as-needed");
7197 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007198 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007199 CmdArgs.push_back("--no-as-needed");
7200 }
7201
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007202 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007203 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007204 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007205 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007206
7207 // According to Android ABI, we have to link with libdl if we are
7208 // linking with non-static libgcc.
7209 //
7210 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7211 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7212 if (isAndroid && !StaticLibgcc)
7213 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007214}
7215
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007216static std::string getLinuxDynamicLinker(const ArgList &Args,
7217 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007218 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7219 if (ToolChain.getTriple().isArch64Bit())
7220 return "/system/bin/linker64";
7221 else
7222 return "/system/bin/linker";
7223 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7224 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007225 return "/lib/ld-linux.so.2";
Tim Northover40956e62014-07-23 12:32:58 +00007226 else if (ToolChain.getArch() == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007227 return "/lib/ld-linux-aarch64.so.1";
Tim Northover40956e62014-07-23 12:32:58 +00007228 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007229 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007230 else if (ToolChain.getArch() == llvm::Triple::arm ||
7231 ToolChain.getArch() == llvm::Triple::thumb) {
7232 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7233 return "/lib/ld-linux-armhf.so.3";
7234 else
7235 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007236 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7237 ToolChain.getArch() == llvm::Triple::thumbeb) {
7238 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7239 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7240 else
7241 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007242 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007243 ToolChain.getArch() == llvm::Triple::mipsel ||
7244 ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007245 ToolChain.getArch() == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007246 StringRef CPUName;
7247 StringRef ABIName;
7248 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7249 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7250
7251 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7252 .Case("o32", "/lib")
7253 .Case("n32", "/lib32")
7254 .Case("n64", "/lib64")
7255 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007256 StringRef LibName;
7257 if (mips::isUCLibc(Args))
7258 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7259 else
7260 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007261
7262 return (LibDir + "/" + LibName).str();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007263 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7264 return "/lib/ld.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007265 else if (ToolChain.getArch() == llvm::Triple::ppc64) {
7266 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7267 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007268 return "/lib64/ld64.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007269 } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
7270 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7271 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007272 return "/lib64/ld64.so.2";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007273 } else if (ToolChain.getArch() == llvm::Triple::systemz)
7274 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007275 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7276 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007277 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7278 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7279 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007280 else
7281 return "/lib64/ld-linux-x86-64.so.2";
7282}
7283
Renato Golinc4b49242014-02-13 10:01:16 +00007284static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007285 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007286 // Make use of compiler-rt if --rtlib option is used
7287 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7288
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007289 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007290 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007291 switch (TC.getTriple().getOS()) {
7292 default: llvm_unreachable("unsupported OS");
7293 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007294 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007295 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007296 break;
7297 }
Renato Golinc4b49242014-02-13 10:01:16 +00007298 break;
7299 case ToolChain::RLT_Libgcc:
7300 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7301 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007302 }
7303}
7304
Rafael Espindola1e085772014-08-15 17:14:35 +00007305static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7306 switch (T.getArch()) {
7307 case llvm::Triple::x86:
7308 return "elf_i386";
7309 case llvm::Triple::aarch64:
7310 return "aarch64linux";
7311 case llvm::Triple::aarch64_be:
7312 return "aarch64_be_linux";
7313 case llvm::Triple::arm:
7314 case llvm::Triple::thumb:
7315 return "armelf_linux_eabi";
7316 case llvm::Triple::armeb:
7317 case llvm::Triple::thumbeb:
7318 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7319 case llvm::Triple::ppc:
7320 return "elf32ppclinux";
7321 case llvm::Triple::ppc64:
7322 return "elf64ppc";
7323 case llvm::Triple::ppc64le:
7324 return "elf64lppc";
7325 case llvm::Triple::sparc:
7326 return "elf32_sparc";
7327 case llvm::Triple::sparcv9:
7328 return "elf64_sparc";
7329 case llvm::Triple::mips:
7330 return "elf32btsmip";
7331 case llvm::Triple::mipsel:
7332 return "elf32ltsmip";
7333 case llvm::Triple::mips64:
7334 if (mips::hasMipsAbiArg(Args, "n32"))
7335 return "elf32btsmipn32";
7336 return "elf64btsmip";
7337 case llvm::Triple::mips64el:
7338 if (mips::hasMipsAbiArg(Args, "n32"))
7339 return "elf32ltsmipn32";
7340 return "elf64ltsmip";
7341 case llvm::Triple::systemz:
7342 return "elf64_s390";
7343 case llvm::Triple::x86_64:
7344 if (T.getEnvironment() == llvm::Triple::GNUX32)
7345 return "elf32_x86_64";
7346 return "elf_x86_64";
7347 default:
7348 llvm_unreachable("Unexpected arch");
7349 }
7350}
7351
Thomas Schwinge4e555262013-03-28 19:04:25 +00007352void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7353 const InputInfo &Output,
7354 const InputInfoList &Inputs,
7355 const ArgList &Args,
7356 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007357 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007358 static_cast<const toolchains::Linux&>(getToolChain());
7359 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007360 const bool isAndroid =
7361 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007362 const bool IsPIE =
7363 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007364 !Args.hasArg(options::OPT_static) &&
7365 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7366 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007367 // Cannot use isPIEDefault here since otherwise
7368 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007369 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007370
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007371 ArgStringList CmdArgs;
7372
Rafael Espindolad1002f62010-11-15 18:28:16 +00007373 // Silence warning for "clang -g foo.o -o foo"
7374 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007375 // and "clang -emit-llvm foo.o -o foo"
7376 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007377 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007378 // handled somewhere else.
7379 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007380
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007381 if (!D.SysRoot.empty())
7382 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007383
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007384 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007385 CmdArgs.push_back("-pie");
7386
Rafael Espindola1c76c592010-11-07 22:57:16 +00007387 if (Args.hasArg(options::OPT_rdynamic))
7388 CmdArgs.push_back("-export-dynamic");
7389
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007390 if (Args.hasArg(options::OPT_s))
7391 CmdArgs.push_back("-s");
7392
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007393 for (const auto &Opt : ToolChain.ExtraOpts)
7394 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007395
7396 if (!Args.hasArg(options::OPT_static)) {
7397 CmdArgs.push_back("--eh-frame-hdr");
7398 }
7399
7400 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007401 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007402
7403 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007404 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007405 ToolChain.getArch() == llvm::Triple::armeb ||
7406 ToolChain.getArch() == llvm::Triple::thumb ||
7407 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007408 CmdArgs.push_back("-Bstatic");
7409 else
7410 CmdArgs.push_back("-static");
7411 } else if (Args.hasArg(options::OPT_shared)) {
7412 CmdArgs.push_back("-shared");
7413 }
7414
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007415 if (ToolChain.getArch() == llvm::Triple::arm ||
7416 ToolChain.getArch() == llvm::Triple::armeb ||
7417 ToolChain.getArch() == llvm::Triple::thumb ||
7418 ToolChain.getArch() == llvm::Triple::thumbeb ||
7419 (!Args.hasArg(options::OPT_static) &&
7420 !Args.hasArg(options::OPT_shared))) {
7421 CmdArgs.push_back("-dynamic-linker");
7422 CmdArgs.push_back(Args.MakeArgString(
7423 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7424 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007425
7426 CmdArgs.push_back("-o");
7427 CmdArgs.push_back(Output.getFilename());
7428
Rafael Espindola81937ec2010-12-01 01:52:43 +00007429 if (!Args.hasArg(options::OPT_nostdlib) &&
7430 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007431 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007432 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007433 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007434 if (Args.hasArg(options::OPT_pg))
7435 crt1 = "gcrt1.o";
7436 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007437 crt1 = "Scrt1.o";
7438 else
7439 crt1 = "crt1.o";
7440 }
7441 if (crt1)
7442 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007443
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007444 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7445 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007446
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007447 const char *crtbegin;
7448 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007449 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007450 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007451 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007452 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007453 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007454 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007455 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007456 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007457
7458 // Add crtfastmath.o if available and fast math is enabled.
7459 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007460 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007461
7462 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007463 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007464
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007465 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007466
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007467 for (const auto &Path : Paths)
7468 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007469
Alp Tokerce365ca2013-12-02 12:43:03 +00007470 if (D.IsUsingLTO(Args))
7471 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007472
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007473 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7474 CmdArgs.push_back("--no-demangle");
7475
Alexey Samsonov52550342014-09-15 19:58:40 +00007476 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007477 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007478 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007479 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007480
Hans Wennborg70850d82013-07-18 20:29:38 +00007481 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007482 !Args.hasArg(options::OPT_nostdlib) &&
7483 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007484 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7485 !Args.hasArg(options::OPT_static);
7486 if (OnlyLibstdcxxStatic)
7487 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007488 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007489 if (OnlyLibstdcxxStatic)
7490 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007491 CmdArgs.push_back("-lm");
7492 }
7493
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007494 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007495 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7496 if (Args.hasArg(options::OPT_static))
7497 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007498
Alexey Samsonov52550342014-09-15 19:58:40 +00007499 if (NeedsSanitizerDeps)
7500 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7501
Alexey Bataev186b28a2014-03-06 05:43:53 +00007502 LibOpenMP UsedOpenMPLib = LibUnknown;
7503 if (Args.hasArg(options::OPT_fopenmp)) {
7504 UsedOpenMPLib = LibGOMP;
7505 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7506 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7507 .Case("libgomp", LibGOMP)
7508 .Case("libiomp5", LibIOMP5)
7509 .Default(LibUnknown);
7510 if (UsedOpenMPLib == LibUnknown)
7511 D.Diag(diag::err_drv_unsupported_option_argument)
7512 << A->getOption().getName() << A->getValue();
7513 }
7514 switch (UsedOpenMPLib) {
7515 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007516 CmdArgs.push_back("-lgomp");
7517
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007518 // FIXME: Exclude this for platforms with libgomp that don't require
7519 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007520 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007521 break;
7522 case LibIOMP5:
7523 CmdArgs.push_back("-liomp5");
7524 break;
7525 case LibUnknown:
7526 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007527 }
Renato Golinc4b49242014-02-13 10:01:16 +00007528 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007529
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007530 if ((Args.hasArg(options::OPT_pthread) ||
7531 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7532 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007533 CmdArgs.push_back("-lpthread");
7534
7535 CmdArgs.push_back("-lc");
7536
7537 if (Args.hasArg(options::OPT_static))
7538 CmdArgs.push_back("--end-group");
7539 else
Renato Golinc4b49242014-02-13 10:01:16 +00007540 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007541 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007542
Rafael Espindola81937ec2010-12-01 01:52:43 +00007543 if (!Args.hasArg(options::OPT_nostartfiles)) {
7544 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007545 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007546 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007547 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007548 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007549 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007550 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007551
Rafael Espindola81937ec2010-12-01 01:52:43 +00007552 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007553 if (!isAndroid)
7554 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007555 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007556 }
7557
David Blaikiec11bf802014-09-04 16:04:28 +00007558 C.addCommand(
7559 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007560}
7561
Chris Lattner3e2ee142010-07-07 16:01:42 +00007562void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007563 const InputInfo &Output,
7564 const InputInfoList &Inputs,
7565 const ArgList &Args,
7566 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007567 ArgStringList CmdArgs;
7568
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007569 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007570
7571 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007572 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007573
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007574 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007575 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007576
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007577 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007578 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007579}
7580
7581void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007582 const InputInfo &Output,
7583 const InputInfoList &Inputs,
7584 const ArgList &Args,
7585 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007586 const Driver &D = getToolChain().getDriver();
7587 ArgStringList CmdArgs;
7588
Daniel Dunbarb440f562010-08-02 02:38:21 +00007589 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007590 CmdArgs.push_back("-o");
7591 CmdArgs.push_back(Output.getFilename());
7592 } else {
7593 assert(Output.isNothing() && "Invalid output.");
7594 }
7595
7596 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007597 !Args.hasArg(options::OPT_nostartfiles)) {
7598 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7599 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7600 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7601 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7602 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007603
7604 Args.AddAllArgs(CmdArgs, options::OPT_L);
7605 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7606 Args.AddAllArgs(CmdArgs, options::OPT_e);
7607
Daniel Dunbar54423b22010-09-17 00:24:54 +00007608 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007609
Alexey Samsonov7811d192014-02-20 13:57:37 +00007610 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007611
Chris Lattner3e2ee142010-07-07 16:01:42 +00007612 if (!Args.hasArg(options::OPT_nostdlib) &&
7613 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007614 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007615 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007616 CmdArgs.push_back("-lm");
7617 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007618 }
7619
7620 if (!Args.hasArg(options::OPT_nostdlib) &&
7621 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007622 if (Args.hasArg(options::OPT_pthread))
7623 CmdArgs.push_back("-lpthread");
7624 CmdArgs.push_back("-lc");
7625 CmdArgs.push_back("-lCompilerRT-Generic");
7626 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7627 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007628 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007629 }
7630
Logan Chieneb9162f2014-06-26 14:23:45 +00007631 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007632 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007633}
7634
Daniel Dunbarcc912342009-05-02 18:28:39 +00007635/// DragonFly Tools
7636
7637// For now, DragonFly Assemble does just about the same as for
7638// FreeBSD, but this may change soon.
7639void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007640 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007641 const InputInfoList &Inputs,
7642 const ArgList &Args,
7643 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007644 ArgStringList CmdArgs;
7645
7646 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7647 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007648 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007649 CmdArgs.push_back("--32");
7650
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007651 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007652
7653 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007654 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007655
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007656 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007657 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007658
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007659 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007660 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007661}
7662
7663void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007664 const InputInfo &Output,
7665 const InputInfoList &Inputs,
7666 const ArgList &Args,
7667 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007668 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007669 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00007670 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00007671
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007672 if (!D.SysRoot.empty())
7673 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7674
John McCall65b8da02013-04-11 22:55:55 +00007675 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007676 if (Args.hasArg(options::OPT_static)) {
7677 CmdArgs.push_back("-Bstatic");
7678 } else {
John McCall65b8da02013-04-11 22:55:55 +00007679 if (Args.hasArg(options::OPT_rdynamic))
7680 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007681 if (Args.hasArg(options::OPT_shared))
7682 CmdArgs.push_back("-Bshareable");
7683 else {
7684 CmdArgs.push_back("-dynamic-linker");
7685 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7686 }
John McCall65b8da02013-04-11 22:55:55 +00007687 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007688 }
7689
7690 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7691 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007692 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007693 CmdArgs.push_back("-m");
7694 CmdArgs.push_back("elf_i386");
7695 }
7696
Daniel Dunbarb440f562010-08-02 02:38:21 +00007697 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007698 CmdArgs.push_back("-o");
7699 CmdArgs.push_back(Output.getFilename());
7700 } else {
7701 assert(Output.isNothing() && "Invalid output.");
7702 }
7703
7704 if (!Args.hasArg(options::OPT_nostdlib) &&
7705 !Args.hasArg(options::OPT_nostartfiles)) {
7706 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007707 if (Args.hasArg(options::OPT_pg))
7708 CmdArgs.push_back(Args.MakeArgString(
7709 getToolChain().GetFilePath("gcrt1.o")));
7710 else {
7711 if (Args.hasArg(options::OPT_pie))
7712 CmdArgs.push_back(Args.MakeArgString(
7713 getToolChain().GetFilePath("Scrt1.o")));
7714 else
7715 CmdArgs.push_back(Args.MakeArgString(
7716 getToolChain().GetFilePath("crt1.o")));
7717 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007718 }
John McCall65b8da02013-04-11 22:55:55 +00007719 CmdArgs.push_back(Args.MakeArgString(
7720 getToolChain().GetFilePath("crti.o")));
7721 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7722 CmdArgs.push_back(Args.MakeArgString(
7723 getToolChain().GetFilePath("crtbeginS.o")));
7724 else
7725 CmdArgs.push_back(Args.MakeArgString(
7726 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007727 }
7728
7729 Args.AddAllArgs(CmdArgs, options::OPT_L);
7730 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7731 Args.AddAllArgs(CmdArgs, options::OPT_e);
7732
Daniel Dunbar54423b22010-09-17 00:24:54 +00007733 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007734
7735 if (!Args.hasArg(options::OPT_nostdlib) &&
7736 !Args.hasArg(options::OPT_nodefaultlibs)) {
7737 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7738 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007739 if (UseGCC47)
7740 CmdArgs.push_back("-L/usr/lib/gcc47");
7741 else
7742 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007743
7744 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007745 if (UseGCC47) {
7746 CmdArgs.push_back("-rpath");
7747 CmdArgs.push_back("/usr/lib/gcc47");
7748 } else {
7749 CmdArgs.push_back("-rpath");
7750 CmdArgs.push_back("/usr/lib/gcc44");
7751 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007752 }
7753
Hans Wennborg70850d82013-07-18 20:29:38 +00007754 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007755 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007756 CmdArgs.push_back("-lm");
7757 }
7758
Daniel Dunbarcc912342009-05-02 18:28:39 +00007759 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007760 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007761
7762 if (!Args.hasArg(options::OPT_nolibc)) {
7763 CmdArgs.push_back("-lc");
7764 }
7765
John McCall65b8da02013-04-11 22:55:55 +00007766 if (UseGCC47) {
7767 if (Args.hasArg(options::OPT_static) ||
7768 Args.hasArg(options::OPT_static_libgcc)) {
7769 CmdArgs.push_back("-lgcc");
7770 CmdArgs.push_back("-lgcc_eh");
7771 } else {
7772 if (Args.hasArg(options::OPT_shared_libgcc)) {
7773 CmdArgs.push_back("-lgcc_pic");
7774 if (!Args.hasArg(options::OPT_shared))
7775 CmdArgs.push_back("-lgcc");
7776 } else {
7777 CmdArgs.push_back("-lgcc");
7778 CmdArgs.push_back("--as-needed");
7779 CmdArgs.push_back("-lgcc_pic");
7780 CmdArgs.push_back("--no-as-needed");
7781 }
7782 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007783 } else {
John McCall65b8da02013-04-11 22:55:55 +00007784 if (Args.hasArg(options::OPT_shared)) {
7785 CmdArgs.push_back("-lgcc_pic");
7786 } else {
7787 CmdArgs.push_back("-lgcc");
7788 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007789 }
7790 }
7791
7792 if (!Args.hasArg(options::OPT_nostdlib) &&
7793 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007794 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007795 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007796 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007797 else
7798 CmdArgs.push_back(Args.MakeArgString(
7799 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007800 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007801 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007802 }
7803
Alexey Samsonov7811d192014-02-20 13:57:37 +00007804 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007805
Logan Chieneb9162f2014-06-26 14:23:45 +00007806 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007807 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007808}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007809
Alexey Samsonov6424e022014-05-12 20:20:20 +00007810static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7811 ArgStringList &CmdArgs,
Craig Topperbf3e3272014-08-30 16:55:52 +00007812 StringRef RTName) {
Alexey Samsonov6424e022014-05-12 20:20:20 +00007813 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7814 llvm::sys::path::append(LibSanitizer,
7815 Twine("clang_rt.") + RTName + ".lib");
7816 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7817}
7818
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00007819// Try to find Exe from a Visual Studio distribution. This first tries to find
7820// an installed copy of Visual Studio and, failing that, looks in the PATH,
7821// making sure that whatever executable that's found is not a same-named exe
7822// from clang itself to prevent clang from falling back to itself.
7823static std::string FindVisualStudioExecutable(const ToolChain &TC,
7824 const char *Exe,
7825 const char *ClangProgramPath) {
7826 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
7827 std::string visualStudioBinDir;
7828 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
7829 visualStudioBinDir)) {
7830 SmallString<128> FilePath(visualStudioBinDir);
7831 llvm::sys::path::append(FilePath, Exe);
7832 if (llvm::sys::fs::can_execute(FilePath.c_str()))
7833 return FilePath.str();
7834 }
7835
7836 return Exe;
7837}
7838
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007839void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7840 const InputInfo &Output,
7841 const InputInfoList &Inputs,
7842 const ArgList &Args,
7843 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007844 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007845 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007846
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007847 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
7848 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007849 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7850 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007851
7852 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007853 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007854 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007855
Zachary Turner10d75b22014-10-22 20:40:43 +00007856 if (!llvm::sys::Process::GetEnv("LIB")) {
7857 // If the VC environment hasn't been configured (perhaps because the user
7858 // did not run vcvarsall), try to build a consistent link environment. If
7859 // the environment variable is set however, assume the user knows what he's
7860 // doing.
7861 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007862 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00007863 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
7864 SmallString<128> LibDir(VisualStudioDir);
7865 llvm::sys::path::append(LibDir, "VC", "lib");
7866 switch (MSVC.getArch()) {
7867 case llvm::Triple::x86:
7868 // x86 just puts the libraries directly in lib
7869 break;
7870 case llvm::Triple::x86_64:
7871 llvm::sys::path::append(LibDir, "amd64");
7872 break;
7873 case llvm::Triple::arm:
7874 llvm::sys::path::append(LibDir, "arm");
7875 break;
7876 default:
7877 break;
7878 }
7879 CmdArgs.push_back(
7880 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
7881 }
7882
7883 std::string WindowsSdkLibPath;
7884 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
7885 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
7886 WindowsSdkLibPath.c_str()));
7887 }
7888
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007889 CmdArgs.push_back("-nologo");
7890
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007891 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007892 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007893
Hans Wennborgf1a74252013-09-10 20:18:04 +00007894 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007895 if (DLL) {
7896 CmdArgs.push_back(Args.MakeArgString("-dll"));
7897
7898 SmallString<128> ImplibName(Output.getFilename());
7899 llvm::sys::path::replace_extension(ImplibName, "lib");
7900 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7901 ImplibName.str()));
7902 }
7903
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007904 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007905 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007906 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007907 // FIXME: Handle 64-bit.
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007908 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007909 addSanitizerRTWindows(TC, Args, CmdArgs, "asan_dynamic-i386");
7910 addSanitizerRTWindows(TC, Args, CmdArgs,
Timur Iskhodzhanov92c06012014-09-12 13:21:02 +00007911 "asan_dynamic_runtime_thunk-i386");
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00007912 // Make sure the dynamic runtime thunk is not optimized out at link time
7913 // to ensure proper SEH handling.
7914 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007915 } else if (DLL) {
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007916 addSanitizerRTWindows(TC, Args, CmdArgs, "asan_dll_thunk-i386");
Alexey Samsonov6424e022014-05-12 20:20:20 +00007917 } else {
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007918 addSanitizerRTWindows(TC, Args, CmdArgs, "asan-i386");
7919 addSanitizerRTWindows(TC, Args, CmdArgs, "asan_cxx-i386");
Alexey Samsonov6424e022014-05-12 20:20:20 +00007920 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007921 }
7922
Hans Wennborg2e274592013-08-13 23:38:57 +00007923 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007924
Reid Kleckner337188f2014-09-16 19:22:00 +00007925 // Add filenames, libraries, and other linker inputs.
7926 for (const auto &Input : Inputs) {
7927 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007928 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00007929 continue;
7930 }
7931
7932 const Arg &A = Input.getInputArg();
7933
7934 // Render -l options differently for the MSVC linker.
7935 if (A.getOption().matches(options::OPT_l)) {
7936 StringRef Lib = A.getValue();
7937 const char *LinkLibArg;
7938 if (Lib.endswith(".lib"))
7939 LinkLibArg = Args.MakeArgString(Lib);
7940 else
7941 LinkLibArg = Args.MakeArgString(Lib + ".lib");
7942 CmdArgs.push_back(LinkLibArg);
7943 continue;
7944 }
7945
7946 // Otherwise, this is some other kind of linker input option like -Wl, -z,
7947 // or -L. Render it, even if MSVC doesn't understand it.
7948 A.renderAsInput(Args, CmdArgs);
7949 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007950
Zachary Turner719f58c2014-12-01 23:06:47 +00007951 // We need to special case some linker paths. In the case of lld, we need to
7952 // translate 'lld' into 'lld-link', and in the case of the regular msvc
7953 // linker, we need to use a special search algorithm.
7954 llvm::SmallString<128> linkPath;
7955 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
7956 if (Linker.equals_lower("lld"))
7957 Linker = "lld-link";
7958
7959 if (Linker.equals_lower("link")) {
7960 // If we're using the MSVC linker, it's not sufficient to just use link
7961 // from the program PATH, because other environments like GnuWin32 install
7962 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007963 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00007964 C.getDriver().getClangProgramPath());
7965 } else {
7966 linkPath = Linker;
7967 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007968 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00007969 }
7970
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00007971 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00007972 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007973}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007974
7975void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7976 const InputInfo &Output,
7977 const InputInfoList &Inputs,
7978 const ArgList &Args,
7979 const char *LinkingOutput) const {
7980 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7981}
7982
David Blaikiec11bf802014-09-04 16:04:28 +00007983std::unique_ptr<Command> visualstudio::Compile::GetCommand(
7984 Compilation &C, const JobAction &JA, const InputInfo &Output,
7985 const InputInfoList &Inputs, const ArgList &Args,
7986 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00007987 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007988 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007989 CmdArgs.push_back("/c"); // Compile only.
7990 CmdArgs.push_back("/W0"); // No warnings.
7991
7992 // The goal is to be able to invoke this tool correctly based on
7993 // any flag accepted by clang-cl.
7994
7995 // These are spelled the same way in clang and cl.exe,.
7996 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7997 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007998
7999 // Optimization level.
8000 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8001 if (A->getOption().getID() == options::OPT_O0) {
8002 CmdArgs.push_back("/Od");
8003 } else {
8004 StringRef OptLevel = A->getValue();
8005 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8006 A->render(Args, CmdArgs);
8007 else if (OptLevel == "3")
8008 CmdArgs.push_back("/Ox");
8009 }
8010 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008011
8012 // Flags for which clang-cl have an alias.
8013 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8014
David Majnemerf6072342014-07-01 22:24:56 +00008015 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8016 /*default=*/false))
8017 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008018 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8019 options::OPT_fno_function_sections))
8020 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8021 ? "/Gy"
8022 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008023 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8024 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008025 CmdArgs.push_back(
8026 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008027 if (Args.hasArg(options::OPT_fsyntax_only))
8028 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008029 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8030 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008031
Hans Wennborg260ff402013-09-27 17:54:18 +00008032 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008033 for (const auto &Include : Includes)
8034 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008035
Hans Wennborg87cfa712013-09-19 20:32:16 +00008036 // Flags that can simply be passed through.
8037 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8038 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008039 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008040
8041 // The order of these flags is relevant, so pick the last one.
8042 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8043 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8044 A->render(Args, CmdArgs);
8045
8046
8047 // Input filename.
8048 assert(Inputs.size() == 1);
8049 const InputInfo &II = Inputs[0];
8050 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8051 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8052 if (II.isFilename())
8053 CmdArgs.push_back(II.getFilename());
8054 else
8055 II.getInputArg().renderAsInput(Args, CmdArgs);
8056
8057 // Output filename.
8058 assert(Output.getType() == types::TY_Object);
8059 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8060 Output.getFilename());
8061 CmdArgs.push_back(Fo);
8062
Hans Wennborg188382e2013-09-20 18:16:35 +00008063 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008064 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8065 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008066 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8067 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008068}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008069
8070
8071/// XCore Tools
8072// We pass assemble and link construction to the xcc tool.
8073
8074void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8075 const InputInfo &Output,
8076 const InputInfoList &Inputs,
8077 const ArgList &Args,
8078 const char *LinkingOutput) const {
8079 ArgStringList CmdArgs;
8080
8081 CmdArgs.push_back("-o");
8082 CmdArgs.push_back(Output.getFilename());
8083
8084 CmdArgs.push_back("-c");
8085
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008086 if (Args.hasArg(options::OPT_v))
8087 CmdArgs.push_back("-v");
8088
Robert Lytton894d25c2014-05-02 09:33:25 +00008089 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8090 if (!A->getOption().matches(options::OPT_g0))
8091 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008092
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008093 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8094 false))
8095 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008096
8097 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8098 options::OPT_Xassembler);
8099
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008100 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008101 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008102
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008103 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008104 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008105}
8106
8107void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8108 const InputInfo &Output,
8109 const InputInfoList &Inputs,
8110 const ArgList &Args,
8111 const char *LinkingOutput) const {
8112 ArgStringList CmdArgs;
8113
8114 if (Output.isFilename()) {
8115 CmdArgs.push_back("-o");
8116 CmdArgs.push_back(Output.getFilename());
8117 } else {
8118 assert(Output.isNothing() && "Invalid output.");
8119 }
8120
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008121 if (Args.hasArg(options::OPT_v))
8122 CmdArgs.push_back("-v");
8123
David Majnemer8de68642014-12-05 08:11:58 +00008124 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008125 CmdArgs.push_back("-fexceptions");
8126
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008127 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8128
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008129 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008130 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008131}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008132
8133void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8134 const InputInfo &Output,
8135 const InputInfoList &Inputs,
8136 const ArgList &Args,
8137 const char *LinkingOutput) const {
8138 const auto &TC =
8139 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8140 ArgStringList CmdArgs;
8141 const char *Exec;
8142
8143 switch (TC.getArch()) {
8144 default: llvm_unreachable("unsupported architecture");
8145 case llvm::Triple::arm:
8146 case llvm::Triple::thumb:
8147 break;
8148 case llvm::Triple::x86:
8149 CmdArgs.push_back("--32");
8150 break;
8151 case llvm::Triple::x86_64:
8152 CmdArgs.push_back("--64");
8153 break;
8154 }
8155
8156 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8157
8158 CmdArgs.push_back("-o");
8159 CmdArgs.push_back(Output.getFilename());
8160
8161 for (const auto &Input : Inputs)
8162 CmdArgs.push_back(Input.getFilename());
8163
8164 const std::string Assembler = TC.GetProgramPath("as");
8165 Exec = Args.MakeArgString(Assembler);
8166
8167 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8168}
8169
8170void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8171 const InputInfo &Output,
8172 const InputInfoList &Inputs,
8173 const ArgList &Args,
8174 const char *LinkingOutput) const {
8175 const auto &TC =
8176 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8177 const llvm::Triple &T = TC.getTriple();
8178 const Driver &D = TC.getDriver();
8179 SmallString<128> EntryPoint;
8180 ArgStringList CmdArgs;
8181 const char *Exec;
8182
8183 // Silence warning for "clang -g foo.o -o foo"
8184 Args.ClaimAllArgs(options::OPT_g_Group);
8185 // and "clang -emit-llvm foo.o -o foo"
8186 Args.ClaimAllArgs(options::OPT_emit_llvm);
8187 // and for "clang -w foo.o -o foo"
8188 Args.ClaimAllArgs(options::OPT_w);
8189 // Other warning options are already handled somewhere else.
8190
8191 if (!D.SysRoot.empty())
8192 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8193
8194 if (Args.hasArg(options::OPT_pie))
8195 CmdArgs.push_back("-pie");
8196 if (Args.hasArg(options::OPT_rdynamic))
8197 CmdArgs.push_back("-export-dynamic");
8198 if (Args.hasArg(options::OPT_s))
8199 CmdArgs.push_back("--strip-all");
8200
8201 CmdArgs.push_back("-m");
8202 switch (TC.getArch()) {
8203 default: llvm_unreachable("unsupported architecture");
8204 case llvm::Triple::arm:
8205 case llvm::Triple::thumb:
8206 // FIXME: this is incorrect for WinCE
8207 CmdArgs.push_back("thumb2pe");
8208 break;
8209 case llvm::Triple::x86:
8210 CmdArgs.push_back("i386pe");
8211 EntryPoint.append("_");
8212 break;
8213 case llvm::Triple::x86_64:
8214 CmdArgs.push_back("i386pep");
8215 break;
8216 }
8217
8218 if (Args.hasArg(options::OPT_shared)) {
8219 switch (T.getArch()) {
8220 default: llvm_unreachable("unsupported architecture");
8221 case llvm::Triple::arm:
8222 case llvm::Triple::thumb:
8223 case llvm::Triple::x86_64:
8224 EntryPoint.append("_DllMainCRTStartup");
8225 break;
8226 case llvm::Triple::x86:
8227 EntryPoint.append("_DllMainCRTStartup@12");
8228 break;
8229 }
8230
8231 CmdArgs.push_back("-shared");
8232 CmdArgs.push_back("-Bdynamic");
8233
8234 CmdArgs.push_back("--enable-auto-image-base");
8235
8236 CmdArgs.push_back("--entry");
8237 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8238 } else {
8239 EntryPoint.append("mainCRTStartup");
8240
8241 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
8242 : "-Bdynamic");
8243
8244 if (!Args.hasArg(options::OPT_nostdlib) &&
8245 !Args.hasArg(options::OPT_nostartfiles)) {
8246 CmdArgs.push_back("--entry");
8247 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8248 }
8249
8250 // FIXME: handle subsystem
8251 }
8252
8253 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00008254 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008255
8256 CmdArgs.push_back("-o");
8257 CmdArgs.push_back(Output.getFilename());
8258
8259 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
8260 SmallString<261> ImpLib(Output.getFilename());
8261 llvm::sys::path::replace_extension(ImpLib, ".lib");
8262
8263 CmdArgs.push_back("--out-implib");
8264 CmdArgs.push_back(Args.MakeArgString(ImpLib));
8265 }
8266
8267 if (!Args.hasArg(options::OPT_nostdlib) &&
8268 !Args.hasArg(options::OPT_nostartfiles)) {
8269 const std::string CRTPath(D.SysRoot + "/usr/lib/");
8270 const char *CRTBegin;
8271
8272 CRTBegin =
8273 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
8274 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
8275 }
8276
8277 Args.AddAllArgs(CmdArgs, options::OPT_L);
8278
8279 const auto &Paths = TC.getFilePaths();
8280 for (const auto &Path : Paths)
8281 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8282
8283 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
8284
8285 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8286 !Args.hasArg(options::OPT_nodefaultlibs)) {
8287 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
8288 !Args.hasArg(options::OPT_static);
8289 if (StaticCXX)
8290 CmdArgs.push_back("-Bstatic");
8291 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
8292 if (StaticCXX)
8293 CmdArgs.push_back("-Bdynamic");
8294 }
8295
8296 if (!Args.hasArg(options::OPT_nostdlib)) {
8297 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8298 // TODO handle /MT[d] /MD[d]
8299 CmdArgs.push_back("-lmsvcrt");
8300 AddRunTimeLibs(TC, D, CmdArgs, Args);
8301 }
8302 }
8303
8304 const std::string Linker = TC.GetProgramPath("ld");
8305 Exec = Args.MakeArgString(Linker);
8306
8307 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8308}