blob: de2afd55ead5e24f65d7cca0b6e7387690630e78 [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 Abdulrasool61770ab2015-01-02 21:47:33 +00002106 // FIXME: handle 64-bit
2107 if (TC.getTriple().isOSWindows() &&
2108 !TC.getTriple().isWindowsItaniumEnvironment())
2109 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002110 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002111 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002112 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002113}
2114
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002115static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2116 // The runtimes are located in the OS-specific resource directory.
2117 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002118 const llvm::Triple &Triple = TC.getTriple();
2119 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002120 StringRef OSLibName =
2121 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002122 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002123 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002124}
2125
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002126static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
2127 bool Shared = false,
2128 const char *Env = "") {
2129 bool IsOSWindows = TC.getTriple().isOSWindows();
2130 StringRef Arch = getArchNameForCompilerRTLib(TC);
2131 const char *Prefix = IsOSWindows ? "" : "lib";
2132 const char *Suffix =
2133 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2134
2135 SmallString<128> Path = getCompilerRTLibDir(TC);
2136 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2137 Arch + Env + Suffix);
2138
2139 return Path;
2140}
2141
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002142// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002143// FIXME: Make sure we can also emit shared objects if they're requested
2144// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002145static void addClangRT(const ToolChain &TC, const ArgList &Args,
2146 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002147 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002148
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002149 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002150 // FIXME: why do we link against gcc when we are using compiler-rt?
2151 CmdArgs.push_back("-lgcc_s");
2152 if (TC.getDriver().CCCIsCXX())
2153 CmdArgs.push_back("-lgcc_eh");
2154 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002155}
2156
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002157static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2158 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002159 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2160 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002161 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002162 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002163 Args.hasArg(options::OPT_fcreate_profile) ||
2164 Args.hasArg(options::OPT_coverage)))
2165 return;
2166
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002167 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002168}
2169
Alexey Samsonov52550342014-09-15 19:58:40 +00002170static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2171 ArgStringList &CmdArgs, StringRef Sanitizer,
2172 bool IsShared) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002173 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2174 ? "-android"
2175 : "";
2176
Alexey Samsonov52550342014-09-15 19:58:40 +00002177 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002178 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002179 if (!IsShared)
2180 CmdArgs.push_back("-whole-archive");
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002181 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared,
2182 Env)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002183 if (!IsShared)
2184 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002185}
2186
Alexey Samsonov52550342014-09-15 19:58:40 +00002187// Tries to use a file with the list of dynamic symbols that need to be exported
2188// from the runtime library. Returns true if the file was found.
2189static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2190 ArgStringList &CmdArgs,
2191 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002192 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2193 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2194 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002195 return true;
2196 }
2197 return false;
2198}
2199
2200static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2201 ArgStringList &CmdArgs) {
2202 // Force linking against the system libraries sanitizers depends on
2203 // (see PR15823 why this is necessary).
2204 CmdArgs.push_back("--no-as-needed");
2205 CmdArgs.push_back("-lpthread");
2206 CmdArgs.push_back("-lrt");
2207 CmdArgs.push_back("-lm");
2208 // There's no libdl on FreeBSD.
2209 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2210 CmdArgs.push_back("-ldl");
2211}
2212
2213static void
2214collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2215 SmallVectorImpl<StringRef> &SharedRuntimes,
2216 SmallVectorImpl<StringRef> &StaticRuntimes,
2217 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2218 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2219 // Collect shared runtimes.
2220 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2221 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002222 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002223
Alexey Samsonov52550342014-09-15 19:58:40 +00002224 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002225 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002226 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2227 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002228 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002229 }
2230 if (SanArgs.needsAsanRt()) {
2231 if (SanArgs.needsSharedAsanRt()) {
2232 HelperStaticRuntimes.push_back("asan-preinit");
2233 } else {
2234 StaticRuntimes.push_back("asan");
2235 if (SanArgs.linkCXXRuntimes())
2236 StaticRuntimes.push_back("asan_cxx");
2237 }
2238 }
2239 if (SanArgs.needsDfsanRt())
2240 StaticRuntimes.push_back("dfsan");
2241 if (SanArgs.needsLsanRt())
2242 StaticRuntimes.push_back("lsan");
2243 if (SanArgs.needsMsanRt())
2244 StaticRuntimes.push_back("msan");
2245 if (SanArgs.needsTsanRt())
2246 StaticRuntimes.push_back("tsan");
2247 // WARNING: UBSan should always go last.
2248 if (SanArgs.needsUbsanRt()) {
2249 // If UBSan is not combined with another sanitizer, we need to pull in
2250 // sanitizer_common explicitly.
2251 if (StaticRuntimes.empty())
2252 HelperStaticRuntimes.push_back("san");
2253 StaticRuntimes.push_back("ubsan");
2254 if (SanArgs.linkCXXRuntimes())
2255 StaticRuntimes.push_back("ubsan_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002256 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002257}
2258
Alexey Samsonov52550342014-09-15 19:58:40 +00002259// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2260// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2261static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002262 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002263 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2264 HelperStaticRuntimes;
2265 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2266 HelperStaticRuntimes);
2267 for (auto RT : SharedRuntimes)
2268 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2269 for (auto RT : HelperStaticRuntimes)
2270 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2271 bool AddExportDynamic = false;
2272 for (auto RT : StaticRuntimes) {
2273 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2274 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2275 }
2276 // If there is a static runtime with no dynamic list, force all the symbols
2277 // to be dynamic to be sure we export sanitizer interface functions.
2278 if (AddExportDynamic)
2279 CmdArgs.push_back("-export-dynamic");
2280 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002281}
2282
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002283static bool shouldUseFramePointerForTarget(const ArgList &Args,
2284 const llvm::Triple &Triple) {
2285 switch (Triple.getArch()) {
2286 // Don't use a frame pointer on linux if optimizing for certain targets.
2287 case llvm::Triple::mips64:
2288 case llvm::Triple::mips64el:
2289 case llvm::Triple::mips:
2290 case llvm::Triple::mipsel:
2291 case llvm::Triple::systemz:
2292 case llvm::Triple::x86:
2293 case llvm::Triple::x86_64:
2294 if (Triple.isOSLinux())
2295 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2296 if (!A->getOption().matches(options::OPT_O0))
2297 return false;
2298 return true;
2299 case llvm::Triple::xcore:
2300 return false;
2301 default:
2302 return true;
2303 }
2304}
2305
Rafael Espindola224dd632011-12-14 21:02:23 +00002306static bool shouldUseFramePointer(const ArgList &Args,
2307 const llvm::Triple &Triple) {
2308 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2309 options::OPT_fomit_frame_pointer))
2310 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2311
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002312 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002313}
2314
Eric Christopherb7d97e92013-04-03 01:58:53 +00002315static bool shouldUseLeafFramePointer(const ArgList &Args,
2316 const llvm::Triple &Triple) {
2317 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2318 options::OPT_momit_leaf_frame_pointer))
2319 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2320
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002321 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002322}
2323
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002324/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002325static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002326 SmallString<128> cwd;
2327 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002328 CmdArgs.push_back("-fdebug-compilation-dir");
2329 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002330 }
2331}
2332
Eric Christopherd3804002013-02-22 20:12:52 +00002333static const char *SplitDebugName(const ArgList &Args,
2334 const InputInfoList &Inputs) {
2335 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2336 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2337 SmallString<128> T(FinalOutput->getValue());
2338 llvm::sys::path::replace_extension(T, "dwo");
2339 return Args.MakeArgString(T);
2340 } else {
2341 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002342 SmallString<128> T(
2343 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002344 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2345 llvm::sys::path::replace_extension(F, "dwo");
2346 T += F;
2347 return Args.MakeArgString(F);
2348 }
2349}
2350
2351static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2352 const Tool &T, const JobAction &JA,
2353 const ArgList &Args, const InputInfo &Output,
2354 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002355 ArgStringList ExtractArgs;
2356 ExtractArgs.push_back("--extract-dwo");
2357
2358 ArgStringList StripArgs;
2359 StripArgs.push_back("--strip-dwo");
2360
2361 // Grabbing the output of the earlier compile step.
2362 StripArgs.push_back(Output.getFilename());
2363 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002364 ExtractArgs.push_back(OutFile);
2365
2366 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002367 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002368
2369 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002370 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002371
2372 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002373 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002374}
2375
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002376/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002377/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2378static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002379 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002380 if (A->getOption().matches(options::OPT_O4) ||
2381 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002382 return true;
2383
2384 if (A->getOption().matches(options::OPT_O0))
2385 return false;
2386
2387 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2388
Rafael Espindola91780de2013-08-26 14:05:41 +00002389 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002390 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002391 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002392 return true;
2393
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002394 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002395 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002396 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002397
2398 unsigned OptLevel = 0;
2399 if (S.getAsInteger(10, OptLevel))
2400 return false;
2401
2402 return OptLevel > 1;
2403 }
2404
2405 return false;
2406}
2407
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002408/// Add -x lang to \p CmdArgs for \p Input.
2409static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2410 ArgStringList &CmdArgs) {
2411 // When using -verify-pch, we don't want to provide the type
2412 // 'precompiled-header' if it was inferred from the file extension
2413 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2414 return;
2415
2416 CmdArgs.push_back("-x");
2417 if (Args.hasArg(options::OPT_rewrite_objc))
2418 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2419 else
2420 CmdArgs.push_back(types::getTypeName(Input.getType()));
2421}
2422
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002423static std::string getMSCompatibilityVersion(const char *VersionStr) {
2424 unsigned Version;
2425 if (StringRef(VersionStr).getAsInteger(10, Version))
2426 return "0";
2427
2428 if (Version < 100)
2429 return llvm::utostr_32(Version) + ".0";
2430
2431 if (Version < 10000)
2432 return llvm::utostr_32(Version / 100) + "." +
2433 llvm::utostr_32(Version % 100);
2434
2435 unsigned Build = 0, Factor = 1;
2436 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2437 Build = Build + (Version % 10) * Factor;
2438 return llvm::utostr_32(Version / 100) + "." +
2439 llvm::utostr_32(Version % 100) + "." +
2440 llvm::utostr_32(Build);
2441}
2442
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002443void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002444 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002445 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002446 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002447 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002448 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2449 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002450 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002451 ArgStringList CmdArgs;
2452
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002453 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002454 bool IsWindowsCygnus =
2455 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002456 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2457
Daniel Dunbare521a892009-03-31 20:53:55 +00002458 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2459
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002460 // Invoke ourselves in -cc1 mode.
2461 //
2462 // FIXME: Implement custom jobs for internal actions.
2463 CmdArgs.push_back("-cc1");
2464
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002465 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002466 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002467 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002468 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002469
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002470 const llvm::Triple TT(TripleStr);
2471 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2472 TT.getArch() == llvm::Triple::thumb)) {
2473 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2474 unsigned Version;
2475 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2476 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002477 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2478 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002479 }
2480
Tim Northover336f1892014-03-29 13:16:12 +00002481 // Push all default warning arguments that are specific to
2482 // the given target. These come before user provided warning options
2483 // are provided.
2484 getToolChain().addClangWarningOptions(CmdArgs);
2485
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002486 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002487 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002488
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002489 if (isa<AnalyzeJobAction>(JA)) {
2490 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2491 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002492 } else if (isa<MigrateJobAction>(JA)) {
2493 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002494 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002495 if (Output.getType() == types::TY_Dependencies)
2496 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002497 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002498 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002499 if (Args.hasArg(options::OPT_rewrite_objc) &&
2500 !Args.hasArg(options::OPT_g_Group))
2501 CmdArgs.push_back("-P");
2502 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002503 } else if (isa<AssembleJobAction>(JA)) {
2504 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002505
David Blaikie9260ed62013-07-25 21:19:01 +00002506 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002507
2508 // Also ignore explicit -force_cpusubtype_ALL option.
2509 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002510 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002511 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002512 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002513
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002514 if (JA.getType() == types::TY_Nothing)
2515 CmdArgs.push_back("-fsyntax-only");
2516 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002517 CmdArgs.push_back("-emit-pch");
2518 else
2519 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002520 } else if (isa<VerifyPCHJobAction>(JA)) {
2521 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002522 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002523 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2524 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002525
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002526 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002527 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002528 } else if (JA.getType() == types::TY_LLVM_IR ||
2529 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002530 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002531 } else if (JA.getType() == types::TY_LLVM_BC ||
2532 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002533 CmdArgs.push_back("-emit-llvm-bc");
2534 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002535 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002536 } else if (JA.getType() == types::TY_AST) {
2537 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002538 } else if (JA.getType() == types::TY_ModuleFile) {
2539 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002540 } else if (JA.getType() == types::TY_RewrittenObjC) {
2541 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002542 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002543 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2544 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002545 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002546 } else {
2547 assert(JA.getType() == types::TY_PP_Asm &&
2548 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002549 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002550 }
2551
Justin Bognera88f0122014-06-20 22:59:50 +00002552 // We normally speed up the clang process a bit by skipping destructors at
2553 // exit, but when we're generating diagnostics we can rely on some of the
2554 // cleanup.
2555 if (!C.isForDiagnostics())
2556 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002557
John McCallbb79b5f2010-02-13 03:50:24 +00002558 // Disable the verification pass in -asserts builds.
2559#ifdef NDEBUG
2560 CmdArgs.push_back("-disable-llvm-verifier");
2561#endif
2562
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002563 // Set the main file name, so that debug info works even with
2564 // -save-temps.
2565 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002566 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002567
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002568 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002569 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002570 if (Args.hasArg(options::OPT_static))
2571 CmdArgs.push_back("-static-define");
2572
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002573 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002574 // Enable region store model by default.
2575 CmdArgs.push_back("-analyzer-store=region");
2576
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002577 // Treat blocks as analysis entry points.
2578 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2579
Ted Kremenek49c79792011-03-24 00:28:47 +00002580 CmdArgs.push_back("-analyzer-eagerly-assume");
2581
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002582 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002583 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002584 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002585
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002586 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002587 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002588
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002589 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002590 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002591
2592 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002593
Jordan Rose10ad0812013-04-05 17:55:07 +00002594 if (types::isCXX(Inputs[0].getType()))
2595 CmdArgs.push_back("-analyzer-checker=cplusplus");
2596
Nico Webere8e53112014-05-11 01:04:02 +00002597 // Enable the following experimental checkers for testing.
2598 CmdArgs.push_back(
2599 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002600 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2601 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2602 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2603 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2604 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002605 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002606
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002607 // Set the output format. The default is plist, for (lame) historical
2608 // reasons.
2609 CmdArgs.push_back("-analyzer-output");
2610 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002611 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002612 else
2613 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002614
Ted Kremenekfe449a22010-03-22 22:32:05 +00002615 // Disable the presentation of standard compiler warnings when
2616 // using --analyze. We only want to show static analyzer diagnostics
2617 // or frontend errors.
2618 CmdArgs.push_back("-w");
2619
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002620 // Add -Xanalyzer arguments when running as analyzer.
2621 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002622 }
2623
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002624 CheckCodeGenerationOptions(D, Args);
2625
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002626 bool PIE = getToolChain().isPIEDefault();
2627 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002628 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002629
Alexey Bataev40e75222014-01-28 06:30:35 +00002630 // Android-specific defaults for PIC/PIE
2631 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2632 switch (getToolChain().getTriple().getArch()) {
2633 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002634 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002635 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002636 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002637 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002638 case llvm::Triple::mips:
2639 case llvm::Triple::mipsel:
2640 case llvm::Triple::mips64:
2641 case llvm::Triple::mips64el:
2642 PIC = true; // "-fpic"
2643 break;
2644
2645 case llvm::Triple::x86:
2646 case llvm::Triple::x86_64:
2647 PIC = true; // "-fPIC"
2648 IsPICLevelTwo = true;
2649 break;
2650
2651 default:
2652 break;
2653 }
2654 }
2655
Brad Smith5b05db82014-06-24 19:51:29 +00002656 // OpenBSD-specific defaults for PIE
2657 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2658 switch (getToolChain().getTriple().getArch()) {
2659 case llvm::Triple::mips64:
2660 case llvm::Triple::mips64el:
2661 case llvm::Triple::sparc:
2662 case llvm::Triple::x86:
2663 case llvm::Triple::x86_64:
2664 IsPICLevelTwo = false; // "-fpie"
2665 break;
2666
2667 case llvm::Triple::ppc:
2668 case llvm::Triple::sparcv9:
2669 IsPICLevelTwo = true; // "-fPIE"
2670 break;
2671
2672 default:
2673 break;
2674 }
2675 }
2676
Alexey Samsonov090301e2013-04-09 12:28:19 +00002677 // For the PIC and PIE flag options, this logic is different from the
2678 // legacy logic in very old versions of GCC, as that logic was just
2679 // a bug no one had ever fixed. This logic is both more rational and
2680 // consistent with GCC's new logic now that the bugs are fixed. The last
2681 // argument relating to either PIC or PIE wins, and no other argument is
2682 // used. If the last argument is any flavor of the '-fno-...' arguments,
2683 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2684 // at the same level.
2685 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2686 options::OPT_fpic, options::OPT_fno_pic,
2687 options::OPT_fPIE, options::OPT_fno_PIE,
2688 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002689 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2690 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002691 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002692 if (LastPICArg) {
2693 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002694 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2695 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2696 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2697 PIC = PIE || O.matches(options::OPT_fPIC) ||
2698 O.matches(options::OPT_fpic);
2699 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2700 O.matches(options::OPT_fPIC);
2701 } else {
2702 PIE = PIC = false;
2703 }
2704 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002705 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002706
Nick Lewycky609dd662013-10-11 03:33:53 +00002707 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002708 // specified while enabling PIC enabled level 1 PIC, just force it back to
2709 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2710 // informal testing).
2711 if (PIC && getToolChain().getTriple().isOSDarwin())
2712 IsPICLevelTwo |= getToolChain().isPICDefault();
2713
Chandler Carruthc0c04552012-04-08 16:40:35 +00002714 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2715 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002716 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00002717 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002718 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002719 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002720 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002721
Chandler Carruth76a943b2012-11-19 03:52:03 +00002722 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2723 // This is a very special mode. It trumps the other modes, almost no one
2724 // uses it, and it isn't even valid on any OS but Darwin.
2725 if (!getToolChain().getTriple().isOSDarwin())
2726 D.Diag(diag::err_drv_unsupported_opt_for_target)
2727 << A->getSpelling() << getToolChain().getTriple().str();
2728
2729 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2730
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002731 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002732 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002733
Chandler Carruth76a943b2012-11-19 03:52:03 +00002734 // Only a forced PIC mode can cause the actual compile to have PIC defines
2735 // etc., no flags are sufficient. This behavior was selected to closely
2736 // match that of llvm-gcc and Apple GCC before that.
2737 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2738 CmdArgs.push_back("-pic-level");
2739 CmdArgs.push_back("2");
2740 }
2741 } else {
2742 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2743 // handled in Clang's IRGen by the -pie-level flag.
2744 CmdArgs.push_back("-mrelocation-model");
2745 CmdArgs.push_back(PIC ? "pic" : "static");
2746
2747 if (PIC) {
2748 CmdArgs.push_back("-pic-level");
2749 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2750 if (PIE) {
2751 CmdArgs.push_back("-pie-level");
2752 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2753 }
2754 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002755 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002756
Jonathan Roelofsb140a102014-10-03 21:57:44 +00002757 CmdArgs.push_back("-mthread-model");
2758 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2759 CmdArgs.push_back(A->getValue());
2760 else
2761 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2762
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002763 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2764 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002765 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002766
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002767 // LLVM Code Generator Options.
2768
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002769 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2770 StringRef v = A->getValue();
2771 CmdArgs.push_back("-mllvm");
2772 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2773 A->claim();
2774 }
2775
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002776 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2777 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002778 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002779 }
2780
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002781 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2782 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002783 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002784 D.Diag(diag::err_drv_unsupported_opt_for_target)
2785 << A->getSpelling() << getToolChain().getTriple().str();
2786 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2787 CmdArgs.push_back("-fpcc-struct-return");
2788 } else {
2789 assert(A->getOption().matches(options::OPT_freg_struct_return));
2790 CmdArgs.push_back("-freg-struct-return");
2791 }
2792 }
2793
Roman Divacky65b88cd2011-03-01 17:40:53 +00002794 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2795 CmdArgs.push_back("-mrtd");
2796
Rafael Espindola224dd632011-12-14 21:02:23 +00002797 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002798 CmdArgs.push_back("-mdisable-fp-elim");
2799 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2800 options::OPT_fno_zero_initialized_in_bss))
2801 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002802
2803 bool OFastEnabled = isOptimizationLevelFast(Args);
2804 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2805 // enabled. This alias option is being used to simplify the hasFlag logic.
2806 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2807 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002808 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2809 // doesn't do any TBAA.
2810 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002811 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002812 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002813 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002814 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2815 options::OPT_fno_struct_path_tbaa))
2816 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002817 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2818 false))
2819 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002820 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2821 options::OPT_fno_optimize_sibling_calls))
2822 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002823
Eric Christopher006208c2013-04-04 06:29:47 +00002824 // Handle segmented stacks.
2825 if (Args.hasArg(options::OPT_fsplit_stack))
2826 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002827
2828 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2829 // This alias option is being used to simplify the getLastArg logic.
2830 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2831 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002832
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002833 // Handle various floating point optimization flags, mapping them to the
2834 // appropriate LLVM code generation flags. The pattern for all of these is to
2835 // default off the codegen optimizations, and if any flag enables them and no
2836 // flag disables them after the flag enabling them, enable the codegen
2837 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002838 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002839 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002840 options::OPT_ffinite_math_only,
2841 options::OPT_fno_finite_math_only,
2842 options::OPT_fhonor_infinities,
2843 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002844 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2845 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002846 A->getOption().getID() != options::OPT_fhonor_infinities)
2847 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002848 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002849 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002850 options::OPT_ffinite_math_only,
2851 options::OPT_fno_finite_math_only,
2852 options::OPT_fhonor_nans,
2853 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002854 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2855 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002856 A->getOption().getID() != options::OPT_fhonor_nans)
2857 CmdArgs.push_back("-menable-no-nans");
2858
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002859 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2860 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002861 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002862 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002863 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002864 options::OPT_fno_math_errno)) {
2865 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2866 // However, turning *off* -ffast_math merely restores the toolchain default
2867 // (which may be false).
2868 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2869 A->getOption().getID() == options::OPT_ffast_math ||
2870 A->getOption().getID() == options::OPT_Ofast)
2871 MathErrno = false;
2872 else if (A->getOption().getID() == options::OPT_fmath_errno)
2873 MathErrno = true;
2874 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002875 if (MathErrno)
2876 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002877
2878 // There are several flags which require disabling very specific
2879 // optimizations. Any of these being disabled forces us to turn off the
2880 // entire set of LLVM optimizations, so collect them through all the flag
2881 // madness.
2882 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002883 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002884 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002885 options::OPT_funsafe_math_optimizations,
2886 options::OPT_fno_unsafe_math_optimizations,
2887 options::OPT_fassociative_math,
2888 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002889 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2890 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002891 A->getOption().getID() != options::OPT_fno_associative_math)
2892 AssociativeMath = true;
2893 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002894 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002895 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002896 options::OPT_funsafe_math_optimizations,
2897 options::OPT_fno_unsafe_math_optimizations,
2898 options::OPT_freciprocal_math,
2899 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002900 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2901 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002902 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2903 ReciprocalMath = true;
2904 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002905 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002906 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002907 options::OPT_funsafe_math_optimizations,
2908 options::OPT_fno_unsafe_math_optimizations,
2909 options::OPT_fsigned_zeros,
2910 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002911 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2912 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002913 A->getOption().getID() != options::OPT_fsigned_zeros)
2914 SignedZeros = false;
2915 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002916 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002917 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002918 options::OPT_funsafe_math_optimizations,
2919 options::OPT_fno_unsafe_math_optimizations,
2920 options::OPT_ftrapping_math,
2921 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002922 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2923 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002924 A->getOption().getID() != options::OPT_ftrapping_math)
2925 TrappingMath = false;
2926 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2927 !TrappingMath)
2928 CmdArgs.push_back("-menable-unsafe-fp-math");
2929
Lang Hamesaa53b932012-07-06 00:59:19 +00002930
2931 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002932 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002933 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002934 options::OPT_ffp_contract)) {
2935 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002936 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002937 if (Val == "fast" || Val == "on" || Val == "off") {
2938 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2939 } else {
2940 D.Diag(diag::err_drv_unsupported_option_argument)
2941 << A->getOption().getName() << Val;
2942 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002943 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2944 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002945 // If fast-math is set then set the fp-contract mode to fast.
2946 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2947 }
2948 }
2949
Bob Wilson6a039162012-07-19 03:52:53 +00002950 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2951 // and if we find them, tell the frontend to provide the appropriate
2952 // preprocessor macros. This is distinct from enabling any optimizations as
2953 // these options induce language changes which must survive serialization
2954 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002955 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2956 options::OPT_fno_fast_math))
2957 if (!A->getOption().matches(options::OPT_fno_fast_math))
2958 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002959 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2960 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002961 if (A->getOption().matches(options::OPT_ffinite_math_only))
2962 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002963
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002964 // Decide whether to use verbose asm. Verbose assembly is the default on
2965 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002966 bool IsIntegratedAssemblerDefault =
2967 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002968 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002969 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002970 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002971 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002972
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002973 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002974 IsIntegratedAssemblerDefault))
2975 CmdArgs.push_back("-no-integrated-as");
2976
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002977 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2978 CmdArgs.push_back("-mdebug-pass");
2979 CmdArgs.push_back("Structure");
2980 }
2981 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2982 CmdArgs.push_back("-mdebug-pass");
2983 CmdArgs.push_back("Arguments");
2984 }
2985
John McCall8517abc2010-02-19 02:45:38 +00002986 // Enable -mconstructor-aliases except on darwin, where we have to
2987 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002988 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002989 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002990
John McCall7ef5cb32011-03-18 02:56:14 +00002991 // Darwin's kernel doesn't support guard variables; just die if we
2992 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002993 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002994 CmdArgs.push_back("-fforbid-guard-variables");
2995
Douglas Gregordbe39272011-02-01 15:15:22 +00002996 if (Args.hasArg(options::OPT_mms_bitfields)) {
2997 CmdArgs.push_back("-mms-bitfields");
2998 }
John McCall8517abc2010-02-19 02:45:38 +00002999
Daniel Dunbar306945d2009-09-16 06:17:29 +00003000 // This is a coarse approximation of what llvm-gcc actually does, both
3001 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3002 // complicated ways.
3003 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003004 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3005 options::OPT_fno_asynchronous_unwind_tables,
3006 (getToolChain().IsUnwindTablesDefault() ||
3007 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3008 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003009 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3010 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003011 CmdArgs.push_back("-munwind-tables");
3012
Chandler Carruth05fb5852012-11-21 23:40:23 +00003013 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003014
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003015 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3016 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003017 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003018 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003019
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003020 // FIXME: Handle -mtune=.
3021 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003022
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003023 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003024 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003025 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003026 }
3027
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003028 // Add the target cpu
3029 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3030 llvm::Triple ETriple(ETripleStr);
3031 std::string CPU = getCPUName(Args, ETriple);
3032 if (!CPU.empty()) {
3033 CmdArgs.push_back("-target-cpu");
3034 CmdArgs.push_back(Args.MakeArgString(CPU));
3035 }
3036
Rafael Espindolaeb265472013-08-21 21:59:03 +00003037 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3038 CmdArgs.push_back("-mfpmath");
3039 CmdArgs.push_back(A->getValue());
3040 }
3041
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003042 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003043 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003044
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003045 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003046 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003047 default:
3048 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003049
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003050 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003051 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003052 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003053 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003054 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003055 break;
3056
Tim Northover573cbee2014-05-24 12:52:07 +00003057 case llvm::Triple::aarch64:
3058 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003059 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003060 break;
3061
Eric Christopher0b26a612010-03-02 02:41:08 +00003062 case llvm::Triple::mips:
3063 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003064 case llvm::Triple::mips64:
3065 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003066 AddMIPSTargetArgs(Args, CmdArgs);
3067 break;
3068
Ulrich Weigand8afad612014-07-28 13:17:52 +00003069 case llvm::Triple::ppc:
3070 case llvm::Triple::ppc64:
3071 case llvm::Triple::ppc64le:
3072 AddPPCTargetArgs(Args, CmdArgs);
3073 break;
3074
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003075 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003076 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003077 AddSparcTargetArgs(Args, CmdArgs);
3078 break;
3079
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003080 case llvm::Triple::x86:
3081 case llvm::Triple::x86_64:
3082 AddX86TargetArgs(Args, CmdArgs);
3083 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003084
3085 case llvm::Triple::hexagon:
3086 AddHexagonTargetArgs(Args, CmdArgs);
3087 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003088 }
3089
Hans Wennborg75958c42013-08-08 00:17:41 +00003090 // Add clang-cl arguments.
3091 if (getToolChain().getDriver().IsCLMode())
3092 AddClangCLArgs(Args, CmdArgs);
3093
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003094 // Pass the linker version in use.
3095 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3096 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003097 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003098 }
3099
Eric Christopherb7d97e92013-04-03 01:58:53 +00003100 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003101 CmdArgs.push_back("-momit-leaf-frame-pointer");
3102
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003103 // Explicitly error on some things we know we don't support and can't just
3104 // ignore.
3105 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003106 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3107 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003108 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003109 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003110 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003111 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3112 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003113 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003114 << Unsupported->getOption().getName();
3115 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003116 }
3117
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003118 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003119 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003120 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003121 CmdArgs.push_back("-header-include-file");
3122 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3123 D.CCPrintHeadersFilename : "-");
3124 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003125 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003126 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003127
Chad Rosierbe10f982011-08-02 17:58:04 +00003128 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003129 CmdArgs.push_back("-diagnostic-log-file");
3130 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3131 D.CCLogDiagnosticsFilename : "-");
3132 }
3133
Manman Ren17bdb0f2013-11-20 20:22:14 +00003134 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3135 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003136 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003137 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003138 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3139 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003140 // FIXME: we should support specifying dwarf version with
3141 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003142 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003143 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003144 const llvm::Triple &Triple = getToolChain().getTriple();
3145 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003146 Triple.getOS() == llvm::Triple::FreeBSD ||
3147 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003148 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003149 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003150 CmdArgs.push_back("-gdwarf-2");
3151 else if (A->getOption().matches(options::OPT_gdwarf_3))
3152 CmdArgs.push_back("-gdwarf-3");
3153 else if (A->getOption().matches(options::OPT_gdwarf_4))
3154 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003155 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003156 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003157 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003158 const llvm::Triple &Triple = getToolChain().getTriple();
3159 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003160 Triple.getOS() == llvm::Triple::FreeBSD ||
3161 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003162 CmdArgs.push_back("-gdwarf-2");
3163 else
3164 CmdArgs.push_back("-g");
3165 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003166 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003167
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003168 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3169 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003170 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3171 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003172 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003173
Eric Christopher138c32b2013-09-13 22:37:55 +00003174 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003175 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3176 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003177 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003178 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003179 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003180 CmdArgs.push_back("-g");
3181 CmdArgs.push_back("-backend-option");
3182 CmdArgs.push_back("-split-dwarf=Enable");
3183 }
3184
Eric Christopher138c32b2013-09-13 22:37:55 +00003185 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3186 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3187 CmdArgs.push_back("-backend-option");
3188 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3189 }
Eric Christophereec89c22013-06-18 00:03:50 +00003190
Eric Christopher0d403d22014-02-14 01:27:03 +00003191 // -gdwarf-aranges turns on the emission of the aranges section in the
3192 // backend.
3193 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3194 CmdArgs.push_back("-backend-option");
3195 CmdArgs.push_back("-generate-arange-section");
3196 }
3197
David Blaikief36d9ba2014-01-27 18:52:43 +00003198 if (Args.hasFlag(options::OPT_fdebug_types_section,
3199 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003200 CmdArgs.push_back("-backend-option");
3201 CmdArgs.push_back("-generate-type-units");
3202 }
Eric Christophereec89c22013-06-18 00:03:50 +00003203
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003204 if (Args.hasFlag(options::OPT_ffunction_sections,
3205 options::OPT_fno_function_sections, false)) {
3206 CmdArgs.push_back("-ffunction-sections");
3207 }
3208
3209 if (Args.hasFlag(options::OPT_fdata_sections,
3210 options::OPT_fno_data_sections, false)) {
3211 CmdArgs.push_back("-fdata-sections");
3212 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003213
Chris Lattner3c77a352010-06-22 00:03:40 +00003214 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3215
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003216 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3217 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3218 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3219 D.Diag(diag::err_drv_argument_not_allowed_with)
3220 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3221
3222 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3223
3224 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3225 A->render(Args, CmdArgs);
3226 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3227 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3228
Nick Lewycky207bce32011-04-21 23:44:07 +00003229 if (Args.hasArg(options::OPT_ftest_coverage) ||
3230 Args.hasArg(options::OPT_coverage))
3231 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003232 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3233 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003234 Args.hasArg(options::OPT_coverage))
3235 CmdArgs.push_back("-femit-coverage-data");
3236
Alex Lorenzee024992014-08-04 18:41:51 +00003237 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
3238 !Args.hasArg(options::OPT_fprofile_instr_generate))
3239 D.Diag(diag::err_drv_argument_only_allowed_with)
3240 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3241
3242 if (Args.hasArg(options::OPT_fcoverage_mapping))
3243 CmdArgs.push_back("-fcoverage-mapping");
3244
Nick Lewycky480cb992011-05-04 20:46:58 +00003245 if (C.getArgs().hasArg(options::OPT_c) ||
3246 C.getArgs().hasArg(options::OPT_S)) {
3247 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003248 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003249 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003250 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003251 CoverageFilename = FinalOutput->getValue();
3252 } else {
3253 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3254 }
Nick Lewycky737a4522013-03-07 08:28:53 +00003255 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003256 SmallString<128> Pwd;
3257 if (!llvm::sys::fs::current_path(Pwd)) {
3258 llvm::sys::path::append(Pwd, CoverageFilename.str());
3259 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003260 }
3261 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003262 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003263 }
3264 }
3265
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003266 // Pass options for controlling the default header search paths.
3267 if (Args.hasArg(options::OPT_nostdinc)) {
3268 CmdArgs.push_back("-nostdsysteminc");
3269 CmdArgs.push_back("-nobuiltininc");
3270 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003271 if (Args.hasArg(options::OPT_nostdlibinc))
3272 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003273 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3274 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3275 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003276
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003277 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003278 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003279 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003280
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003281 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3282
Ted Kremenekf7639e12012-03-06 20:06:33 +00003283 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003284 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003285 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003286 options::OPT_ccc_arcmt_modify,
3287 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003288 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003289 switch (A->getOption().getID()) {
3290 default:
3291 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003292 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003293 CmdArgs.push_back("-arcmt-check");
3294 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003295 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003296 CmdArgs.push_back("-arcmt-modify");
3297 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003298 case options::OPT_ccc_arcmt_migrate:
3299 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003300 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003301 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003302
3303 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3304 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003305 break;
John McCalld70fb982011-06-15 23:25:17 +00003306 }
3307 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003308 } else {
3309 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3310 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3311 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003312 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003313
Ted Kremenekf7639e12012-03-06 20:06:33 +00003314 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3315 if (ARCMTEnabled) {
3316 D.Diag(diag::err_drv_argument_not_allowed_with)
3317 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3318 }
3319 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003320 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003321
3322 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003323 options::OPT_objcmt_migrate_subscripting,
3324 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003325 // None specified, means enable them all.
3326 CmdArgs.push_back("-objcmt-migrate-literals");
3327 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003328 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003329 } else {
3330 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3331 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003332 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003333 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003334 } else {
3335 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3336 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3337 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3338 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3339 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3340 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3341 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3342 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3343 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3344 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3345 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3346 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3347 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003348 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003349 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003350 }
3351
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003352 // Add preprocessing options like -I, -D, etc. if we are using the
3353 // preprocessor.
3354 //
3355 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003356 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003357 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003358
Rafael Espindolaa7431922011-07-21 23:40:37 +00003359 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3360 // that "The compiler can only warn and ignore the option if not recognized".
3361 // When building with ccache, it will pass -D options to clang even on
3362 // preprocessed inputs and configure concludes that -fPIC is not supported.
3363 Args.ClaimAllArgs(options::OPT_D);
3364
Alp Toker7874bdc2013-11-15 20:40:58 +00003365 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003366 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3367 if (A->getOption().matches(options::OPT_O4)) {
3368 CmdArgs.push_back("-O3");
3369 D.Diag(diag::warn_O4_is_O3);
3370 } else {
3371 A->render(Args, CmdArgs);
3372 }
3373 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003374
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003375 // Warn about ignored options to clang.
3376 for (arg_iterator it = Args.filtered_begin(
3377 options::OPT_clang_ignored_gcc_optimization_f_Group),
3378 ie = Args.filtered_end(); it != ie; ++it) {
3379 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3380 }
3381
Rafael Espindola16042fc2015-01-02 23:23:52 +00003382 // Don't warn about unused -f(no-)?lto. This can happen when we're preprocessing or
3383 // precompiling.
Chad Rosier86b82082012-12-12 20:06:31 +00003384 Args.ClaimAllArgs(options::OPT_flto);
Rafael Espindola5640ae42015-01-02 22:56:15 +00003385 Args.ClaimAllArgs(options::OPT_fno_lto);
Chad Rosier86b82082012-12-12 20:06:31 +00003386
Richard Smith3be1cb22014-08-07 00:24:21 +00003387 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003388 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003389 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3390 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003391 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003392 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003393
3394 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003395 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003396 //
3397 // If a std is supplied, only add -trigraphs if it follows the
3398 // option.
3399 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3400 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003401 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003402 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003403 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003404 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003405 else
3406 Std->render(Args, CmdArgs);
3407
Nico Weber00721502014-12-23 22:32:37 +00003408 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003409 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003410 options::OPT_ftrigraphs,
3411 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003412 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003413 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003414 } else {
3415 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003416 //
3417 // FIXME: Clang doesn't correctly handle -std= when the input language
3418 // doesn't match. For the time being just ignore this for C++ inputs;
3419 // eventually we want to do all the standard defaulting here instead of
3420 // splitting it between the driver and clang -cc1.
3421 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003422 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3423 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003424 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003425 CmdArgs.push_back("-std=c++11");
3426
Nico Weber00721502014-12-23 22:32:37 +00003427 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3428 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003429 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003430
Richard Smith282b4492013-09-04 22:50:31 +00003431 // GCC's behavior for -Wwrite-strings is a bit strange:
3432 // * In C, this "warning flag" changes the types of string literals from
3433 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3434 // for the discarded qualifier.
3435 // * In C++, this is just a normal warning flag.
3436 //
3437 // Implementing this warning correctly in C is hard, so we follow GCC's
3438 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3439 // a non-const char* in C, rather than using this crude hack.
3440 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003441 // FIXME: This should behave just like a warning flag, and thus should also
3442 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3443 Arg *WriteStrings =
3444 Args.getLastArg(options::OPT_Wwrite_strings,
3445 options::OPT_Wno_write_strings, options::OPT_w);
3446 if (WriteStrings &&
3447 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003448 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003449 }
3450
Chandler Carruth61fbf622011-04-23 09:27:53 +00003451 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003452 // during C++ compilation, which it is by default. GCC keeps this define even
3453 // in the presence of '-w', match this behavior bug-for-bug.
3454 if (types::isCXX(InputType) &&
3455 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3456 true)) {
3457 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003458 }
3459
Chandler Carruthe0391482010-05-22 02:21:53 +00003460 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3461 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3462 if (Asm->getOption().matches(options::OPT_fasm))
3463 CmdArgs.push_back("-fgnu-keywords");
3464 else
3465 CmdArgs.push_back("-fno-gnu-keywords");
3466 }
3467
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003468 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3469 CmdArgs.push_back("-fno-dwarf-directory-asm");
3470
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003471 if (ShouldDisableAutolink(Args, getToolChain()))
3472 CmdArgs.push_back("-fno-autolink");
3473
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003474 // Add in -fdebug-compilation-dir if necessary.
3475 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003476
Richard Smith9a568822011-11-21 19:36:32 +00003477 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3478 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003479 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003480 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003481 }
3482
Richard Smith79c927b2013-11-06 19:31:51 +00003483 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3484 CmdArgs.push_back("-foperator-arrow-depth");
3485 CmdArgs.push_back(A->getValue());
3486 }
3487
Richard Smith9a568822011-11-21 19:36:32 +00003488 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3489 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003490 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003491 }
3492
Richard Smitha3d3bd22013-05-08 02:12:03 +00003493 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3494 CmdArgs.push_back("-fconstexpr-steps");
3495 CmdArgs.push_back(A->getValue());
3496 }
3497
Richard Smithb3a14522013-02-22 01:59:51 +00003498 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3499 CmdArgs.push_back("-fbracket-depth");
3500 CmdArgs.push_back(A->getValue());
3501 }
3502
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003503 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3504 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003505 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003506 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003507 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3508 } else
3509 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003510 }
3511
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003512
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003513 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003514 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003515
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003516 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3517 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003518 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003519 }
David Chisnall5778fce2009-08-31 16:41:57 +00003520
Chris Lattnere23003d2010-01-09 21:54:33 +00003521 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3522 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003523 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003524 }
3525
Chris Lattnerb35583d2010-04-07 20:49:23 +00003526 CmdArgs.push_back("-ferror-limit");
3527 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003528 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003529 else
3530 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003531
Chandler Carrutha77a7272010-05-06 04:55:18 +00003532 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3533 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003534 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003535 }
3536
3537 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3538 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003539 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003540 }
3541
Richard Smithf6f003a2011-12-16 19:06:07 +00003542 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3543 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003544 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003545 }
3546
Nick Lewycky24653262014-12-16 21:39:02 +00003547 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3548 CmdArgs.push_back("-fspell-checking-limit");
3549 CmdArgs.push_back(A->getValue());
3550 }
3551
Daniel Dunbar2c978472009-11-04 06:24:47 +00003552 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003553 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003554 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003555 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003556 } else {
3557 // If -fmessage-length=N was not specified, determine whether this is a
3558 // terminal and, if so, implicitly define -fmessage-length appropriately.
3559 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003560 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003561 }
3562
John McCallb4a99d32013-02-19 01:57:35 +00003563 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3564 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3565 options::OPT_fvisibility_ms_compat)) {
3566 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3567 CmdArgs.push_back("-fvisibility");
3568 CmdArgs.push_back(A->getValue());
3569 } else {
3570 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3571 CmdArgs.push_back("-fvisibility");
3572 CmdArgs.push_back("hidden");
3573 CmdArgs.push_back("-ftype-visibility");
3574 CmdArgs.push_back("default");
3575 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003576 }
3577
Douglas Gregor08329632010-06-15 17:05:35 +00003578 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003579
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003580 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3581
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003582 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003583 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3584 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003585 CmdArgs.push_back("-ffreestanding");
3586
Daniel Dunbare357d562009-12-03 18:42:11 +00003587 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003588 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003589 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003590 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3591 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003592 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003593 // AltiVec language extensions aren't relevant for assembling.
3594 if (!isa<PreprocessJobAction>(JA) ||
3595 Output.getType() != types::TY_PP_Asm)
3596 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003597 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3598 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003599
Peter Collingbourne32701642013-11-01 18:16:25 +00003600 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3601 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003602
Eric Christopher459d2712013-02-19 06:16:53 +00003603 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003604 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003605 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003606 getToolChain().getArch() == llvm::Triple::ppc64 ||
3607 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003608 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003609 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003610
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003611 if (getToolChain().SupportsProfiling())
3612 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003613
3614 // -flax-vector-conversions is default.
3615 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3616 options::OPT_fno_lax_vector_conversions))
3617 CmdArgs.push_back("-fno-lax-vector-conversions");
3618
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003619 if (Args.getLastArg(options::OPT_fapple_kext))
3620 CmdArgs.push_back("-fapple-kext");
3621
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003622 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003623 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003624 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003625 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3626 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003627
3628 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3629 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003630 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003631 }
3632
Bob Wilson14adb362012-02-03 06:27:22 +00003633 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003634
Chandler Carruth6e501032011-03-27 00:04:55 +00003635 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3636 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3637 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3638 options::OPT_fno_wrapv)) {
3639 if (A->getOption().matches(options::OPT_fwrapv))
3640 CmdArgs.push_back("-fwrapv");
3641 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3642 options::OPT_fno_strict_overflow)) {
3643 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3644 CmdArgs.push_back("-fwrapv");
3645 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003646
3647 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3648 options::OPT_fno_reroll_loops))
3649 if (A->getOption().matches(options::OPT_freroll_loops))
3650 CmdArgs.push_back("-freroll-loops");
3651
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003652 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003653 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3654 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003655
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003656 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3657
Mahesha S6a682be42012-10-27 07:47:56 +00003658
Daniel Dunbar4930e332009-11-17 08:07:36 +00003659 // -stack-protector=0 is default.
3660 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003661 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3662 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003663 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003664 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003665 if (A->getOption().matches(options::OPT_fstack_protector)) {
3666 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3667 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3668 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003669 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003670 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003671 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003672 } else {
3673 StackProtectorLevel =
3674 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3675 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003676 if (StackProtectorLevel) {
3677 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003678 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003679 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003680
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003681 // --param ssp-buffer-size=
3682 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3683 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003684 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003685 if (Str.startswith("ssp-buffer-size=")) {
3686 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003687 CmdArgs.push_back("-stack-protector-buffer-size");
3688 // FIXME: Verify the argument is a valid integer.
3689 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003690 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003691 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003692 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003693 }
3694
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003695 // Translate -mstackrealign
3696 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3697 false)) {
3698 CmdArgs.push_back("-backend-option");
3699 CmdArgs.push_back("-force-align-stack");
3700 }
3701 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3702 false)) {
3703 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3704 }
3705
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003706 if (Args.hasArg(options::OPT_mstack_alignment)) {
3707 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3708 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003709 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003710
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003711 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3712 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
3713 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3714
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003715 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3716 options::OPT_mno_restrict_it)) {
3717 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3718 CmdArgs.push_back("-backend-option");
3719 CmdArgs.push_back("-arm-restrict-it");
3720 } else {
3721 CmdArgs.push_back("-backend-option");
3722 CmdArgs.push_back("-arm-no-restrict-it");
3723 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003724 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3725 TT.getArch() == llvm::Triple::thumb)) {
3726 // Windows on ARM expects restricted IT blocks
3727 CmdArgs.push_back("-backend-option");
3728 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003729 }
3730
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003731 if (TT.getArch() == llvm::Triple::arm ||
3732 TT.getArch() == llvm::Triple::thumb) {
3733 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3734 options::OPT_mno_long_calls)) {
3735 if (A->getOption().matches(options::OPT_mlong_calls)) {
3736 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003737 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003738 }
3739 }
3740 }
3741
Daniel Dunbard18049a2009-04-07 21:16:11 +00003742 // Forward -f options with positive and negative forms; we translate
3743 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003744 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3745 StringRef fname = A->getValue();
3746 if (!llvm::sys::fs::exists(fname))
3747 D.Diag(diag::err_drv_no_such_file) << fname;
3748 else
3749 A->render(Args, CmdArgs);
3750 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003751
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003752 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003753 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003754 CmdArgs.push_back("-fapple-kext");
3755 if (!Args.hasArg(options::OPT_fbuiltin))
3756 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003757 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003758 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003759 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003760 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003761 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003762
Nuno Lopes13c88c72009-12-16 16:59:22 +00003763 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3764 options::OPT_fno_assume_sane_operator_new))
3765 CmdArgs.push_back("-fno-assume-sane-operator-new");
3766
Daniel Dunbar4930e332009-11-17 08:07:36 +00003767 // -fblocks=0 is default.
3768 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003769 getToolChain().IsBlocksDefault()) ||
3770 (Args.hasArg(options::OPT_fgnu_runtime) &&
3771 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3772 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003773 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003774
3775 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3776 !getToolChain().hasBlocksRuntime())
3777 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003778 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003779
Richard Smithffb65082014-09-30 23:10:19 +00003780 // -fmodules enables modules (off by default).
3781 // Users can pass -fno-cxx-modules to turn off modules support for
3782 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003783 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003784 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3785 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3786 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00003787 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003788 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003789 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003790 HaveModules = true;
3791 }
3792 }
3793
Daniel Jasper07e6c402013-08-05 20:26:17 +00003794 // -fmodule-maps enables module map processing (off by default) for header
3795 // checking. It is implied by -fmodules.
3796 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3797 false)) {
3798 CmdArgs.push_back("-fmodule-maps");
3799 }
3800
Daniel Jasperac42b752013-10-21 06:34:34 +00003801 // -fmodules-decluse checks that modules used are declared so (off by
3802 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003803 if (Args.hasFlag(options::OPT_fmodules_decluse,
3804 options::OPT_fno_modules_decluse,
3805 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003806 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003807 }
3808
Daniel Jasper962b38e2014-04-11 11:47:45 +00003809 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3810 // all #included headers are part of modules.
3811 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3812 options::OPT_fno_modules_strict_decluse,
3813 false)) {
3814 CmdArgs.push_back("-fmodules-strict-decluse");
3815 }
3816
Daniel Jasperac42b752013-10-21 06:34:34 +00003817 // -fmodule-name specifies the module that is currently being built (or
3818 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00003819 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00003820
Richard Smith9887d792014-10-17 01:42:53 +00003821 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00003822 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00003823 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00003824
Richard Smithe842a472014-10-22 02:05:46 +00003825 // -fmodule-file can be used to specify files containing precompiled modules.
3826 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3827
3828 // -fmodule-cache-path specifies where our implicitly-built module files
3829 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00003830 SmallString<128> ModuleCachePath;
3831 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3832 ModuleCachePath = A->getValue();
3833 if (HaveModules) {
3834 if (C.isForDiagnostics()) {
3835 // When generating crash reports, we want to emit the modules along with
3836 // the reproduction sources, so we ignore any provided module path.
3837 ModuleCachePath = Output.getFilename();
3838 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3839 llvm::sys::path::append(ModuleCachePath, "modules");
3840 } else if (ModuleCachePath.empty()) {
3841 // No module path was provided: use the default.
3842 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3843 ModuleCachePath);
3844 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3845 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3846 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003847 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003848 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3849 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3850 }
3851
3852 // When building modules and generating crashdumps, we need to dump a module
3853 // dependency VFS alongside the output.
3854 if (HaveModules && C.isForDiagnostics()) {
3855 SmallString<128> VFSDir(Output.getFilename());
3856 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00003857 // Add the cache directory as a temp so the crash diagnostics pick it up.
3858 C.addTempFile(Args.MakeArgString(VFSDir));
3859
Justin Bognera88f0122014-06-20 22:59:50 +00003860 llvm::sys::path::append(VFSDir, "vfs");
3861 CmdArgs.push_back("-module-dependency-dir");
3862 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003863 }
3864
Richard Smith9887d792014-10-17 01:42:53 +00003865 if (HaveModules)
3866 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003867
Douglas Gregor35b04d62013-02-07 19:01:24 +00003868 // Pass through all -fmodules-ignore-macro arguments.
3869 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003870 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3871 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003872
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003873 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3874
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003875 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3876 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3877 D.Diag(diag::err_drv_argument_not_allowed_with)
3878 << A->getAsString(Args) << "-fbuild-session-timestamp";
3879
3880 llvm::sys::fs::file_status Status;
3881 if (llvm::sys::fs::status(A->getValue(), Status))
3882 D.Diag(diag::err_drv_no_such_file) << A->getValue();
NAKAMURA Takumi0f9447d2014-08-03 01:11:44 +00003883 char TimeStamp[48];
3884 snprintf(TimeStamp, sizeof(TimeStamp), "-fbuild-session-timestamp=%" PRIu64,
3885 (uint64_t)Status.getLastModificationTime().toEpochTime());
3886 CmdArgs.push_back(Args.MakeArgString(TimeStamp));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003887 }
3888
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003889 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00003890 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3891 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003892 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3893
3894 Args.AddLastArg(CmdArgs,
3895 options::OPT_fmodules_validate_once_per_build_session);
3896 }
3897
Ben Langmuirdcf73862014-03-12 00:06:17 +00003898 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3899
John McCalldfea9982010-04-09 19:12:06 +00003900 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003901 if (Args.hasFlag(options::OPT_fno_access_control,
3902 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003903 false))
John McCall3155f572010-04-09 19:03:51 +00003904 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003905
Anders Carlssond470fef2010-11-21 00:09:52 +00003906 // -felide-constructors is the default.
3907 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3908 options::OPT_felide_constructors,
3909 false))
3910 CmdArgs.push_back("-fno-elide-constructors");
3911
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003912 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003913 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003914 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003915 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003916
Richard Smith52be6192012-11-05 22:04:41 +00003917 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003918 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003919 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003920 Args.getLastArg(options::OPT_mkernel,
3921 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003922 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003923 D.Diag(diag::err_drv_argument_not_allowed_with)
3924 << "-fsanitize=vptr" << NoRttiArg;
3925 }
3926 }
3927
Tony Linthicum76329bf2011-12-12 21:14:55 +00003928 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003929 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003930 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003931 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003932 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003933 CmdArgs.push_back("-fshort-enums");
3934
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003935 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003936 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003937 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003938 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003939
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003940 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003941 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003942 options::OPT_fno_threadsafe_statics))
3943 CmdArgs.push_back("-fno-threadsafe-statics");
3944
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003945 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003946 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3947 options::OPT_fno_use_cxa_atexit,
3948 !IsWindowsCygnus && !IsWindowsGNU &&
3949 getToolChain().getArch() != llvm::Triple::hexagon &&
3950 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003951 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003952 CmdArgs.push_back("-fno-use-cxa-atexit");
3953
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003954 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003955 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003956 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003957 CmdArgs.push_back("-fms-extensions");
3958
Francois Pichet1b4f1632011-09-17 04:32:15 +00003959 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003960 if (Args.hasFlag(options::OPT_fms_compatibility,
3961 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003962 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3963 options::OPT_fno_ms_extensions,
3964 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003965 CmdArgs.push_back("-fms-compatibility");
3966
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003967 // -fms-compatibility-version=17.00 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003968 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003969 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
3970 Args.hasArg(options::OPT_fms_compatibility_version)) {
3971 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3972 const Arg *MSCompatibilityVersion =
3973 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003974
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003975 if (MSCVersion && MSCompatibilityVersion)
3976 D.Diag(diag::err_drv_argument_not_allowed_with)
3977 << MSCVersion->getAsString(Args)
3978 << MSCompatibilityVersion->getAsString(Args);
3979
3980 std::string Ver;
3981 if (MSCompatibilityVersion)
3982 Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
3983 else if (MSCVersion)
3984 Ver = getMSCompatibilityVersion(MSCVersion->getValue());
3985
3986 if (Ver.empty())
3987 CmdArgs.push_back("-fms-compatibility-version=17.00");
3988 else
3989 CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
3990 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003991
Eric Christopher5ecce122013-02-18 00:38:31 +00003992 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003993 if (Args.hasFlag(options::OPT_fborland_extensions,
3994 options::OPT_fno_borland_extensions, false))
3995 CmdArgs.push_back("-fborland-extensions");
3996
Francois Pichet02744872011-09-01 16:38:08 +00003997 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3998 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003999 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004000 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004001 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004002
Chandler Carruthe03aa552010-04-17 20:17:31 +00004003 // -fgnu-keywords default varies depending on language; only pass if
4004 // specified.
4005 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004006 options::OPT_fno_gnu_keywords))
4007 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004008
Rafael Espindola922a6242011-06-02 17:30:53 +00004009 if (Args.hasFlag(options::OPT_fgnu89_inline,
4010 options::OPT_fno_gnu89_inline,
4011 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004012 CmdArgs.push_back("-fgnu89-inline");
4013
Chad Rosier9c76d242012-03-15 22:31:42 +00004014 if (Args.hasArg(options::OPT_fno_inline))
4015 CmdArgs.push_back("-fno-inline");
4016
Chad Rosier64d6be92012-03-06 21:17:19 +00004017 if (Args.hasArg(options::OPT_fno_inline_functions))
4018 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004019
John McCall5fb5df92012-06-20 06:18:46 +00004020 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004021
John McCall5fb5df92012-06-20 06:18:46 +00004022 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004023 // legacy is the default. Except for deployment taget of 10.5,
4024 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4025 // gets ignored silently.
4026 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004027 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4028 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004029 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004030 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004031 if (getToolChain().UseObjCMixedDispatch())
4032 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4033 else
4034 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4035 }
4036 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004037
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004038 // When ObjectiveC legacy runtime is in effect on MacOSX,
4039 // turn on the option to do Array/Dictionary subscripting
4040 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004041 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
4042 getToolChain().getTriple().isMacOSX() &&
4043 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4044 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004045 objcRuntime.isNeXTFamily())
4046 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4047
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004048 // -fencode-extended-block-signature=1 is default.
4049 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4050 CmdArgs.push_back("-fencode-extended-block-signature");
4051 }
4052
John McCall24fc0de2011-07-06 00:26:06 +00004053 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4054 // NOTE: This logic is duplicated in ToolChains.cpp.
4055 bool ARC = isObjCAutoRefCount(Args);
4056 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004057 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004058
John McCall24fc0de2011-07-06 00:26:06 +00004059 CmdArgs.push_back("-fobjc-arc");
4060
Chandler Carruth491db322011-11-04 07:34:47 +00004061 // FIXME: It seems like this entire block, and several around it should be
4062 // wrapped in isObjC, but for now we just use it here as this is where it
4063 // was being used previously.
4064 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4065 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4066 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4067 else
4068 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4069 }
4070
John McCall24fc0de2011-07-06 00:26:06 +00004071 // Allow the user to enable full exceptions code emission.
4072 // We define off for Objective-CC, on for Objective-C++.
4073 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4074 options::OPT_fno_objc_arc_exceptions,
4075 /*default*/ types::isCXX(InputType)))
4076 CmdArgs.push_back("-fobjc-arc-exceptions");
4077 }
4078
4079 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4080 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004081 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004082 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004083
John McCall24fc0de2011-07-06 00:26:06 +00004084 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4085 // takes precedence.
4086 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4087 if (!GCArg)
4088 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4089 if (GCArg) {
4090 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004091 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004092 << GCArg->getAsString(Args);
4093 } else if (getToolChain().SupportsObjCGC()) {
4094 GCArg->render(Args, CmdArgs);
4095 } else {
4096 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004097 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004098 << GCArg->getAsString(Args);
4099 }
4100 }
4101
Reid Klecknerc542d372014-06-27 17:02:02 +00004102 // Handle GCC-style exception args.
4103 if (!C.getDriver().IsCLMode())
4104 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
4105 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004106
4107 if (getToolChain().UseSjLjExceptions())
4108 CmdArgs.push_back("-fsjlj-exceptions");
4109
4110 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004111 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4112 options::OPT_fno_assume_sane_operator_new))
4113 CmdArgs.push_back("-fno-assume-sane-operator-new");
4114
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004115 // -fconstant-cfstrings is default, and may be subject to argument translation
4116 // on Darwin.
4117 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4118 options::OPT_fno_constant_cfstrings) ||
4119 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4120 options::OPT_mno_constant_cfstrings))
4121 CmdArgs.push_back("-fno-constant-cfstrings");
4122
John Thompsoned4e2952009-11-05 20:14:16 +00004123 // -fshort-wchar default varies depending on platform; only
4124 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004125 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4126 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004127 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004128
Hans Wennborg28c96312013-07-31 23:39:13 +00004129 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004130 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004131 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004132 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004133 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004134
Daniel Dunbar096ed292011-10-05 21:04:55 +00004135 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4136 // -fno-pack-struct doesn't apply to -fpack-struct=.
4137 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004138 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004139 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004140 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004141 } else if (Args.hasFlag(options::OPT_fpack_struct,
4142 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004143 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004144 }
4145
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004146 // Handle -fmax-type-align=N and -fno-type-align
4147 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4148 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4149 if (!SkipMaxTypeAlign) {
4150 std::string MaxTypeAlignStr = "-fmax-type-align=";
4151 MaxTypeAlignStr += A->getValue();
4152 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4153 }
4154 } else if (getToolChain().getTriple().isOSDarwin()) {
4155 if (!SkipMaxTypeAlign) {
4156 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4157 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4158 }
4159 }
4160
Robert Lytton0e076492013-08-13 09:43:10 +00004161 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004162 if (!Args.hasArg(options::OPT_fcommon))
4163 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004164 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004165 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004166
Daniel Dunbard18049a2009-04-07 21:16:11 +00004167 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004168 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004169 CmdArgs.push_back("-fno-common");
4170
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004171 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004172 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004173 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004174 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004175 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004176 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4177
Daniel Dunbar6358d682010-10-15 22:30:42 +00004178 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4179 if (!Args.hasFlag(options::OPT_ffor_scope,
4180 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004181 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004182 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4183
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004184 // -finput_charset=UTF-8 is default. Reject others
4185 if (Arg *inputCharset = Args.getLastArg(
4186 options::OPT_finput_charset_EQ)) {
4187 StringRef value = inputCharset->getValue();
4188 if (value != "UTF-8")
4189 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4190 }
4191
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004192 // -fexec_charset=UTF-8 is default. Reject others
4193 if (Arg *execCharset = Args.getLastArg(
4194 options::OPT_fexec_charset_EQ)) {
4195 StringRef value = execCharset->getValue();
4196 if (value != "UTF-8")
4197 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4198 }
4199
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004200 // -fcaret-diagnostics is default.
4201 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4202 options::OPT_fno_caret_diagnostics, true))
4203 CmdArgs.push_back("-fno-caret-diagnostics");
4204
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004205 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004206 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004207 options::OPT_fno_diagnostics_fixit_info))
4208 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004209
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004210 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004211 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004212 options::OPT_fno_diagnostics_show_option))
4213 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004214
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004215 if (const Arg *A =
4216 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4217 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004218 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004219 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004220
Douglas Gregor643c9222011-05-21 17:07:29 +00004221 if (const Arg *A =
4222 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4223 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004224 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004225 }
4226
Chandler Carruthb6766f02011-03-27 01:50:55 +00004227 if (Arg *A = Args.getLastArg(
4228 options::OPT_fdiagnostics_show_note_include_stack,
4229 options::OPT_fno_diagnostics_show_note_include_stack)) {
4230 if (A->getOption().matches(
4231 options::OPT_fdiagnostics_show_note_include_stack))
4232 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4233 else
4234 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4235 }
4236
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004237 // Color diagnostics are the default, unless the terminal doesn't support
4238 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004239 // Support both clang's -f[no-]color-diagnostics and gcc's
4240 // -f[no-]diagnostics-colors[=never|always|auto].
4241 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004242 for (const auto &Arg : Args) {
4243 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004244 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4245 !O.matches(options::OPT_fdiagnostics_color) &&
4246 !O.matches(options::OPT_fno_color_diagnostics) &&
4247 !O.matches(options::OPT_fno_diagnostics_color) &&
4248 !O.matches(options::OPT_fdiagnostics_color_EQ))
4249 continue;
4250
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004251 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004252 if (O.matches(options::OPT_fcolor_diagnostics) ||
4253 O.matches(options::OPT_fdiagnostics_color)) {
4254 ShowColors = Colors_On;
4255 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4256 O.matches(options::OPT_fno_diagnostics_color)) {
4257 ShowColors = Colors_Off;
4258 } else {
4259 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004260 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004261 if (value == "always")
4262 ShowColors = Colors_On;
4263 else if (value == "never")
4264 ShowColors = Colors_Off;
4265 else if (value == "auto")
4266 ShowColors = Colors_Auto;
4267 else
4268 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4269 << ("-fdiagnostics-color=" + value).str();
4270 }
4271 }
4272 if (ShowColors == Colors_On ||
4273 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004274 CmdArgs.push_back("-fcolor-diagnostics");
4275
Nico Rieck7857d462013-09-11 00:38:02 +00004276 if (Args.hasArg(options::OPT_fansi_escape_codes))
4277 CmdArgs.push_back("-fansi-escape-codes");
4278
Daniel Dunbardb097022009-06-08 21:13:54 +00004279 if (!Args.hasFlag(options::OPT_fshow_source_location,
4280 options::OPT_fno_show_source_location))
4281 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004282
Douglas Gregor643c9222011-05-21 17:07:29 +00004283 if (!Args.hasFlag(options::OPT_fshow_column,
4284 options::OPT_fno_show_column,
4285 true))
4286 CmdArgs.push_back("-fno-show-column");
4287
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004288 if (!Args.hasFlag(options::OPT_fspell_checking,
4289 options::OPT_fno_spell_checking))
4290 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004291
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004292
Chad Rosierc8e56e82012-12-05 21:08:21 +00004293 // -fno-asm-blocks is default.
4294 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4295 false))
4296 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004297
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004298 // Enable vectorization per default according to the optimization level
4299 // selected. For optimization levels that want vectorization we use the alias
4300 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004301 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004302 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004303 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004304 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004305 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004306 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004307
Chad Rosier136d67d2014-04-28 19:30:57 +00004308 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004309 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4310 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004311 options::OPT_fslp_vectorize;
4312 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004313 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004314 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004315
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004316 // -fno-slp-vectorize-aggressive is default.
4317 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004318 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004319 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004320
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004321 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4322 A->render(Args, CmdArgs);
4323
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004324 // -fdollars-in-identifiers default varies depending on platform and
4325 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004326 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004327 options::OPT_fno_dollars_in_identifiers)) {
4328 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004329 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004330 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004331 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004332 }
4333
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004334 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4335 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004336 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004337 options::OPT_fno_unit_at_a_time)) {
4338 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004339 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004340 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004341
Eli Friedman055c9702011-11-02 01:53:16 +00004342 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4343 options::OPT_fno_apple_pragma_pack, false))
4344 CmdArgs.push_back("-fapple-pragma-pack");
4345
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004346 // le32-specific flags:
4347 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4348 // by default.
4349 if (getToolChain().getArch() == llvm::Triple::le32) {
4350 CmdArgs.push_back("-fno-math-builtin");
4351 }
4352
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004353 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004354 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004355 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004356#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004357 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004358 (getToolChain().getArch() == llvm::Triple::arm ||
4359 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004360 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4361 CmdArgs.push_back("-fno-builtin-strcat");
4362 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4363 CmdArgs.push_back("-fno-builtin-strcpy");
4364 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004365#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004366
Justin Bognera88f0122014-06-20 22:59:50 +00004367 // Enable rewrite includes if the user's asked for it or if we're generating
4368 // diagnostics.
4369 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4370 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004371 if (Args.hasFlag(options::OPT_frewrite_includes,
4372 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004373 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004374 CmdArgs.push_back("-frewrite-includes");
4375
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004376 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004377 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004378 options::OPT_traditional_cpp)) {
4379 if (isa<PreprocessJobAction>(JA))
4380 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004381 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004382 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004383 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004384
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004385 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004386 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004387
4388 // Handle serialized diagnostics.
4389 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4390 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004391 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004392 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004393
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004394 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4395 CmdArgs.push_back("-fretain-comments-from-system-headers");
4396
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004397 // Forward -fcomment-block-commands to -cc1.
4398 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004399 // Forward -fparse-all-comments to -cc1.
4400 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004401
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004402 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4403 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004404 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004405 bool OptDisabled = false;
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004406 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4407 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004408 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004409
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004410 // We translate this by hand to the -cc1 argument, since nightly test uses
4411 // it and developers have been trained to spell it with -mllvm.
Bob Wilson23a55f12014-12-21 07:00:00 +00004412 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004413 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004414 OptDisabled = true;
4415 } else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004416 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004417 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004418
Bob Wilson23a55f12014-12-21 07:00:00 +00004419 // With -save-temps, we want to save the unoptimized bitcode output from the
4420 // CompileJobAction, so disable optimizations if they are not already
4421 // disabled.
4422 if (Args.hasArg(options::OPT_save_temps) && !OptDisabled &&
4423 isa<CompileJobAction>(JA))
4424 CmdArgs.push_back("-disable-llvm-optzns");
4425
Daniel Dunbard67a3222009-03-30 06:36:42 +00004426 if (Output.getType() == types::TY_Dependencies) {
4427 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004428 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004429 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004430 CmdArgs.push_back(Output.getFilename());
4431 } else {
4432 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004433 }
4434
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004435 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004436 addDashXForInput(Args, II, CmdArgs);
4437
Daniel Dunbarb440f562010-08-02 02:38:21 +00004438 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004439 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004440 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004441 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004442 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004443
Chris Lattnere9d7d782009-11-03 19:50:27 +00004444 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4445
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004446 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004447
4448 // Optionally embed the -cc1 level arguments into the debug info, for build
4449 // analysis.
4450 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004451 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004452 for (const auto &Arg : Args)
4453 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004454
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004455 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004456 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004457 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004458 SmallString<128> EscapedArg;
4459 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004460 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004461 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004462 }
4463 CmdArgs.push_back("-dwarf-debug-flags");
4464 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4465 }
4466
Eric Christopherd3804002013-02-22 20:12:52 +00004467 // Add the split debug info name to the command lines here so we
4468 // can propagate it to the backend.
4469 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004470 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004471 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4472 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004473 const char *SplitDwarfOut;
4474 if (SplitDwarf) {
4475 CmdArgs.push_back("-split-dwarf-file");
4476 SplitDwarfOut = SplitDebugName(Args, Inputs);
4477 CmdArgs.push_back(SplitDwarfOut);
4478 }
4479
4480 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004481 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004482 Output.getType() == types::TY_Object &&
4483 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004484 auto CLCommand =
4485 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4486 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4487 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004488 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004489 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004490 }
4491
Daniel Dunbar17731772009-03-23 19:03:36 +00004492
Eric Christopherf1545832013-02-22 23:50:16 +00004493 // Handle the debug info splitting at object creation time if we're
4494 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004495 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004496 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004497 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004498
Roman Divacky178e01602011-02-10 16:52:03 +00004499 if (Arg *A = Args.getLastArg(options::OPT_pg))
4500 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004501 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004502 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004503
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004504 // Claim some arguments which clang supports automatically.
4505
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004506 // -fpch-preprocess is used with gcc to add a special marker in the output to
4507 // include the PCH file. Clang's PTH solution is completely transparent, so we
4508 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004509 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004510
Daniel Dunbar17731772009-03-23 19:03:36 +00004511 // Claim some arguments which clang doesn't support, but we don't
4512 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004513 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4514 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004515
Rafael Espindolab0092d72013-09-04 19:37:35 +00004516 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004517 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004518}
4519
John McCall5fb5df92012-06-20 06:18:46 +00004520/// Add options related to the Objective-C runtime/ABI.
4521///
4522/// Returns true if the runtime is non-fragile.
4523ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4524 ArgStringList &cmdArgs,
4525 RewriteKind rewriteKind) const {
4526 // Look for the controlling runtime option.
4527 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4528 options::OPT_fgnu_runtime,
4529 options::OPT_fobjc_runtime_EQ);
4530
4531 // Just forward -fobjc-runtime= to the frontend. This supercedes
4532 // options about fragility.
4533 if (runtimeArg &&
4534 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4535 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004536 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004537 if (runtime.tryParse(value)) {
4538 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4539 << value;
4540 }
4541
4542 runtimeArg->render(args, cmdArgs);
4543 return runtime;
4544 }
4545
4546 // Otherwise, we'll need the ABI "version". Version numbers are
4547 // slightly confusing for historical reasons:
4548 // 1 - Traditional "fragile" ABI
4549 // 2 - Non-fragile ABI, version 1
4550 // 3 - Non-fragile ABI, version 2
4551 unsigned objcABIVersion = 1;
4552 // If -fobjc-abi-version= is present, use that to set the version.
4553 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004554 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004555 if (value == "1")
4556 objcABIVersion = 1;
4557 else if (value == "2")
4558 objcABIVersion = 2;
4559 else if (value == "3")
4560 objcABIVersion = 3;
4561 else
4562 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4563 << value;
4564 } else {
4565 // Otherwise, determine if we are using the non-fragile ABI.
4566 bool nonFragileABIIsDefault =
4567 (rewriteKind == RK_NonFragile ||
4568 (rewriteKind == RK_None &&
4569 getToolChain().IsObjCNonFragileABIDefault()));
4570 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4571 options::OPT_fno_objc_nonfragile_abi,
4572 nonFragileABIIsDefault)) {
4573 // Determine the non-fragile ABI version to use.
4574#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4575 unsigned nonFragileABIVersion = 1;
4576#else
4577 unsigned nonFragileABIVersion = 2;
4578#endif
4579
4580 if (Arg *abiArg = args.getLastArg(
4581 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004582 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004583 if (value == "1")
4584 nonFragileABIVersion = 1;
4585 else if (value == "2")
4586 nonFragileABIVersion = 2;
4587 else
4588 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4589 << value;
4590 }
4591
4592 objcABIVersion = 1 + nonFragileABIVersion;
4593 } else {
4594 objcABIVersion = 1;
4595 }
4596 }
4597
4598 // We don't actually care about the ABI version other than whether
4599 // it's non-fragile.
4600 bool isNonFragile = objcABIVersion != 1;
4601
4602 // If we have no runtime argument, ask the toolchain for its default runtime.
4603 // However, the rewriter only really supports the Mac runtime, so assume that.
4604 ObjCRuntime runtime;
4605 if (!runtimeArg) {
4606 switch (rewriteKind) {
4607 case RK_None:
4608 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4609 break;
4610 case RK_Fragile:
4611 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4612 break;
4613 case RK_NonFragile:
4614 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4615 break;
4616 }
4617
4618 // -fnext-runtime
4619 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4620 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004621 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004622 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4623
4624 // Otherwise, build for a generic macosx port.
4625 } else {
4626 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4627 }
4628
4629 // -fgnu-runtime
4630 } else {
4631 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004632 // Legacy behaviour is to target the gnustep runtime if we are i
4633 // non-fragile mode or the GCC runtime in fragile mode.
4634 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004635 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004636 else
4637 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004638 }
4639
4640 cmdArgs.push_back(args.MakeArgString(
4641 "-fobjc-runtime=" + runtime.getAsString()));
4642 return runtime;
4643}
4644
Reid Klecknerc542d372014-06-27 17:02:02 +00004645static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4646 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4647 I += HaveDash;
4648 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004649}
Reid Klecknerc542d372014-06-27 17:02:02 +00004650
4651struct EHFlags {
4652 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4653 bool Synch;
4654 bool Asynch;
4655 bool NoExceptC;
4656};
4657
4658/// /EH controls whether to run destructor cleanups when exceptions are
4659/// thrown. There are three modifiers:
4660/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4661/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4662/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4663/// - c: Assume that extern "C" functions are implicitly noexcept. This
4664/// modifier is an optimization, so we ignore it for now.
4665/// The default is /EHs-c-, meaning cleanups are disabled.
4666static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4667 EHFlags EH;
4668 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4669 for (auto EHVal : EHArgs) {
4670 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4671 switch (EHVal[I]) {
4672 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4673 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4674 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4675 default: break;
4676 }
4677 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4678 break;
4679 }
4680 }
4681 return EH;
4682}
4683
Hans Wennborg75958c42013-08-08 00:17:41 +00004684void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4685 unsigned RTOptionID = options::OPT__SLASH_MT;
4686
Hans Wennborgf1a74252013-09-10 20:18:04 +00004687 if (Args.hasArg(options::OPT__SLASH_LDd))
4688 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4689 // but defining _DEBUG is sticky.
4690 RTOptionID = options::OPT__SLASH_MTd;
4691
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004692 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004693 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004694
Hans Wennborg75958c42013-08-08 00:17:41 +00004695 switch(RTOptionID) {
4696 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004697 if (Args.hasArg(options::OPT__SLASH_LDd))
4698 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004699 CmdArgs.push_back("-D_MT");
4700 CmdArgs.push_back("-D_DLL");
4701 CmdArgs.push_back("--dependent-lib=msvcrt");
4702 break;
4703 case options::OPT__SLASH_MDd:
4704 CmdArgs.push_back("-D_DEBUG");
4705 CmdArgs.push_back("-D_MT");
4706 CmdArgs.push_back("-D_DLL");
4707 CmdArgs.push_back("--dependent-lib=msvcrtd");
4708 break;
4709 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004710 if (Args.hasArg(options::OPT__SLASH_LDd))
4711 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004712 CmdArgs.push_back("-D_MT");
4713 CmdArgs.push_back("--dependent-lib=libcmt");
4714 break;
4715 case options::OPT__SLASH_MTd:
4716 CmdArgs.push_back("-D_DEBUG");
4717 CmdArgs.push_back("-D_MT");
4718 CmdArgs.push_back("--dependent-lib=libcmtd");
4719 break;
4720 default:
4721 llvm_unreachable("Unexpected option ID.");
4722 }
4723
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004724 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4725 // users want. The /Za flag to cl.exe turns this off, but it's not
4726 // implemented in clang.
4727 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004728
Hans Wennborg8858a032014-07-21 23:42:07 +00004729 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4730 // would produce interleaved output, so ignore /showIncludes in such cases.
4731 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4732 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4733 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004734
David Majnemerf6072342014-07-01 22:24:56 +00004735 // This controls whether or not we emit RTTI data for polymorphic types.
4736 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4737 /*default=*/false))
4738 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004739
Reid Klecknerc542d372014-06-27 17:02:02 +00004740 const Driver &D = getToolChain().getDriver();
4741 EHFlags EH = parseClangCLEHFlags(D, Args);
4742 // FIXME: Do something with NoExceptC.
4743 if (EH.Synch || EH.Asynch) {
4744 CmdArgs.push_back("-fexceptions");
4745 CmdArgs.push_back("-fcxx-exceptions");
4746 }
4747
Hans Wennborge50cec32014-06-13 20:59:54 +00004748 // /EP should expand to -E -P.
4749 if (Args.hasArg(options::OPT__SLASH_EP)) {
4750 CmdArgs.push_back("-E");
4751 CmdArgs.push_back("-P");
4752 }
4753
David Majnemer86c318f2014-02-11 21:05:00 +00004754 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4755 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4756 if (MostGeneralArg && BestCaseArg)
4757 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4758 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4759
4760 if (MostGeneralArg) {
4761 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4762 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4763 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4764
4765 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4766 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4767 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4768 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4769 << FirstConflict->getAsString(Args)
4770 << SecondConflict->getAsString(Args);
4771
4772 if (SingleArg)
4773 CmdArgs.push_back("-fms-memptr-rep=single");
4774 else if (MultipleArg)
4775 CmdArgs.push_back("-fms-memptr-rep=multiple");
4776 else
4777 CmdArgs.push_back("-fms-memptr-rep=virtual");
4778 }
4779
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004780 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4781 A->render(Args, CmdArgs);
4782
Hans Wennborg81f74482013-09-10 01:07:07 +00004783 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4784 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004785 if (Args.hasArg(options::OPT__SLASH_fallback))
4786 CmdArgs.push_back("msvc-fallback");
4787 else
4788 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004789 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004790}
4791
Hans Wennborg1da044a2014-06-26 19:59:02 +00004792visualstudio::Compile *Clang::getCLFallback() const {
4793 if (!CLFallback)
4794 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4795 return CLFallback.get();
4796}
4797
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004798void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004799 const InputInfo &Output,
4800 const InputInfoList &Inputs,
4801 const ArgList &Args,
4802 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004803 ArgStringList CmdArgs;
4804
4805 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4806 const InputInfo &Input = Inputs[0];
4807
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004808 // Don't warn about "clang -w -c foo.s"
4809 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004810 // and "clang -emit-llvm -c foo.s"
4811 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004812
Rafael Espindola16042fc2015-01-02 23:23:52 +00004813 // Don't warn on -flto/-fno-lto
4814 // FIXME: Code duplicated with Clang::ConstructJob.
4815 Args.ClaimAllArgs(options::OPT_flto);
4816 Args.ClaimAllArgs(options::OPT_fno_lto);
4817
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004818 // Invoke ourselves in -cc1as mode.
4819 //
4820 // FIXME: Implement custom jobs for internal actions.
4821 CmdArgs.push_back("-cc1as");
4822
4823 // Add the "effective" target triple.
4824 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004825 std::string TripleStr =
4826 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004827 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4828
4829 // Set the output mode, we currently only expect to be used as a real
4830 // assembler.
4831 CmdArgs.push_back("-filetype");
4832 CmdArgs.push_back("obj");
4833
Eric Christopher45f2e712012-12-18 00:31:10 +00004834 // Set the main file name, so that debug info works even with
4835 // -save-temps or preprocessed assembly.
4836 CmdArgs.push_back("-main-file-name");
4837 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4838
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004839 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004840 const llvm::Triple &Triple = getToolChain().getTriple();
4841 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004842 if (!CPU.empty()) {
4843 CmdArgs.push_back("-target-cpu");
4844 CmdArgs.push_back(Args.MakeArgString(CPU));
4845 }
4846
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004847 // Add the target features
4848 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004849 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004850
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004851 // Ignore explicit -force_cpusubtype_ALL option.
4852 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004853
Eric Christopherfc3ee562012-01-10 00:38:01 +00004854 // Determine the original source input.
4855 const Action *SourceAction = &JA;
4856 while (SourceAction->getKind() != Action::InputClass) {
4857 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4858 SourceAction = SourceAction->getInputs()[0];
4859 }
4860
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004861 // Forward -g and handle debug info related flags, assuming we are dealing
4862 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004863 if (SourceAction->getType() == types::TY_Asm ||
4864 SourceAction->getType() == types::TY_PP_Asm) {
4865 Args.ClaimAllArgs(options::OPT_g_Group);
4866 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4867 if (!A->getOption().matches(options::OPT_g0))
4868 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004869
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004870 if (Args.hasArg(options::OPT_gdwarf_2))
4871 CmdArgs.push_back("-gdwarf-2");
4872 if (Args.hasArg(options::OPT_gdwarf_3))
4873 CmdArgs.push_back("-gdwarf-3");
4874 if (Args.hasArg(options::OPT_gdwarf_4))
4875 CmdArgs.push_back("-gdwarf-4");
4876
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004877 // Add the -fdebug-compilation-dir flag if needed.
4878 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004879
4880 // Set the AT_producer to the clang version when using the integrated
4881 // assembler on assembly source files.
4882 CmdArgs.push_back("-dwarf-debug-producer");
4883 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004884 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004885
4886 // Optionally embed the -cc1as level arguments into the debug info, for build
4887 // analysis.
4888 if (getToolChain().UseDwarfDebugFlags()) {
4889 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004890 for (const auto &Arg : Args)
4891 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004892
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004893 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004894 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4895 Flags += Exec;
4896 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004897 SmallString<128> EscapedArg;
4898 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00004899 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004900 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00004901 }
4902 CmdArgs.push_back("-dwarf-debug-flags");
4903 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4904 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004905
4906 // FIXME: Add -static support, once we have it.
4907
David Blaikie372d9502014-01-17 03:17:40 +00004908 // Consume all the warning flags. Usually this would be handled more
4909 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4910 // doesn't handle that so rather than warning about unused flags that are
4911 // actually used, we'll lie by omission instead.
4912 // FIXME: Stop lying and consume only the appropriate driver flags
4913 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4914 ie = Args.filtered_end();
4915 it != ie; ++it)
4916 (*it)->claim();
4917
David Blaikie9260ed62013-07-25 21:19:01 +00004918 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4919 getToolChain().getDriver());
4920
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004921 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004922
4923 assert(Output.isFilename() && "Unexpected lipo output.");
4924 CmdArgs.push_back("-o");
4925 CmdArgs.push_back(Output.getFilename());
4926
Daniel Dunbarb440f562010-08-02 02:38:21 +00004927 assert(Input.isFilename() && "Invalid input.");
4928 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004929
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004930 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00004931 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004932
4933 // Handle the debug info splitting at object creation time if we're
4934 // creating an object.
4935 // TODO: Currently only works on linux with newer objcopy.
4936 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004937 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004938 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4939 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004940}
4941
Reid Kleckner0290c9c2014-09-15 17:45:39 +00004942void GnuTool::anchor() {}
4943
Daniel Dunbara3246a02009-03-18 08:07:30 +00004944void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004945 const InputInfo &Output,
4946 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004947 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004948 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004949 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004950 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004951
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004952 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004953 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004954 // Don't forward any -g arguments to assembly steps.
4955 if (isa<AssembleJobAction>(JA) &&
4956 A->getOption().matches(options::OPT_g_Group))
4957 continue;
4958
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004959 // Don't forward any -W arguments to assembly and link steps.
4960 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4961 A->getOption().matches(options::OPT_W_Group))
4962 continue;
4963
Daniel Dunbar2da02722009-03-19 07:55:12 +00004964 // It is unfortunate that we have to claim here, as this means
4965 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004966 // platforms using a generic gcc, even if we are just using gcc
4967 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004968 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004969 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004970 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004971 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004972
Daniel Dunbar4e295052010-01-25 22:35:08 +00004973 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004974
4975 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004976 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004977 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004978 CmdArgs.push_back(
4979 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004980 }
4981
Daniel Dunbar5716d872009-05-02 21:41:52 +00004982 // Try to force gcc to match the tool chain we want, if we recognize
4983 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004984 //
4985 // FIXME: The triple class should directly provide the information we want
4986 // here.
Rafael Espindolaed1233e2014-08-28 21:23:05 +00004987 llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004988 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004989 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004990 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4991 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004992 CmdArgs.push_back("-m64");
4993
Daniel Dunbarb440f562010-08-02 02:38:21 +00004994 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004995 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004996 CmdArgs.push_back(Output.getFilename());
4997 } else {
4998 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004999 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005000 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005001
Tony Linthicum76329bf2011-12-12 21:14:55 +00005002 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5003 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005004
5005 // Only pass -x if gcc will understand it; otherwise hope gcc
5006 // understands the suffix correctly. The main use case this would go
5007 // wrong in is for linker inputs if they happened to have an odd
5008 // suffix; really the only way to get this to happen is a command
5009 // like '-x foobar a.c' which will treat a.c like a linker input.
5010 //
5011 // FIXME: For the linker case specifically, can we safely convert
5012 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005013 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005014 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005015 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5016 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005017 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005018 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005019 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005020 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005021 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005022 else if (II.getType() == types::TY_ModuleFile)
5023 D.Diag(diag::err_drv_no_module_support)
5024 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005025
Daniel Dunbara3246a02009-03-18 08:07:30 +00005026 if (types::canTypeBeUserSpecified(II.getType())) {
5027 CmdArgs.push_back("-x");
5028 CmdArgs.push_back(types::getTypeName(II.getType()));
5029 }
5030
Daniel Dunbarb440f562010-08-02 02:38:21 +00005031 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005032 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005033 else {
5034 const Arg &A = II.getInputArg();
5035
5036 // Reverse translate some rewritten options.
5037 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5038 CmdArgs.push_back("-lstdc++");
5039 continue;
5040 }
5041
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005042 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005043 A.render(Args, CmdArgs);
5044 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005045 }
5046
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005047 const std::string customGCCName = D.getCCCGenericGCCName();
5048 const char *GCCName;
5049 if (!customGCCName.empty())
5050 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005051 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005052 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005053 } else
5054 GCCName = "gcc";
5055
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005056 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005057 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005058 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005059}
5060
Daniel Dunbar4e295052010-01-25 22:35:08 +00005061void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5062 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005063 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005064}
5065
Daniel Dunbar4e295052010-01-25 22:35:08 +00005066void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5067 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005068 const Driver &D = getToolChain().getDriver();
5069
Daniel Dunbar4e295052010-01-25 22:35:08 +00005070 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005071 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
5072 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00005073 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005074 else {
5075 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005076 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005077 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005078
Daniel Dunbar4e295052010-01-25 22:35:08 +00005079 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005080 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005081}
5082
Daniel Dunbar4e295052010-01-25 22:35:08 +00005083void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5084 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005085 // The types are (hopefully) good enough.
5086}
5087
Tony Linthicum76329bf2011-12-12 21:14:55 +00005088// Hexagon tools start.
5089void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5090 ArgStringList &CmdArgs) const {
5091
5092}
5093void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5094 const InputInfo &Output,
5095 const InputInfoList &Inputs,
5096 const ArgList &Args,
5097 const char *LinkingOutput) const {
5098
5099 const Driver &D = getToolChain().getDriver();
5100 ArgStringList CmdArgs;
5101
5102 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005103 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005104 CmdArgs.push_back(Args.MakeArgString(MarchString));
5105
5106 RenderExtraToolArgs(JA, CmdArgs);
5107
5108 if (Output.isFilename()) {
5109 CmdArgs.push_back("-o");
5110 CmdArgs.push_back(Output.getFilename());
5111 } else {
5112 assert(Output.isNothing() && "Unexpected output");
5113 CmdArgs.push_back("-fsyntax-only");
5114 }
5115
Matthew Curtise8f80a12012-12-06 17:49:03 +00005116 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5117 if (!SmallDataThreshold.empty())
5118 CmdArgs.push_back(
5119 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005120
Matthew Curtise5df3812012-12-07 17:23:04 +00005121 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5122 options::OPT_Xassembler);
5123
Tony Linthicum76329bf2011-12-12 21:14:55 +00005124 // Only pass -x if gcc will understand it; otherwise hope gcc
5125 // understands the suffix correctly. The main use case this would go
5126 // wrong in is for linker inputs if they happened to have an odd
5127 // suffix; really the only way to get this to happen is a command
5128 // like '-x foobar a.c' which will treat a.c like a linker input.
5129 //
5130 // FIXME: For the linker case specifically, can we safely convert
5131 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005132 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005133 // Don't try to pass LLVM or AST inputs to a generic gcc.
5134 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5135 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5136 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5137 << getToolChain().getTripleString();
5138 else if (II.getType() == types::TY_AST)
5139 D.Diag(clang::diag::err_drv_no_ast_support)
5140 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005141 else if (II.getType() == types::TY_ModuleFile)
5142 D.Diag(diag::err_drv_no_module_support)
5143 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005144
5145 if (II.isFilename())
5146 CmdArgs.push_back(II.getFilename());
5147 else
5148 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5149 II.getInputArg().render(Args, CmdArgs);
5150 }
5151
5152 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005153 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005154 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005155}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005156
Tony Linthicum76329bf2011-12-12 21:14:55 +00005157void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5158 ArgStringList &CmdArgs) const {
5159 // The types are (hopefully) good enough.
5160}
5161
5162void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5163 const InputInfo &Output,
5164 const InputInfoList &Inputs,
5165 const ArgList &Args,
5166 const char *LinkingOutput) const {
5167
Matthew Curtise689b052012-12-06 15:46:07 +00005168 const toolchains::Hexagon_TC& ToolChain =
5169 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5170 const Driver &D = ToolChain.getDriver();
5171
Tony Linthicum76329bf2011-12-12 21:14:55 +00005172 ArgStringList CmdArgs;
5173
Matthew Curtise689b052012-12-06 15:46:07 +00005174 //----------------------------------------------------------------------------
5175 //
5176 //----------------------------------------------------------------------------
5177 bool hasStaticArg = Args.hasArg(options::OPT_static);
5178 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005179 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005180 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5181 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5182 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5183 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005184
Matthew Curtise689b052012-12-06 15:46:07 +00005185 //----------------------------------------------------------------------------
5186 // Silence warnings for various options
5187 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005188
Matthew Curtise689b052012-12-06 15:46:07 +00005189 Args.ClaimAllArgs(options::OPT_g_Group);
5190 Args.ClaimAllArgs(options::OPT_emit_llvm);
5191 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5192 // handled somewhere else.
5193 Args.ClaimAllArgs(options::OPT_static_libgcc);
5194
5195 //----------------------------------------------------------------------------
5196 //
5197 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005198 for (const auto &Opt : ToolChain.ExtraOpts)
5199 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005200
Matthew Curtisf10a5952012-12-06 14:16:43 +00005201 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5202 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005203
Matthew Curtise689b052012-12-06 15:46:07 +00005204 if (buildingLib) {
5205 CmdArgs.push_back("-shared");
5206 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5207 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005208 }
5209
Matthew Curtise689b052012-12-06 15:46:07 +00005210 if (hasStaticArg)
5211 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005212
Matthew Curtise8f80a12012-12-06 17:49:03 +00005213 if (buildPIE && !buildingLib)
5214 CmdArgs.push_back("-pie");
5215
5216 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5217 if (!SmallDataThreshold.empty()) {
5218 CmdArgs.push_back(
5219 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5220 }
5221
Matthew Curtise689b052012-12-06 15:46:07 +00005222 //----------------------------------------------------------------------------
5223 //
5224 //----------------------------------------------------------------------------
5225 CmdArgs.push_back("-o");
5226 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005227
Matthew Curtise689b052012-12-06 15:46:07 +00005228 const std::string MarchSuffix = "/" + MarchString;
5229 const std::string G0Suffix = "/G0";
5230 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005231 const std::string RootDir =
5232 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005233 const std::string StartFilesDir = RootDir
5234 + "hexagon/lib"
5235 + (buildingLib
5236 ? MarchG0Suffix : MarchSuffix);
5237
5238 //----------------------------------------------------------------------------
5239 // moslib
5240 //----------------------------------------------------------------------------
5241 std::vector<std::string> oslibs;
5242 bool hasStandalone= false;
5243
5244 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5245 ie = Args.filtered_end(); it != ie; ++it) {
5246 (*it)->claim();
5247 oslibs.push_back((*it)->getValue());
5248 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005249 }
Matthew Curtise689b052012-12-06 15:46:07 +00005250 if (oslibs.empty()) {
5251 oslibs.push_back("standalone");
5252 hasStandalone = true;
5253 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005254
Matthew Curtise689b052012-12-06 15:46:07 +00005255 //----------------------------------------------------------------------------
5256 // Start Files
5257 //----------------------------------------------------------------------------
5258 if (incStdLib && incStartFiles) {
5259
5260 if (!buildingLib) {
5261 if (hasStandalone) {
5262 CmdArgs.push_back(
5263 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5264 }
5265 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5266 }
5267 std::string initObj = useShared ? "/initS.o" : "/init.o";
5268 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5269 }
5270
5271 //----------------------------------------------------------------------------
5272 // Library Search Paths
5273 //----------------------------------------------------------------------------
5274 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005275 for (const auto &LibPath : LibPaths)
5276 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005277
5278 //----------------------------------------------------------------------------
5279 //
5280 //----------------------------------------------------------------------------
5281 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5282 Args.AddAllArgs(CmdArgs, options::OPT_e);
5283 Args.AddAllArgs(CmdArgs, options::OPT_s);
5284 Args.AddAllArgs(CmdArgs, options::OPT_t);
5285 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5286
5287 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5288
5289 //----------------------------------------------------------------------------
5290 // Libraries
5291 //----------------------------------------------------------------------------
5292 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005293 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005294 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5295 CmdArgs.push_back("-lm");
5296 }
5297
5298 CmdArgs.push_back("--start-group");
5299
5300 if (!buildingLib) {
5301 for(std::vector<std::string>::iterator i = oslibs.begin(),
5302 e = oslibs.end(); i != e; ++i)
5303 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5304 CmdArgs.push_back("-lc");
5305 }
5306 CmdArgs.push_back("-lgcc");
5307
5308 CmdArgs.push_back("--end-group");
5309 }
5310
5311 //----------------------------------------------------------------------------
5312 // End files
5313 //----------------------------------------------------------------------------
5314 if (incStdLib && incStartFiles) {
5315 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5316 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5317 }
5318
5319 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005320 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5321 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005322}
5323// Hexagon tools end.
5324
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005325/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005326const char *arm::getARMCPUForMArch(const ArgList &Args,
5327 const llvm::Triple &Triple) {
5328 StringRef MArch;
5329 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5330 // Otherwise, if we have -march= choose the base CPU for that arch.
5331 MArch = A->getValue();
5332 } else {
5333 // Otherwise, use the Arch from the triple.
5334 MArch = Triple.getArchName();
5335 }
5336
5337 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005338 if (MArch == "native") {
5339 std::string CPU = llvm::sys::getHostCPUName();
5340 if (CPU != "generic") {
5341 // Translate the native cpu into the architecture. The switch below will
5342 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005343 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005344 }
5345 }
5346
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005347 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005348}
5349
5350/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005351StringRef arm::getARMTargetCPU(const ArgList &Args,
5352 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005353 // FIXME: Warn on inconsistent use of -mcpu and -march.
5354 // If we have -mcpu=, use that.
5355 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5356 StringRef MCPU = A->getValue();
5357 // Handle -mcpu=native.
5358 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005359 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005360 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005361 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005362 }
5363
5364 return getARMCPUForMArch(Args, Triple);
5365}
5366
5367/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5368/// CPU.
5369//
5370// FIXME: This is redundant with -mcpu, why does LLVM use this.
5371// FIXME: tblgen this, or kill it!
5372const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5373 return llvm::StringSwitch<const char *>(CPU)
5374 .Case("strongarm", "v4")
5375 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5376 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5377 .Cases("arm920", "arm920t", "arm922t", "v4t")
5378 .Cases("arm940t", "ep9312","v4t")
5379 .Cases("arm10tdmi", "arm1020t", "v5")
5380 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5381 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5382 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5383 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5384 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5385 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Charlie Turner2919cbd2014-11-06 14:59:30 +00005386 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
Renato Golin5886bc32014-10-13 10:22:48 +00005387 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005388 .Cases("cortex-r4", "cortex-r5", "v7r")
5389 .Case("cortex-m0", "v6m")
5390 .Case("cortex-m3", "v7m")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00005391 .Cases("cortex-m4", "cortex-m7", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005392 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005393 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005394 .Cases("cortex-a53", "cortex-a57", "v8")
5395 .Default("");
5396}
5397
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005398bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5399 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5400 return A && (A->getValue() == StringRef(Value));
5401}
5402
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005403bool mips::isUCLibc(const ArgList &Args) {
5404 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005405 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005406}
5407
Daniel Sanders2bf13662014-07-10 14:40:57 +00005408bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005409 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5410 return llvm::StringSwitch<bool>(NaNArg->getValue())
5411 .Case("2008", true)
5412 .Case("legacy", false)
5413 .Default(false);
5414
5415 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005416 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5417 .Cases("mips32r6", "mips64r6", true)
5418 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005419
5420 return false;
5421}
5422
Daniel Sanders379d44b2014-07-16 11:52:23 +00005423bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5424 StringRef ABIName) {
5425 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005426 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005427 return false;
5428
5429 if (ABIName != "32")
5430 return false;
5431
5432 return llvm::StringSwitch<bool>(CPUName)
5433 .Cases("mips2", "mips3", "mips4", "mips5", true)
5434 .Cases("mips32", "mips32r2", true)
5435 .Cases("mips64", "mips64r2", true)
5436 .Default(false);
5437}
5438
Tim Northover157d9112014-01-16 08:48:16 +00005439llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005440 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5441 // archs which Darwin doesn't use.
5442
5443 // The matching this routine does is fairly pointless, since it is neither the
5444 // complete architecture list, nor a reasonable subset. The problem is that
5445 // historically the driver driver accepts this and also ties its -march=
5446 // handling to the architecture name, so we need to be careful before removing
5447 // support for it.
5448
5449 // This code must be kept in sync with Clang's Darwin specific argument
5450 // translation.
5451
5452 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5453 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5454 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5455 .Case("ppc64", llvm::Triple::ppc64)
5456 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5457 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5458 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005459 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005460 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005461 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005462 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005463 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005464 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005465 .Case("r600", llvm::Triple::r600)
5466 .Case("nvptx", llvm::Triple::nvptx)
5467 .Case("nvptx64", llvm::Triple::nvptx64)
5468 .Case("amdil", llvm::Triple::amdil)
5469 .Case("spir", llvm::Triple::spir)
5470 .Default(llvm::Triple::UnknownArch);
5471}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005472
Tim Northover157d9112014-01-16 08:48:16 +00005473void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5474 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5475 T.setArch(Arch);
5476
5477 if (Str == "x86_64h")
5478 T.setArchName(Str);
5479 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5480 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005481 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005482 }
5483}
5484
Bob Wilsondecc03e2012-11-23 06:14:39 +00005485const char *Clang::getBaseInputName(const ArgList &Args,
5486 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005487 return Args.MakeArgString(
5488 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005489}
5490
Bob Wilsondecc03e2012-11-23 06:14:39 +00005491const char *Clang::getBaseInputStem(const ArgList &Args,
5492 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005493 const char *Str = getBaseInputName(Args, Inputs);
5494
Chris Lattner906bb902011-01-16 08:14:11 +00005495 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005496 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005497
5498 return Str;
5499}
5500
Bob Wilsondecc03e2012-11-23 06:14:39 +00005501const char *Clang::getDependencyFileName(const ArgList &Args,
5502 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005503 // FIXME: Think about this more.
5504 std::string Res;
5505
5506 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005507 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005508 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005509 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005510 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005511 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005512 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005513}
5514
Daniel Dunbarbe220842009-03-20 16:06:39 +00005515void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005516 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005517 const InputInfoList &Inputs,
5518 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005519 const char *LinkingOutput) const {
5520 ArgStringList CmdArgs;
5521
5522 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5523 const InputInfo &Input = Inputs[0];
5524
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005525 // Determine the original source input.
5526 const Action *SourceAction = &JA;
5527 while (SourceAction->getKind() != Action::InputClass) {
5528 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5529 SourceAction = SourceAction->getInputs()[0];
5530 }
5531
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005532 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005533 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005534 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5535 // FIXME: at run-time detect assembler capabilities or rely on version
5536 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005537 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005538 const llvm::Triple &T(getToolChain().getTriple());
5539 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005540 CmdArgs.push_back("-Q");
5541 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005542
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005543 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005544 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005545 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005546 if (Args.hasArg(options::OPT_gstabs))
5547 CmdArgs.push_back("--gstabs");
5548 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005549 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005550 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005551
Daniel Dunbarbe220842009-03-20 16:06:39 +00005552 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005553 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005554
Daniel Dunbar6d484762010-07-22 01:47:22 +00005555 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005556 if (getToolChain().getArch() == llvm::Triple::x86 ||
5557 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005558 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5559 CmdArgs.push_back("-force_cpusubtype_ALL");
5560
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005561 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005562 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005563 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005564 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005565 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005566 CmdArgs.push_back("-static");
5567
Daniel Dunbarbe220842009-03-20 16:06:39 +00005568 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5569 options::OPT_Xassembler);
5570
5571 assert(Output.isFilename() && "Unexpected lipo output.");
5572 CmdArgs.push_back("-o");
5573 CmdArgs.push_back(Output.getFilename());
5574
Daniel Dunbarb440f562010-08-02 02:38:21 +00005575 assert(Input.isFilename() && "Invalid input.");
5576 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005577
5578 // asm_final spec is empty.
5579
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005580 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005581 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005582 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005583}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005584
Tim Northover157d9112014-01-16 08:48:16 +00005585void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005586
Tim Northover157d9112014-01-16 08:48:16 +00005587void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5588 ArgStringList &CmdArgs) const {
5589 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005590
Daniel Dunbarc1964212009-03-26 16:23:12 +00005591 // Derived from darwin_arch spec.
5592 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005593 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005594
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005595 // FIXME: Is this needed anymore?
5596 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005597 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005598}
5599
Bill Wendling3b2000f2012-10-02 18:02:50 +00005600bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5601 // We only need to generate a temp path for LTO if we aren't compiling object
5602 // files. When compiling source files, we run 'dsymutil' after linking. We
5603 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005604 for (const auto &Input : Inputs)
5605 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005606 return true;
5607
5608 return false;
5609}
5610
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005611void darwin::Link::AddLinkArgs(Compilation &C,
5612 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005613 ArgStringList &CmdArgs,
5614 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005615 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005616 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005617
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005618 unsigned Version[3] = { 0, 0, 0 };
5619 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5620 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005621 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005622 Version[1], Version[2], HadExtra) ||
5623 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005624 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005625 << A->getAsString(Args);
5626 }
5627
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005628 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005629 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005630 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5631 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005632
Bob Wilson3d27dad2013-08-02 22:25:34 +00005633 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5634 CmdArgs.push_back("-export_dynamic");
5635
Bill Wendling313b6bf2012-11-16 23:03:00 +00005636 // If we are using LTO, then automatically create a temporary file path for
5637 // the linker to use, so that it's lifetime will extend past a possible
5638 // dsymutil step.
5639 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5640 const char *TmpPath = C.getArgs().MakeArgString(
5641 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5642 C.addTempFile(TmpPath);
5643 CmdArgs.push_back("-object_path_lto");
5644 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005645 }
5646
Daniel Dunbarc1964212009-03-26 16:23:12 +00005647 // Derived from the "link" spec.
5648 Args.AddAllArgs(CmdArgs, options::OPT_static);
5649 if (!Args.hasArg(options::OPT_static))
5650 CmdArgs.push_back("-dynamic");
5651 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5652 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5653 // here. How do we wish to handle such things?
5654 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005655
Daniel Dunbarc1964212009-03-26 16:23:12 +00005656 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005657 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005658 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005659 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005660
5661 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5662 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5663 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5664
5665 Arg *A;
5666 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5667 (A = Args.getLastArg(options::OPT_current__version)) ||
5668 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005669 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005670 << A->getAsString(Args) << "-dynamiclib";
5671
5672 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5673 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5674 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5675 } else {
5676 CmdArgs.push_back("-dylib");
5677
5678 Arg *A;
5679 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5680 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5681 (A = Args.getLastArg(options::OPT_client__name)) ||
5682 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5683 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5684 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005685 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005686 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005687
Daniel Dunbarc1964212009-03-26 16:23:12 +00005688 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5689 "-dylib_compatibility_version");
5690 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5691 "-dylib_current_version");
5692
Tim Northover157d9112014-01-16 08:48:16 +00005693 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005694
5695 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5696 "-dylib_install_name");
5697 }
5698
5699 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5700 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5701 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005702 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005703 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005704 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5705 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5706 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5707 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5708 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5709 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005710 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005711 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5712 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5713 Args.AddAllArgs(CmdArgs, options::OPT_init);
5714
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005715 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005716 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005717
Daniel Dunbarc1964212009-03-26 16:23:12 +00005718 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5719 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5720 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5721 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5722 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005723
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005724 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5725 options::OPT_fno_pie,
5726 options::OPT_fno_PIE)) {
5727 if (A->getOption().matches(options::OPT_fpie) ||
5728 A->getOption().matches(options::OPT_fPIE))
5729 CmdArgs.push_back("-pie");
5730 else
5731 CmdArgs.push_back("-no_pie");
5732 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005733
5734 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5735 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5736 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5737 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5738 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5739 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5740 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5741 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5742 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5743 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5744 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5745 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5746 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5747 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5748 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5749 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005750
Daniel Dunbar84384642011-05-02 21:03:47 +00005751 // Give --sysroot= preference, over the Apple specific behavior to also use
5752 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005753 StringRef sysroot = C.getSysRoot();
5754 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005755 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005756 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005757 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5758 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005759 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005760 }
5761
Daniel Dunbarc1964212009-03-26 16:23:12 +00005762 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5763 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5764 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5765 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5766 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005767 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005768 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5769 Args.AddAllArgs(CmdArgs, options::OPT_y);
5770 Args.AddLastArg(CmdArgs, options::OPT_w);
5771 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5772 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5773 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5774 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5775 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5776 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5777 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5778 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5779 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5780 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5781 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5782 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5783}
5784
Alexey Bataev186b28a2014-03-06 05:43:53 +00005785enum LibOpenMP {
5786 LibUnknown,
5787 LibGOMP,
5788 LibIOMP5
5789};
5790
Daniel Dunbarc1964212009-03-26 16:23:12 +00005791void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005792 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005793 const InputInfoList &Inputs,
5794 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005795 const char *LinkingOutput) const {
5796 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005797
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005798 // If the number of arguments surpasses the system limits, we will encode the
5799 // input files in a separate file, shortening the command line. To this end,
5800 // build a list of input file names that can be passed via a file with the
5801 // -filelist linker option.
5802 llvm::opt::ArgStringList InputFileList;
5803
Daniel Dunbarc1964212009-03-26 16:23:12 +00005804 // The logic here is derived from gcc's behavior; most of which
5805 // comes from specs (starting with link_command). Consult gcc for
5806 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005807 ArgStringList CmdArgs;
5808
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005809 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5810 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5811 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005812 for (const auto &Arg : Args)
5813 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005814 const char *Exec =
5815 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5816 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00005817 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005818 return;
5819 }
5820
Daniel Dunbarc1964212009-03-26 16:23:12 +00005821 // I'm not sure why this particular decomposition exists in gcc, but
5822 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005823 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005824
Daniel Dunbarc1964212009-03-26 16:23:12 +00005825 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5826 Args.AddAllArgs(CmdArgs, options::OPT_s);
5827 Args.AddAllArgs(CmdArgs, options::OPT_t);
5828 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5829 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005830 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005831 Args.AddAllArgs(CmdArgs, options::OPT_r);
5832
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005833 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5834 // members of static archive libraries which implement Objective-C classes or
5835 // categories.
5836 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5837 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005838
Daniel Dunbarc1964212009-03-26 16:23:12 +00005839 CmdArgs.push_back("-o");
5840 CmdArgs.push_back(Output.getFilename());
5841
Chad Rosier06fd3c62012-05-16 23:45:12 +00005842 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005843 !Args.hasArg(options::OPT_nostartfiles))
5844 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005845
5846 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005847
Alexey Bataev186b28a2014-03-06 05:43:53 +00005848 LibOpenMP UsedOpenMPLib = LibUnknown;
5849 if (Args.hasArg(options::OPT_fopenmp)) {
5850 UsedOpenMPLib = LibGOMP;
5851 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5852 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5853 .Case("libgomp", LibGOMP)
5854 .Case("libiomp5", LibIOMP5)
5855 .Default(LibUnknown);
5856 if (UsedOpenMPLib == LibUnknown)
5857 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5858 << A->getOption().getName() << A->getValue();
5859 }
5860 switch (UsedOpenMPLib) {
5861 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005862 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005863 break;
5864 case LibIOMP5:
5865 CmdArgs.push_back("-liomp5");
5866 break;
5867 case LibUnknown:
5868 break;
5869 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005870
Douglas Gregor9295df02012-05-15 21:00:27 +00005871 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005872 // Build the input file for -filelist (list of linker input files) in case we
5873 // need it later
5874 for (const auto &II : Inputs) {
5875 if (!II.isFilename()) {
5876 // This is a linker input argument.
5877 // We cannot mix input arguments and file names in a -filelist input, thus
5878 // we prematurely stop our list (remaining files shall be passed as
5879 // arguments).
5880 if (InputFileList.size() > 0)
5881 break;
5882
5883 continue;
5884 }
5885
5886 InputFileList.push_back(II.getFilename());
5887 }
5888
Bob Wilson16d93952012-05-15 18:57:39 +00005889 if (isObjCRuntimeLinked(Args) &&
5890 !Args.hasArg(options::OPT_nostdlib) &&
5891 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005892 // We use arclite library for both ARC and subscripting support.
5893 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5894
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005895 CmdArgs.push_back("-framework");
5896 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005897 // Link libobj.
5898 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005899 }
John McCall31168b02011-06-15 23:02:42 +00005900
Daniel Dunbarc1964212009-03-26 16:23:12 +00005901 if (LinkingOutput) {
5902 CmdArgs.push_back("-arch_multiple");
5903 CmdArgs.push_back("-final_output");
5904 CmdArgs.push_back(LinkingOutput);
5905 }
5906
Daniel Dunbarc1964212009-03-26 16:23:12 +00005907 if (Args.hasArg(options::OPT_fnested_functions))
5908 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005909
Daniel Dunbarc1964212009-03-26 16:23:12 +00005910 if (!Args.hasArg(options::OPT_nostdlib) &&
5911 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005912 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005913 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005914
Daniel Dunbarc1964212009-03-26 16:23:12 +00005915 // link_ssp spec is empty.
5916
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005917 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005918 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005919 }
5920
Chad Rosier06fd3c62012-05-16 23:45:12 +00005921 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005922 !Args.hasArg(options::OPT_nostartfiles)) {
5923 // endfile_spec is empty.
5924 }
5925
5926 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5927 Args.AddAllArgs(CmdArgs, options::OPT_F);
5928
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005929 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005930 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005931 std::unique_ptr<Command> Cmd =
5932 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
5933 Cmd->setInputFileList(std::move(InputFileList));
5934 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005935}
5936
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005937void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005938 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005939 const InputInfoList &Inputs,
5940 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005941 const char *LinkingOutput) const {
5942 ArgStringList CmdArgs;
5943
5944 CmdArgs.push_back("-create");
5945 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005946
5947 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005948 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005949
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005950 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005951 assert(II.isFilename() && "Unexpected lipo input.");
5952 CmdArgs.push_back(II.getFilename());
5953 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005954
5955 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00005956 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005957}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005958
Daniel Dunbar88299622010-06-04 18:28:36 +00005959void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005960 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005961 const InputInfoList &Inputs,
5962 const ArgList &Args,
5963 const char *LinkingOutput) const {
5964 ArgStringList CmdArgs;
5965
Daniel Dunbareb86b042011-05-09 17:23:16 +00005966 CmdArgs.push_back("-o");
5967 CmdArgs.push_back(Output.getFilename());
5968
Daniel Dunbar88299622010-06-04 18:28:36 +00005969 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5970 const InputInfo &Input = Inputs[0];
5971 assert(Input.isFilename() && "Unexpected dsymutil input.");
5972 CmdArgs.push_back(Input.getFilename());
5973
Daniel Dunbar88299622010-06-04 18:28:36 +00005974 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005975 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00005976 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005977}
5978
Eric Christopher551ef452011-08-23 17:56:55 +00005979void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005980 const InputInfo &Output,
5981 const InputInfoList &Inputs,
5982 const ArgList &Args,
5983 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005984 ArgStringList CmdArgs;
5985 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005986 CmdArgs.push_back("--debug-info");
5987 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005988 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005989
5990 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5991 const InputInfo &Input = Inputs[0];
5992 assert(Input.isFilename() && "Unexpected verify input");
5993
5994 // Grabbing the output of the earlier dsymutil run.
5995 CmdArgs.push_back(Input.getFilename());
5996
5997 const char *Exec =
5998 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00005999 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006000}
6001
David Chisnallf571cde2012-02-15 13:39:01 +00006002void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6003 const InputInfo &Output,
6004 const InputInfoList &Inputs,
6005 const ArgList &Args,
6006 const char *LinkingOutput) const {
6007 ArgStringList CmdArgs;
6008
6009 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6010 options::OPT_Xassembler);
6011
6012 CmdArgs.push_back("-o");
6013 CmdArgs.push_back(Output.getFilename());
6014
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006015 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006016 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006017
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006018 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006019 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006020}
6021
David Chisnallf571cde2012-02-15 13:39:01 +00006022void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6023 const InputInfo &Output,
6024 const InputInfoList &Inputs,
6025 const ArgList &Args,
6026 const char *LinkingOutput) const {
6027 // FIXME: Find a real GCC, don't hard-code versions here
6028 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6029 const llvm::Triple &T = getToolChain().getTriple();
6030 std::string LibPath = "/usr/lib/";
6031 llvm::Triple::ArchType Arch = T.getArch();
6032 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006033 case llvm::Triple::x86:
6034 GCCLibPath +=
6035 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6036 break;
6037 case llvm::Triple::x86_64:
6038 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6039 GCCLibPath += "/4.5.2/amd64/";
6040 LibPath += "amd64/";
6041 break;
6042 default:
6043 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006044 }
6045
6046 ArgStringList CmdArgs;
6047
David Chisnall272a0712012-02-29 15:06:12 +00006048 // Demangle C++ names in errors
6049 CmdArgs.push_back("-C");
6050
David Chisnallf571cde2012-02-15 13:39:01 +00006051 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6052 (!Args.hasArg(options::OPT_shared))) {
6053 CmdArgs.push_back("-e");
6054 CmdArgs.push_back("_start");
6055 }
6056
6057 if (Args.hasArg(options::OPT_static)) {
6058 CmdArgs.push_back("-Bstatic");
6059 CmdArgs.push_back("-dn");
6060 } else {
6061 CmdArgs.push_back("-Bdynamic");
6062 if (Args.hasArg(options::OPT_shared)) {
6063 CmdArgs.push_back("-shared");
6064 } else {
6065 CmdArgs.push_back("--dynamic-linker");
6066 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6067 }
6068 }
6069
6070 if (Output.isFilename()) {
6071 CmdArgs.push_back("-o");
6072 CmdArgs.push_back(Output.getFilename());
6073 } else {
6074 assert(Output.isNothing() && "Invalid output.");
6075 }
6076
6077 if (!Args.hasArg(options::OPT_nostdlib) &&
6078 !Args.hasArg(options::OPT_nostartfiles)) {
6079 if (!Args.hasArg(options::OPT_shared)) {
6080 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6081 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006082 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006083 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6084 } else {
6085 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006086 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6087 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006088 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006089 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006090 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006091 }
6092
6093 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6094
6095 Args.AddAllArgs(CmdArgs, options::OPT_L);
6096 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6097 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006098 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006099
6100 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6101
6102 if (!Args.hasArg(options::OPT_nostdlib) &&
6103 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006104 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006105 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006106 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006107 if (!Args.hasArg(options::OPT_shared)) {
6108 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006109 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006110 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006111 }
David Chisnallf571cde2012-02-15 13:39:01 +00006112 }
6113
6114 if (!Args.hasArg(options::OPT_nostdlib) &&
6115 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006116 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006117 }
David Chisnall96de9932012-02-16 16:00:47 +00006118 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006119
Alexey Samsonov7811d192014-02-20 13:57:37 +00006120 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006121
6122 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006123 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006124 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006125}
6126
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006127void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006128 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006129 const InputInfoList &Inputs,
6130 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006131 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006132 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006133 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006134
Rafael Espindolacc126272014-02-28 01:55:21 +00006135 switch (getToolChain().getArch()) {
6136 case llvm::Triple::x86:
6137 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6138 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006139 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006140 break;
6141
6142 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006143 CmdArgs.push_back("-mppc");
6144 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006145 break;
6146
6147 case llvm::Triple::sparc:
6148 CmdArgs.push_back("-32");
6149 NeedsKPIC = true;
6150 break;
6151
6152 case llvm::Triple::sparcv9:
6153 CmdArgs.push_back("-64");
6154 CmdArgs.push_back("-Av9a");
6155 NeedsKPIC = true;
6156 break;
6157
6158 case llvm::Triple::mips64:
6159 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006160 StringRef CPUName;
6161 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006162 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006163
6164 CmdArgs.push_back("-mabi");
6165 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6166
6167 if (getToolChain().getArch() == llvm::Triple::mips64)
6168 CmdArgs.push_back("-EB");
6169 else
6170 CmdArgs.push_back("-EL");
6171
Rafael Espindolacc126272014-02-28 01:55:21 +00006172 NeedsKPIC = true;
6173 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006174 }
6175
Rafael Espindolacc126272014-02-28 01:55:21 +00006176 default:
6177 break;
6178 }
6179
6180 if (NeedsKPIC)
6181 addAssemblerKPIC(Args, CmdArgs);
6182
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006183 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6184 options::OPT_Xassembler);
6185
6186 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006187 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006188
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006189 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006190 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006191
6192 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006193 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006194 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006195}
6196
6197void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006198 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006199 const InputInfoList &Inputs,
6200 const ArgList &Args,
6201 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006202 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006203 ArgStringList CmdArgs;
6204
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006205 // Silence warning for "clang -g foo.o -o foo"
6206 Args.ClaimAllArgs(options::OPT_g_Group);
6207 // and "clang -emit-llvm foo.o -o foo"
6208 Args.ClaimAllArgs(options::OPT_emit_llvm);
6209 // and for "clang -w foo.o -o foo". Other warning options are already
6210 // handled somewhere else.
6211 Args.ClaimAllArgs(options::OPT_w);
6212
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006213 if (getToolChain().getArch() == llvm::Triple::mips64)
6214 CmdArgs.push_back("-EB");
6215 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6216 CmdArgs.push_back("-EL");
6217
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006218 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006219 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006220 CmdArgs.push_back("-e");
6221 CmdArgs.push_back("__start");
6222 }
6223
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006224 if (Args.hasArg(options::OPT_static)) {
6225 CmdArgs.push_back("-Bstatic");
6226 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006227 if (Args.hasArg(options::OPT_rdynamic))
6228 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006229 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006230 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006231 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006232 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006233 } else {
6234 CmdArgs.push_back("-dynamic-linker");
6235 CmdArgs.push_back("/usr/libexec/ld.so");
6236 }
6237 }
6238
Rafael Espindola044f7832013-06-05 04:28:55 +00006239 if (Args.hasArg(options::OPT_nopie))
6240 CmdArgs.push_back("-nopie");
6241
Daniel Dunbarb440f562010-08-02 02:38:21 +00006242 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006243 CmdArgs.push_back("-o");
6244 CmdArgs.push_back(Output.getFilename());
6245 } else {
6246 assert(Output.isNothing() && "Invalid output.");
6247 }
6248
6249 if (!Args.hasArg(options::OPT_nostdlib) &&
6250 !Args.hasArg(options::OPT_nostartfiles)) {
6251 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006252 if (Args.hasArg(options::OPT_pg))
6253 CmdArgs.push_back(Args.MakeArgString(
6254 getToolChain().GetFilePath("gcrt0.o")));
6255 else
6256 CmdArgs.push_back(Args.MakeArgString(
6257 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006258 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006259 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006260 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006261 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006262 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006263 }
6264 }
6265
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006266 std::string Triple = getToolChain().getTripleString();
6267 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006268 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006269 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006270 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006271
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006272 Args.AddAllArgs(CmdArgs, options::OPT_L);
6273 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6274 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006275 Args.AddAllArgs(CmdArgs, options::OPT_s);
6276 Args.AddAllArgs(CmdArgs, options::OPT_t);
6277 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6278 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006279
Daniel Dunbar54423b22010-09-17 00:24:54 +00006280 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006281
6282 if (!Args.hasArg(options::OPT_nostdlib) &&
6283 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006284 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006285 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006286 if (Args.hasArg(options::OPT_pg))
6287 CmdArgs.push_back("-lm_p");
6288 else
6289 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006290 }
6291
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006292 // FIXME: For some reason GCC passes -lgcc before adding
6293 // the default system libraries. Just mimic this for now.
6294 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006295
Eric Christopher17674ec2012-09-13 06:32:34 +00006296 if (Args.hasArg(options::OPT_pthread)) {
6297 if (!Args.hasArg(options::OPT_shared) &&
6298 Args.hasArg(options::OPT_pg))
6299 CmdArgs.push_back("-lpthread_p");
6300 else
6301 CmdArgs.push_back("-lpthread");
6302 }
6303
Chandler Carruth45661652011-12-17 22:32:42 +00006304 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006305 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006306 CmdArgs.push_back("-lc_p");
6307 else
6308 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006309 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006310
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006311 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006312 }
6313
6314 if (!Args.hasArg(options::OPT_nostdlib) &&
6315 !Args.hasArg(options::OPT_nostartfiles)) {
6316 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006317 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006318 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006319 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006320 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006321 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006322 }
6323
6324 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006325 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006326 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006327}
Ed Schoutene33194b2009-04-02 19:13:12 +00006328
Eli Friedman9fa28852012-08-08 23:57:20 +00006329void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6330 const InputInfo &Output,
6331 const InputInfoList &Inputs,
6332 const ArgList &Args,
6333 const char *LinkingOutput) const {
6334 ArgStringList CmdArgs;
6335
6336 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6337 options::OPT_Xassembler);
6338
6339 CmdArgs.push_back("-o");
6340 CmdArgs.push_back(Output.getFilename());
6341
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006342 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006343 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006344
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006345 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006346 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006347}
6348
6349void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6350 const InputInfo &Output,
6351 const InputInfoList &Inputs,
6352 const ArgList &Args,
6353 const char *LinkingOutput) const {
6354 const Driver &D = getToolChain().getDriver();
6355 ArgStringList CmdArgs;
6356
6357 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6358 (!Args.hasArg(options::OPT_shared))) {
6359 CmdArgs.push_back("-e");
6360 CmdArgs.push_back("__start");
6361 }
6362
6363 if (Args.hasArg(options::OPT_static)) {
6364 CmdArgs.push_back("-Bstatic");
6365 } else {
6366 if (Args.hasArg(options::OPT_rdynamic))
6367 CmdArgs.push_back("-export-dynamic");
6368 CmdArgs.push_back("--eh-frame-hdr");
6369 CmdArgs.push_back("-Bdynamic");
6370 if (Args.hasArg(options::OPT_shared)) {
6371 CmdArgs.push_back("-shared");
6372 } else {
6373 CmdArgs.push_back("-dynamic-linker");
6374 CmdArgs.push_back("/usr/libexec/ld.so");
6375 }
6376 }
6377
6378 if (Output.isFilename()) {
6379 CmdArgs.push_back("-o");
6380 CmdArgs.push_back(Output.getFilename());
6381 } else {
6382 assert(Output.isNothing() && "Invalid output.");
6383 }
6384
6385 if (!Args.hasArg(options::OPT_nostdlib) &&
6386 !Args.hasArg(options::OPT_nostartfiles)) {
6387 if (!Args.hasArg(options::OPT_shared)) {
6388 if (Args.hasArg(options::OPT_pg))
6389 CmdArgs.push_back(Args.MakeArgString(
6390 getToolChain().GetFilePath("gcrt0.o")));
6391 else
6392 CmdArgs.push_back(Args.MakeArgString(
6393 getToolChain().GetFilePath("crt0.o")));
6394 CmdArgs.push_back(Args.MakeArgString(
6395 getToolChain().GetFilePath("crtbegin.o")));
6396 } else {
6397 CmdArgs.push_back(Args.MakeArgString(
6398 getToolChain().GetFilePath("crtbeginS.o")));
6399 }
6400 }
6401
6402 Args.AddAllArgs(CmdArgs, options::OPT_L);
6403 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6404 Args.AddAllArgs(CmdArgs, options::OPT_e);
6405
6406 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6407
6408 if (!Args.hasArg(options::OPT_nostdlib) &&
6409 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006410 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006411 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6412 if (Args.hasArg(options::OPT_pg))
6413 CmdArgs.push_back("-lm_p");
6414 else
6415 CmdArgs.push_back("-lm");
6416 }
6417
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006418 if (Args.hasArg(options::OPT_pthread)) {
6419 if (!Args.hasArg(options::OPT_shared) &&
6420 Args.hasArg(options::OPT_pg))
6421 CmdArgs.push_back("-lpthread_p");
6422 else
6423 CmdArgs.push_back("-lpthread");
6424 }
6425
Eli Friedman9fa28852012-08-08 23:57:20 +00006426 if (!Args.hasArg(options::OPT_shared)) {
6427 if (Args.hasArg(options::OPT_pg))
6428 CmdArgs.push_back("-lc_p");
6429 else
6430 CmdArgs.push_back("-lc");
6431 }
6432
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006433 StringRef MyArch;
6434 switch (getToolChain().getTriple().getArch()) {
6435 case llvm::Triple::arm:
6436 MyArch = "arm";
6437 break;
6438 case llvm::Triple::x86:
6439 MyArch = "i386";
6440 break;
6441 case llvm::Triple::x86_64:
6442 MyArch = "amd64";
6443 break;
6444 default:
6445 llvm_unreachable("Unsupported architecture");
6446 }
6447 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006448 }
6449
6450 if (!Args.hasArg(options::OPT_nostdlib) &&
6451 !Args.hasArg(options::OPT_nostartfiles)) {
6452 if (!Args.hasArg(options::OPT_shared))
6453 CmdArgs.push_back(Args.MakeArgString(
6454 getToolChain().GetFilePath("crtend.o")));
6455 else
6456 CmdArgs.push_back(Args.MakeArgString(
6457 getToolChain().GetFilePath("crtendS.o")));
6458 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006459
6460 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006461 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006462 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006463}
6464
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006465void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006466 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006467 const InputInfoList &Inputs,
6468 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006469 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006470 ArgStringList CmdArgs;
6471
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006472 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6473 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006474 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006475 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006476 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006477 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006478 else if (getToolChain().getArch() == llvm::Triple::mips ||
6479 getToolChain().getArch() == llvm::Triple::mipsel ||
6480 getToolChain().getArch() == llvm::Triple::mips64 ||
6481 getToolChain().getArch() == llvm::Triple::mips64el) {
6482 StringRef CPUName;
6483 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006484 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006485
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006486 CmdArgs.push_back("-march");
6487 CmdArgs.push_back(CPUName.data());
6488
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006489 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006490 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006491
6492 if (getToolChain().getArch() == llvm::Triple::mips ||
6493 getToolChain().getArch() == llvm::Triple::mips64)
6494 CmdArgs.push_back("-EB");
6495 else
6496 CmdArgs.push_back("-EL");
6497
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006498 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006499 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006500 getToolChain().getArch() == llvm::Triple::armeb ||
6501 getToolChain().getArch() == llvm::Triple::thumb ||
6502 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006503 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006504 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006505 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6506
6507 if (FloatABI == "hard") {
6508 CmdArgs.push_back("-mfpu=vfp");
6509 } else {
6510 CmdArgs.push_back("-mfpu=softvfp");
6511 }
6512
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006513 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006514 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006515 case llvm::Triple::GNUEABI:
6516 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006517 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006518 break;
6519
6520 default:
6521 CmdArgs.push_back("-matpcs");
6522 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006523 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006524 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006525 if (getToolChain().getArch() == llvm::Triple::sparc)
6526 CmdArgs.push_back("-Av8plusa");
6527 else
6528 CmdArgs.push_back("-Av9a");
6529
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006530 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006531 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006532
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006533 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6534 options::OPT_Xassembler);
6535
6536 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006537 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006538
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006539 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006540 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006541
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006542 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006543 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006544}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006545
6546void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006547 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006548 const InputInfoList &Inputs,
6549 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006550 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006551 const toolchains::FreeBSD& ToolChain =
6552 static_cast<const toolchains::FreeBSD&>(getToolChain());
6553 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006554 const bool IsPIE =
6555 !Args.hasArg(options::OPT_shared) &&
6556 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006557 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006558
6559 // Silence warning for "clang -g foo.o -o foo"
6560 Args.ClaimAllArgs(options::OPT_g_Group);
6561 // and "clang -emit-llvm foo.o -o foo"
6562 Args.ClaimAllArgs(options::OPT_emit_llvm);
6563 // and for "clang -w foo.o -o foo". Other warning options are already
6564 // handled somewhere else.
6565 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006566
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006567 if (!D.SysRoot.empty())
6568 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6569
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006570 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006571 CmdArgs.push_back("-pie");
6572
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006573 if (Args.hasArg(options::OPT_static)) {
6574 CmdArgs.push_back("-Bstatic");
6575 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006576 if (Args.hasArg(options::OPT_rdynamic))
6577 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006578 CmdArgs.push_back("--eh-frame-hdr");
6579 if (Args.hasArg(options::OPT_shared)) {
6580 CmdArgs.push_back("-Bshareable");
6581 } else {
6582 CmdArgs.push_back("-dynamic-linker");
6583 CmdArgs.push_back("/libexec/ld-elf.so.1");
6584 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006585 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6586 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006587 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6588 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6589 CmdArgs.push_back("--hash-style=both");
6590 }
6591 }
6592 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006593 }
6594
6595 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6596 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006597 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006598 CmdArgs.push_back("-m");
6599 CmdArgs.push_back("elf_i386_fbsd");
6600 }
6601
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006602 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006603 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006604 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006605 }
6606
Daniel Dunbarb440f562010-08-02 02:38:21 +00006607 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006608 CmdArgs.push_back("-o");
6609 CmdArgs.push_back(Output.getFilename());
6610 } else {
6611 assert(Output.isNothing() && "Invalid output.");
6612 }
6613
6614 if (!Args.hasArg(options::OPT_nostdlib) &&
6615 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006616 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006617 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006618 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006619 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006620 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006621 crt1 = "Scrt1.o";
6622 else
6623 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006624 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006625 if (crt1)
6626 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6627
6628 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6629
Craig Topper92fc2df2014-05-17 16:56:41 +00006630 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006631 if (Args.hasArg(options::OPT_static))
6632 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006633 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006634 crtbegin = "crtbeginS.o";
6635 else
6636 crtbegin = "crtbegin.o";
6637
6638 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006639 }
6640
6641 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00006642 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006643 for (const auto &Path : Paths)
6644 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006645 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6646 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006647 Args.AddAllArgs(CmdArgs, options::OPT_s);
6648 Args.AddAllArgs(CmdArgs, options::OPT_t);
6649 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6650 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006651
Alp Tokerce365ca2013-12-02 12:43:03 +00006652 if (D.IsUsingLTO(Args))
6653 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006654
Alexey Samsonov52550342014-09-15 19:58:40 +00006655 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00006656 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006657
6658 if (!Args.hasArg(options::OPT_nostdlib) &&
6659 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006660 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006661 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006662 if (Args.hasArg(options::OPT_pg))
6663 CmdArgs.push_back("-lm_p");
6664 else
6665 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006666 }
Alexey Samsonov52550342014-09-15 19:58:40 +00006667 if (NeedsSanitizerDeps)
6668 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006669 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6670 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006671 if (Args.hasArg(options::OPT_pg))
6672 CmdArgs.push_back("-lgcc_p");
6673 else
6674 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006675 if (Args.hasArg(options::OPT_static)) {
6676 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006677 } else if (Args.hasArg(options::OPT_pg)) {
6678 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006679 } else {
6680 CmdArgs.push_back("--as-needed");
6681 CmdArgs.push_back("-lgcc_s");
6682 CmdArgs.push_back("--no-as-needed");
6683 }
6684
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006685 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006686 if (Args.hasArg(options::OPT_pg))
6687 CmdArgs.push_back("-lpthread_p");
6688 else
6689 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006690 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006691
Roman Divacky66f22762011-02-10 16:59:40 +00006692 if (Args.hasArg(options::OPT_pg)) {
6693 if (Args.hasArg(options::OPT_shared))
6694 CmdArgs.push_back("-lc");
6695 else
6696 CmdArgs.push_back("-lc_p");
6697 CmdArgs.push_back("-lgcc_p");
6698 } else {
6699 CmdArgs.push_back("-lc");
6700 CmdArgs.push_back("-lgcc");
6701 }
6702
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006703 if (Args.hasArg(options::OPT_static)) {
6704 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006705 } else if (Args.hasArg(options::OPT_pg)) {
6706 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006707 } else {
6708 CmdArgs.push_back("--as-needed");
6709 CmdArgs.push_back("-lgcc_s");
6710 CmdArgs.push_back("--no-as-needed");
6711 }
6712 }
6713
6714 if (!Args.hasArg(options::OPT_nostdlib) &&
6715 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006716 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006717 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006718 else
6719 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006720 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006721 }
6722
Alexey Samsonov7811d192014-02-20 13:57:37 +00006723 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006724
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006725 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006726 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006727 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006728}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006729
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006730void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6731 const InputInfo &Output,
6732 const InputInfoList &Inputs,
6733 const ArgList &Args,
6734 const char *LinkingOutput) const {
6735 ArgStringList CmdArgs;
6736
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006737 // GNU as needs different flags for creating the correct output format
6738 // on architectures with different ABIs or optional feature sets.
6739 switch (getToolChain().getArch()) {
6740 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006741 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006742 break;
6743 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006744 case llvm::Triple::armeb:
6745 case llvm::Triple::thumb:
6746 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006747 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006748 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006749 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006750 }
6751
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006752 case llvm::Triple::mips:
6753 case llvm::Triple::mipsel:
6754 case llvm::Triple::mips64:
6755 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006756 StringRef CPUName;
6757 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006758 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006759
6760 CmdArgs.push_back("-march");
6761 CmdArgs.push_back(CPUName.data());
6762
6763 CmdArgs.push_back("-mabi");
6764 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6765
6766 if (getToolChain().getArch() == llvm::Triple::mips ||
6767 getToolChain().getArch() == llvm::Triple::mips64)
6768 CmdArgs.push_back("-EB");
6769 else
6770 CmdArgs.push_back("-EL");
6771
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006772 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006773 break;
6774 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006775
6776 case llvm::Triple::sparc:
6777 CmdArgs.push_back("-32");
6778 addAssemblerKPIC(Args, CmdArgs);
6779 break;
6780
6781 case llvm::Triple::sparcv9:
6782 CmdArgs.push_back("-64");
6783 CmdArgs.push_back("-Av9");
6784 addAssemblerKPIC(Args, CmdArgs);
6785 break;
6786
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006787 default:
6788 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006789 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006790
6791 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6792 options::OPT_Xassembler);
6793
6794 CmdArgs.push_back("-o");
6795 CmdArgs.push_back(Output.getFilename());
6796
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006797 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006798 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006799
David Chisnallddbd68f2011-09-27 22:03:18 +00006800 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00006801 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006802}
6803
6804void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6805 const InputInfo &Output,
6806 const InputInfoList &Inputs,
6807 const ArgList &Args,
6808 const char *LinkingOutput) const {
6809 const Driver &D = getToolChain().getDriver();
6810 ArgStringList CmdArgs;
6811
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006812 if (!D.SysRoot.empty())
6813 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6814
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006815 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006816 if (Args.hasArg(options::OPT_static)) {
6817 CmdArgs.push_back("-Bstatic");
6818 } else {
6819 if (Args.hasArg(options::OPT_rdynamic))
6820 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006821 if (Args.hasArg(options::OPT_shared)) {
6822 CmdArgs.push_back("-Bshareable");
6823 } else {
6824 CmdArgs.push_back("-dynamic-linker");
6825 CmdArgs.push_back("/libexec/ld.elf_so");
6826 }
6827 }
6828
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006829 // Many NetBSD architectures support more than one ABI.
6830 // Determine the correct emulation for ld.
6831 switch (getToolChain().getArch()) {
6832 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006833 CmdArgs.push_back("-m");
6834 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006835 break;
6836 case llvm::Triple::arm:
6837 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006838 CmdArgs.push_back("-m");
6839 switch (getToolChain().getTriple().getEnvironment()) {
6840 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006841 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006842 CmdArgs.push_back("armelf_nbsd_eabi");
6843 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006844 case llvm::Triple::EABIHF:
6845 case llvm::Triple::GNUEABIHF:
6846 CmdArgs.push_back("armelf_nbsd_eabihf");
6847 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006848 default:
6849 CmdArgs.push_back("armelf_nbsd");
6850 break;
6851 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006852 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00006853 case llvm::Triple::armeb:
6854 case llvm::Triple::thumbeb:
6855 CmdArgs.push_back("-m");
6856 switch (getToolChain().getTriple().getEnvironment()) {
6857 case llvm::Triple::EABI:
6858 case llvm::Triple::GNUEABI:
6859 CmdArgs.push_back("armelfb_nbsd_eabi");
6860 break;
6861 case llvm::Triple::EABIHF:
6862 case llvm::Triple::GNUEABIHF:
6863 CmdArgs.push_back("armelfb_nbsd_eabihf");
6864 break;
6865 default:
6866 CmdArgs.push_back("armelfb_nbsd");
6867 break;
6868 }
6869 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006870 case llvm::Triple::mips64:
6871 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006872 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006873 CmdArgs.push_back("-m");
6874 if (getToolChain().getArch() == llvm::Triple::mips64)
6875 CmdArgs.push_back("elf32btsmip");
6876 else
6877 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006878 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006879 CmdArgs.push_back("-m");
6880 if (getToolChain().getArch() == llvm::Triple::mips64)
6881 CmdArgs.push_back("elf64btsmip");
6882 else
6883 CmdArgs.push_back("elf64ltsmip");
6884 }
6885 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006886 case llvm::Triple::ppc:
6887 CmdArgs.push_back("-m");
6888 CmdArgs.push_back("elf32ppc_nbsd");
6889 break;
6890
6891 case llvm::Triple::ppc64:
6892 case llvm::Triple::ppc64le:
6893 CmdArgs.push_back("-m");
6894 CmdArgs.push_back("elf64ppc");
6895 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006896
6897 case llvm::Triple::sparc:
6898 CmdArgs.push_back("-m");
6899 CmdArgs.push_back("elf32_sparc");
6900 break;
6901
6902 case llvm::Triple::sparcv9:
6903 CmdArgs.push_back("-m");
6904 CmdArgs.push_back("elf64_sparc");
6905 break;
6906
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006907 default:
6908 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006909 }
6910
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006911 if (Output.isFilename()) {
6912 CmdArgs.push_back("-o");
6913 CmdArgs.push_back(Output.getFilename());
6914 } else {
6915 assert(Output.isNothing() && "Invalid output.");
6916 }
6917
6918 if (!Args.hasArg(options::OPT_nostdlib) &&
6919 !Args.hasArg(options::OPT_nostartfiles)) {
6920 if (!Args.hasArg(options::OPT_shared)) {
6921 CmdArgs.push_back(Args.MakeArgString(
6922 getToolChain().GetFilePath("crt0.o")));
6923 CmdArgs.push_back(Args.MakeArgString(
6924 getToolChain().GetFilePath("crti.o")));
6925 CmdArgs.push_back(Args.MakeArgString(
6926 getToolChain().GetFilePath("crtbegin.o")));
6927 } else {
6928 CmdArgs.push_back(Args.MakeArgString(
6929 getToolChain().GetFilePath("crti.o")));
6930 CmdArgs.push_back(Args.MakeArgString(
6931 getToolChain().GetFilePath("crtbeginS.o")));
6932 }
6933 }
6934
6935 Args.AddAllArgs(CmdArgs, options::OPT_L);
6936 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6937 Args.AddAllArgs(CmdArgs, options::OPT_e);
6938 Args.AddAllArgs(CmdArgs, options::OPT_s);
6939 Args.AddAllArgs(CmdArgs, options::OPT_t);
6940 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6941 Args.AddAllArgs(CmdArgs, options::OPT_r);
6942
6943 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6944
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006945 unsigned Major, Minor, Micro;
6946 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6947 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006948 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006949 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00006950 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006951 case llvm::Triple::arm:
6952 case llvm::Triple::armeb:
6953 case llvm::Triple::thumb:
6954 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00006955 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00006956 case llvm::Triple::ppc64:
6957 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006958 case llvm::Triple::x86:
6959 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006960 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006961 break;
6962 default:
6963 break;
6964 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006965 }
6966
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006967 if (!Args.hasArg(options::OPT_nostdlib) &&
6968 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006969 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006970 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6971 CmdArgs.push_back("-lm");
6972 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006973 if (Args.hasArg(options::OPT_pthread))
6974 CmdArgs.push_back("-lpthread");
6975 CmdArgs.push_back("-lc");
6976
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006977 if (useLibgcc) {
6978 if (Args.hasArg(options::OPT_static)) {
6979 // libgcc_eh depends on libc, so resolve as much as possible,
6980 // pull in any new requirements from libc and then get the rest
6981 // of libgcc.
6982 CmdArgs.push_back("-lgcc_eh");
6983 CmdArgs.push_back("-lc");
6984 CmdArgs.push_back("-lgcc");
6985 } else {
6986 CmdArgs.push_back("-lgcc");
6987 CmdArgs.push_back("--as-needed");
6988 CmdArgs.push_back("-lgcc_s");
6989 CmdArgs.push_back("--no-as-needed");
6990 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006991 }
6992 }
6993
6994 if (!Args.hasArg(options::OPT_nostdlib) &&
6995 !Args.hasArg(options::OPT_nostartfiles)) {
6996 if (!Args.hasArg(options::OPT_shared))
6997 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6998 "crtend.o")));
6999 else
7000 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7001 "crtendS.o")));
7002 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7003 "crtn.o")));
7004 }
7005
Alexey Samsonov7811d192014-02-20 13:57:37 +00007006 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007007
Logan Chieneb9162f2014-06-26 14:23:45 +00007008 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007009 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007010}
7011
Thomas Schwinge4e555262013-03-28 19:04:25 +00007012void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7013 const InputInfo &Output,
7014 const InputInfoList &Inputs,
7015 const ArgList &Args,
7016 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00007017 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007018 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007019
7020 // Add --32/--64 to make sure we get the format we want.
7021 // This is incomplete
7022 if (getToolChain().getArch() == llvm::Triple::x86) {
7023 CmdArgs.push_back("--32");
7024 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
Zinovy Nis1db95732014-07-10 15:27:19 +00007025 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7026 CmdArgs.push_back("--x32");
7027 else
7028 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00007029 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
7030 CmdArgs.push_back("-a32");
7031 CmdArgs.push_back("-mppc");
7032 CmdArgs.push_back("-many");
7033 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
7034 CmdArgs.push_back("-a64");
7035 CmdArgs.push_back("-mppc64");
7036 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00007037 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
7038 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007039 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007040 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007041 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007042 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
7043 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007044 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007045 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007046 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
7047 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007048 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007049 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007050 } else if (getToolChain().getArch() == llvm::Triple::arm ||
7051 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007052 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00007053 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
7054 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007055 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
7056 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00007057 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007058
Tim Northover9c7e0352013-12-12 11:55:52 +00007059 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7060 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007061 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007062
7063 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007064
7065 // FIXME: remove krait check when GNU tools support krait cpu
7066 // for now replace it with -march=armv7-a to avoid a lower
7067 // march from being picked in the absence of a cpu flag.
7068 Arg *A;
7069 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7070 StringRef(A->getValue()) == "krait")
7071 CmdArgs.push_back("-march=armv7-a");
7072 else
7073 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007074 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007075 } else if (getToolChain().getArch() == llvm::Triple::mips ||
7076 getToolChain().getArch() == llvm::Triple::mipsel ||
7077 getToolChain().getArch() == llvm::Triple::mips64 ||
7078 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007079 StringRef CPUName;
7080 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007081 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007082 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007083
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007084 CmdArgs.push_back("-march");
7085 CmdArgs.push_back(CPUName.data());
7086
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007087 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007088 CmdArgs.push_back(ABIName.data());
7089
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007090 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7091 // or -mshared (not implemented) is in effect.
7092 bool IsPicOrPie = false;
7093 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7094 options::OPT_fpic, options::OPT_fno_pic,
7095 options::OPT_fPIE, options::OPT_fno_PIE,
7096 options::OPT_fpie, options::OPT_fno_pie)) {
7097 if (A->getOption().matches(options::OPT_fPIC) ||
7098 A->getOption().matches(options::OPT_fpic) ||
7099 A->getOption().matches(options::OPT_fPIE) ||
7100 A->getOption().matches(options::OPT_fpie))
7101 IsPicOrPie = true;
7102 }
7103 if (!IsPicOrPie)
7104 CmdArgs.push_back("-mno-shared");
7105
Daniel Sanders379d44b2014-07-16 11:52:23 +00007106 // LLVM doesn't support -mplt yet and acts as if it is always given.
7107 // However, -mplt has no effect with the N64 ABI.
7108 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007109
7110 if (getToolChain().getArch() == llvm::Triple::mips ||
7111 getToolChain().getArch() == llvm::Triple::mips64)
7112 CmdArgs.push_back("-EB");
7113 else
7114 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007115
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007116 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7117 if (StringRef(A->getValue()) == "2008")
7118 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7119 }
7120
Daniel Sanders379d44b2014-07-16 11:52:23 +00007121 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7122 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7123 options::OPT_mfp64)) {
7124 A->claim();
7125 A->render(Args, CmdArgs);
7126 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7127 ABIName))
7128 CmdArgs.push_back("-mfpxx");
7129
7130 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7131 // -mno-mips16 is actually -no-mips16.
7132 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7133 options::OPT_mno_mips16)) {
7134 if (A->getOption().matches(options::OPT_mips16)) {
7135 A->claim();
7136 A->render(Args, CmdArgs);
7137 } else {
7138 A->claim();
7139 CmdArgs.push_back("-no-mips16");
7140 }
7141 }
7142
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007143 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7144 options::OPT_mno_micromips);
7145 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7146 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7147
Simon Atanasyanbd986632013-11-26 11:58:04 +00007148 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7149 // Do not use AddLastArg because not all versions of MIPS assembler
7150 // support -mmsa / -mno-msa options.
7151 if (A->getOption().matches(options::OPT_mmsa))
7152 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7153 }
7154
Daniel Sanders379d44b2014-07-16 11:52:23 +00007155 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7156 options::OPT_msoft_float);
7157
7158 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7159 options::OPT_mno_odd_spreg);
7160
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007161 NeedsKPIC = true;
7162 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
7163 // Always pass an -march option, since our default of z10 is later
7164 // than the GNU assembler's default.
7165 StringRef CPUName = getSystemZTargetCPU(Args);
7166 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7167 }
7168
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007169 if (NeedsKPIC)
7170 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007171
7172 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7173 options::OPT_Xassembler);
7174
7175 CmdArgs.push_back("-o");
7176 CmdArgs.push_back(Output.getFilename());
7177
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007178 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007179 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007180
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007181 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007182 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007183
7184 // Handle the debug info splitting at object creation time if we're
7185 // creating an object.
7186 // TODO: Currently only works on linux with newer objcopy.
7187 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007188 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007189 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7190 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007191}
7192
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007193static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007194 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007195 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007196 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7197 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007198 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007199 CmdArgs.push_back("-lgcc");
7200
Logan Chien3d3373c2012-11-19 12:04:11 +00007201 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007202 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007203 CmdArgs.push_back("-lgcc");
7204 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007205 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007206 CmdArgs.push_back("--as-needed");
7207 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007208 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007209 CmdArgs.push_back("--no-as-needed");
7210 }
7211
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007212 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007213 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007214 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007215 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007216
7217 // According to Android ABI, we have to link with libdl if we are
7218 // linking with non-static libgcc.
7219 //
7220 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7221 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7222 if (isAndroid && !StaticLibgcc)
7223 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007224}
7225
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007226static std::string getLinuxDynamicLinker(const ArgList &Args,
7227 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007228 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7229 if (ToolChain.getTriple().isArch64Bit())
7230 return "/system/bin/linker64";
7231 else
7232 return "/system/bin/linker";
7233 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7234 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007235 return "/lib/ld-linux.so.2";
Tim Northover40956e62014-07-23 12:32:58 +00007236 else if (ToolChain.getArch() == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007237 return "/lib/ld-linux-aarch64.so.1";
Tim Northover40956e62014-07-23 12:32:58 +00007238 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007239 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007240 else if (ToolChain.getArch() == llvm::Triple::arm ||
7241 ToolChain.getArch() == llvm::Triple::thumb) {
7242 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7243 return "/lib/ld-linux-armhf.so.3";
7244 else
7245 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007246 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7247 ToolChain.getArch() == llvm::Triple::thumbeb) {
7248 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7249 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7250 else
7251 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007252 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007253 ToolChain.getArch() == llvm::Triple::mipsel ||
7254 ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007255 ToolChain.getArch() == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007256 StringRef CPUName;
7257 StringRef ABIName;
7258 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7259 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7260
7261 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7262 .Case("o32", "/lib")
7263 .Case("n32", "/lib32")
7264 .Case("n64", "/lib64")
7265 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007266 StringRef LibName;
7267 if (mips::isUCLibc(Args))
7268 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7269 else
7270 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007271
7272 return (LibDir + "/" + LibName).str();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007273 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7274 return "/lib/ld.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007275 else if (ToolChain.getArch() == llvm::Triple::ppc64) {
7276 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7277 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007278 return "/lib64/ld64.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007279 } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
7280 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7281 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007282 return "/lib64/ld64.so.2";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007283 } else if (ToolChain.getArch() == llvm::Triple::systemz)
7284 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007285 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7286 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007287 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7288 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7289 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007290 else
7291 return "/lib64/ld-linux-x86-64.so.2";
7292}
7293
Renato Golinc4b49242014-02-13 10:01:16 +00007294static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007295 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007296 // Make use of compiler-rt if --rtlib option is used
7297 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7298
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007299 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007300 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007301 switch (TC.getTriple().getOS()) {
7302 default: llvm_unreachable("unsupported OS");
7303 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007304 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007305 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007306 break;
7307 }
Renato Golinc4b49242014-02-13 10:01:16 +00007308 break;
7309 case ToolChain::RLT_Libgcc:
7310 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7311 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007312 }
7313}
7314
Rafael Espindola1e085772014-08-15 17:14:35 +00007315static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7316 switch (T.getArch()) {
7317 case llvm::Triple::x86:
7318 return "elf_i386";
7319 case llvm::Triple::aarch64:
7320 return "aarch64linux";
7321 case llvm::Triple::aarch64_be:
7322 return "aarch64_be_linux";
7323 case llvm::Triple::arm:
7324 case llvm::Triple::thumb:
7325 return "armelf_linux_eabi";
7326 case llvm::Triple::armeb:
7327 case llvm::Triple::thumbeb:
7328 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7329 case llvm::Triple::ppc:
7330 return "elf32ppclinux";
7331 case llvm::Triple::ppc64:
7332 return "elf64ppc";
7333 case llvm::Triple::ppc64le:
7334 return "elf64lppc";
7335 case llvm::Triple::sparc:
7336 return "elf32_sparc";
7337 case llvm::Triple::sparcv9:
7338 return "elf64_sparc";
7339 case llvm::Triple::mips:
7340 return "elf32btsmip";
7341 case llvm::Triple::mipsel:
7342 return "elf32ltsmip";
7343 case llvm::Triple::mips64:
7344 if (mips::hasMipsAbiArg(Args, "n32"))
7345 return "elf32btsmipn32";
7346 return "elf64btsmip";
7347 case llvm::Triple::mips64el:
7348 if (mips::hasMipsAbiArg(Args, "n32"))
7349 return "elf32ltsmipn32";
7350 return "elf64ltsmip";
7351 case llvm::Triple::systemz:
7352 return "elf64_s390";
7353 case llvm::Triple::x86_64:
7354 if (T.getEnvironment() == llvm::Triple::GNUX32)
7355 return "elf32_x86_64";
7356 return "elf_x86_64";
7357 default:
7358 llvm_unreachable("Unexpected arch");
7359 }
7360}
7361
Thomas Schwinge4e555262013-03-28 19:04:25 +00007362void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7363 const InputInfo &Output,
7364 const InputInfoList &Inputs,
7365 const ArgList &Args,
7366 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007367 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007368 static_cast<const toolchains::Linux&>(getToolChain());
7369 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007370 const bool isAndroid =
7371 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007372 const bool IsPIE =
7373 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007374 !Args.hasArg(options::OPT_static) &&
7375 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7376 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007377 // Cannot use isPIEDefault here since otherwise
7378 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007379 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007380
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007381 ArgStringList CmdArgs;
7382
Rafael Espindolad1002f62010-11-15 18:28:16 +00007383 // Silence warning for "clang -g foo.o -o foo"
7384 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007385 // and "clang -emit-llvm foo.o -o foo"
7386 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007387 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007388 // handled somewhere else.
7389 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007390
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007391 if (!D.SysRoot.empty())
7392 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007393
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007394 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007395 CmdArgs.push_back("-pie");
7396
Rafael Espindola1c76c592010-11-07 22:57:16 +00007397 if (Args.hasArg(options::OPT_rdynamic))
7398 CmdArgs.push_back("-export-dynamic");
7399
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007400 if (Args.hasArg(options::OPT_s))
7401 CmdArgs.push_back("-s");
7402
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007403 for (const auto &Opt : ToolChain.ExtraOpts)
7404 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007405
7406 if (!Args.hasArg(options::OPT_static)) {
7407 CmdArgs.push_back("--eh-frame-hdr");
7408 }
7409
7410 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007411 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007412
7413 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007414 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007415 ToolChain.getArch() == llvm::Triple::armeb ||
7416 ToolChain.getArch() == llvm::Triple::thumb ||
7417 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007418 CmdArgs.push_back("-Bstatic");
7419 else
7420 CmdArgs.push_back("-static");
7421 } else if (Args.hasArg(options::OPT_shared)) {
7422 CmdArgs.push_back("-shared");
7423 }
7424
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007425 if (ToolChain.getArch() == llvm::Triple::arm ||
7426 ToolChain.getArch() == llvm::Triple::armeb ||
7427 ToolChain.getArch() == llvm::Triple::thumb ||
7428 ToolChain.getArch() == llvm::Triple::thumbeb ||
7429 (!Args.hasArg(options::OPT_static) &&
7430 !Args.hasArg(options::OPT_shared))) {
7431 CmdArgs.push_back("-dynamic-linker");
7432 CmdArgs.push_back(Args.MakeArgString(
7433 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7434 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007435
7436 CmdArgs.push_back("-o");
7437 CmdArgs.push_back(Output.getFilename());
7438
Rafael Espindola81937ec2010-12-01 01:52:43 +00007439 if (!Args.hasArg(options::OPT_nostdlib) &&
7440 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007441 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007442 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007443 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007444 if (Args.hasArg(options::OPT_pg))
7445 crt1 = "gcrt1.o";
7446 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007447 crt1 = "Scrt1.o";
7448 else
7449 crt1 = "crt1.o";
7450 }
7451 if (crt1)
7452 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007453
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007454 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7455 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007456
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007457 const char *crtbegin;
7458 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007459 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007460 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007461 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007462 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007463 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007464 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007465 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007466 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007467
7468 // Add crtfastmath.o if available and fast math is enabled.
7469 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007470 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007471
7472 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007473 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007474
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007475 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007476
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007477 for (const auto &Path : Paths)
7478 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007479
Alp Tokerce365ca2013-12-02 12:43:03 +00007480 if (D.IsUsingLTO(Args))
7481 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007482
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007483 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7484 CmdArgs.push_back("--no-demangle");
7485
Alexey Samsonov52550342014-09-15 19:58:40 +00007486 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007487 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007488 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007489 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007490
Hans Wennborg70850d82013-07-18 20:29:38 +00007491 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007492 !Args.hasArg(options::OPT_nostdlib) &&
7493 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007494 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7495 !Args.hasArg(options::OPT_static);
7496 if (OnlyLibstdcxxStatic)
7497 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007498 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007499 if (OnlyLibstdcxxStatic)
7500 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007501 CmdArgs.push_back("-lm");
7502 }
7503
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007504 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007505 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7506 if (Args.hasArg(options::OPT_static))
7507 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007508
Alexey Samsonov52550342014-09-15 19:58:40 +00007509 if (NeedsSanitizerDeps)
7510 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7511
Alexey Bataev186b28a2014-03-06 05:43:53 +00007512 LibOpenMP UsedOpenMPLib = LibUnknown;
7513 if (Args.hasArg(options::OPT_fopenmp)) {
7514 UsedOpenMPLib = LibGOMP;
7515 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7516 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7517 .Case("libgomp", LibGOMP)
7518 .Case("libiomp5", LibIOMP5)
7519 .Default(LibUnknown);
7520 if (UsedOpenMPLib == LibUnknown)
7521 D.Diag(diag::err_drv_unsupported_option_argument)
7522 << A->getOption().getName() << A->getValue();
7523 }
7524 switch (UsedOpenMPLib) {
7525 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007526 CmdArgs.push_back("-lgomp");
7527
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007528 // FIXME: Exclude this for platforms with libgomp that don't require
7529 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007530 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007531 break;
7532 case LibIOMP5:
7533 CmdArgs.push_back("-liomp5");
7534 break;
7535 case LibUnknown:
7536 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007537 }
Renato Golinc4b49242014-02-13 10:01:16 +00007538 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007539
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007540 if ((Args.hasArg(options::OPT_pthread) ||
7541 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7542 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007543 CmdArgs.push_back("-lpthread");
7544
7545 CmdArgs.push_back("-lc");
7546
7547 if (Args.hasArg(options::OPT_static))
7548 CmdArgs.push_back("--end-group");
7549 else
Renato Golinc4b49242014-02-13 10:01:16 +00007550 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007551 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007552
Rafael Espindola81937ec2010-12-01 01:52:43 +00007553 if (!Args.hasArg(options::OPT_nostartfiles)) {
7554 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007555 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007556 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007557 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007558 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007559 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007560 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007561
Rafael Espindola81937ec2010-12-01 01:52:43 +00007562 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007563 if (!isAndroid)
7564 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007565 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007566 }
7567
David Blaikiec11bf802014-09-04 16:04:28 +00007568 C.addCommand(
7569 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007570}
7571
Chris Lattner3e2ee142010-07-07 16:01:42 +00007572void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007573 const InputInfo &Output,
7574 const InputInfoList &Inputs,
7575 const ArgList &Args,
7576 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007577 ArgStringList CmdArgs;
7578
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007579 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007580
7581 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007582 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007583
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007584 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007585 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007586
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007587 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007588 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007589}
7590
7591void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007592 const InputInfo &Output,
7593 const InputInfoList &Inputs,
7594 const ArgList &Args,
7595 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007596 const Driver &D = getToolChain().getDriver();
7597 ArgStringList CmdArgs;
7598
Daniel Dunbarb440f562010-08-02 02:38:21 +00007599 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007600 CmdArgs.push_back("-o");
7601 CmdArgs.push_back(Output.getFilename());
7602 } else {
7603 assert(Output.isNothing() && "Invalid output.");
7604 }
7605
7606 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007607 !Args.hasArg(options::OPT_nostartfiles)) {
7608 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7609 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7610 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7611 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7612 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007613
7614 Args.AddAllArgs(CmdArgs, options::OPT_L);
7615 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7616 Args.AddAllArgs(CmdArgs, options::OPT_e);
7617
Daniel Dunbar54423b22010-09-17 00:24:54 +00007618 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007619
Alexey Samsonov7811d192014-02-20 13:57:37 +00007620 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007621
Chris Lattner3e2ee142010-07-07 16:01:42 +00007622 if (!Args.hasArg(options::OPT_nostdlib) &&
7623 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007624 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007625 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007626 CmdArgs.push_back("-lm");
7627 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007628 }
7629
7630 if (!Args.hasArg(options::OPT_nostdlib) &&
7631 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007632 if (Args.hasArg(options::OPT_pthread))
7633 CmdArgs.push_back("-lpthread");
7634 CmdArgs.push_back("-lc");
7635 CmdArgs.push_back("-lCompilerRT-Generic");
7636 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7637 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007638 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007639 }
7640
Logan Chieneb9162f2014-06-26 14:23:45 +00007641 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007642 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007643}
7644
Daniel Dunbarcc912342009-05-02 18:28:39 +00007645/// DragonFly Tools
7646
7647// For now, DragonFly Assemble does just about the same as for
7648// FreeBSD, but this may change soon.
7649void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007650 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007651 const InputInfoList &Inputs,
7652 const ArgList &Args,
7653 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007654 ArgStringList CmdArgs;
7655
7656 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7657 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007658 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007659 CmdArgs.push_back("--32");
7660
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007661 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007662
7663 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007664 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007665
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007666 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007667 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007668
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007669 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007670 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007671}
7672
7673void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007674 const InputInfo &Output,
7675 const InputInfoList &Inputs,
7676 const ArgList &Args,
7677 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007678 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007679 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00007680 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00007681
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007682 if (!D.SysRoot.empty())
7683 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7684
John McCall65b8da02013-04-11 22:55:55 +00007685 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007686 if (Args.hasArg(options::OPT_static)) {
7687 CmdArgs.push_back("-Bstatic");
7688 } else {
John McCall65b8da02013-04-11 22:55:55 +00007689 if (Args.hasArg(options::OPT_rdynamic))
7690 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007691 if (Args.hasArg(options::OPT_shared))
7692 CmdArgs.push_back("-Bshareable");
7693 else {
7694 CmdArgs.push_back("-dynamic-linker");
7695 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7696 }
John McCall65b8da02013-04-11 22:55:55 +00007697 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007698 }
7699
7700 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7701 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007702 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007703 CmdArgs.push_back("-m");
7704 CmdArgs.push_back("elf_i386");
7705 }
7706
Daniel Dunbarb440f562010-08-02 02:38:21 +00007707 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007708 CmdArgs.push_back("-o");
7709 CmdArgs.push_back(Output.getFilename());
7710 } else {
7711 assert(Output.isNothing() && "Invalid output.");
7712 }
7713
7714 if (!Args.hasArg(options::OPT_nostdlib) &&
7715 !Args.hasArg(options::OPT_nostartfiles)) {
7716 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007717 if (Args.hasArg(options::OPT_pg))
7718 CmdArgs.push_back(Args.MakeArgString(
7719 getToolChain().GetFilePath("gcrt1.o")));
7720 else {
7721 if (Args.hasArg(options::OPT_pie))
7722 CmdArgs.push_back(Args.MakeArgString(
7723 getToolChain().GetFilePath("Scrt1.o")));
7724 else
7725 CmdArgs.push_back(Args.MakeArgString(
7726 getToolChain().GetFilePath("crt1.o")));
7727 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007728 }
John McCall65b8da02013-04-11 22:55:55 +00007729 CmdArgs.push_back(Args.MakeArgString(
7730 getToolChain().GetFilePath("crti.o")));
7731 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7732 CmdArgs.push_back(Args.MakeArgString(
7733 getToolChain().GetFilePath("crtbeginS.o")));
7734 else
7735 CmdArgs.push_back(Args.MakeArgString(
7736 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007737 }
7738
7739 Args.AddAllArgs(CmdArgs, options::OPT_L);
7740 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7741 Args.AddAllArgs(CmdArgs, options::OPT_e);
7742
Daniel Dunbar54423b22010-09-17 00:24:54 +00007743 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007744
7745 if (!Args.hasArg(options::OPT_nostdlib) &&
7746 !Args.hasArg(options::OPT_nodefaultlibs)) {
7747 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7748 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007749 if (UseGCC47)
7750 CmdArgs.push_back("-L/usr/lib/gcc47");
7751 else
7752 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007753
7754 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007755 if (UseGCC47) {
7756 CmdArgs.push_back("-rpath");
7757 CmdArgs.push_back("/usr/lib/gcc47");
7758 } else {
7759 CmdArgs.push_back("-rpath");
7760 CmdArgs.push_back("/usr/lib/gcc44");
7761 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007762 }
7763
Hans Wennborg70850d82013-07-18 20:29:38 +00007764 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007765 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007766 CmdArgs.push_back("-lm");
7767 }
7768
Daniel Dunbarcc912342009-05-02 18:28:39 +00007769 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007770 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007771
7772 if (!Args.hasArg(options::OPT_nolibc)) {
7773 CmdArgs.push_back("-lc");
7774 }
7775
John McCall65b8da02013-04-11 22:55:55 +00007776 if (UseGCC47) {
7777 if (Args.hasArg(options::OPT_static) ||
7778 Args.hasArg(options::OPT_static_libgcc)) {
7779 CmdArgs.push_back("-lgcc");
7780 CmdArgs.push_back("-lgcc_eh");
7781 } else {
7782 if (Args.hasArg(options::OPT_shared_libgcc)) {
7783 CmdArgs.push_back("-lgcc_pic");
7784 if (!Args.hasArg(options::OPT_shared))
7785 CmdArgs.push_back("-lgcc");
7786 } else {
7787 CmdArgs.push_back("-lgcc");
7788 CmdArgs.push_back("--as-needed");
7789 CmdArgs.push_back("-lgcc_pic");
7790 CmdArgs.push_back("--no-as-needed");
7791 }
7792 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007793 } else {
John McCall65b8da02013-04-11 22:55:55 +00007794 if (Args.hasArg(options::OPT_shared)) {
7795 CmdArgs.push_back("-lgcc_pic");
7796 } else {
7797 CmdArgs.push_back("-lgcc");
7798 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007799 }
7800 }
7801
7802 if (!Args.hasArg(options::OPT_nostdlib) &&
7803 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007804 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007805 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007806 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007807 else
7808 CmdArgs.push_back(Args.MakeArgString(
7809 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007810 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007811 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007812 }
7813
Alexey Samsonov7811d192014-02-20 13:57:37 +00007814 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007815
Logan Chieneb9162f2014-06-26 14:23:45 +00007816 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007817 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007818}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007819
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00007820// Try to find Exe from a Visual Studio distribution. This first tries to find
7821// an installed copy of Visual Studio and, failing that, looks in the PATH,
7822// making sure that whatever executable that's found is not a same-named exe
7823// from clang itself to prevent clang from falling back to itself.
7824static std::string FindVisualStudioExecutable(const ToolChain &TC,
7825 const char *Exe,
7826 const char *ClangProgramPath) {
7827 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
7828 std::string visualStudioBinDir;
7829 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
7830 visualStudioBinDir)) {
7831 SmallString<128> FilePath(visualStudioBinDir);
7832 llvm::sys::path::append(FilePath, Exe);
7833 if (llvm::sys::fs::can_execute(FilePath.c_str()))
7834 return FilePath.str();
7835 }
7836
7837 return Exe;
7838}
7839
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007840void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7841 const InputInfo &Output,
7842 const InputInfoList &Inputs,
7843 const ArgList &Args,
7844 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007845 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007846 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007847
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007848 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
7849 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007850 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7851 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007852
7853 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007854 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007855 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007856
Zachary Turner10d75b22014-10-22 20:40:43 +00007857 if (!llvm::sys::Process::GetEnv("LIB")) {
7858 // If the VC environment hasn't been configured (perhaps because the user
7859 // did not run vcvarsall), try to build a consistent link environment. If
7860 // the environment variable is set however, assume the user knows what he's
7861 // doing.
7862 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007863 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00007864 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
7865 SmallString<128> LibDir(VisualStudioDir);
7866 llvm::sys::path::append(LibDir, "VC", "lib");
7867 switch (MSVC.getArch()) {
7868 case llvm::Triple::x86:
7869 // x86 just puts the libraries directly in lib
7870 break;
7871 case llvm::Triple::x86_64:
7872 llvm::sys::path::append(LibDir, "amd64");
7873 break;
7874 case llvm::Triple::arm:
7875 llvm::sys::path::append(LibDir, "arm");
7876 break;
7877 default:
7878 break;
7879 }
7880 CmdArgs.push_back(
7881 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
7882 }
7883
7884 std::string WindowsSdkLibPath;
7885 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
7886 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
7887 WindowsSdkLibPath.c_str()));
7888 }
7889
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007890 CmdArgs.push_back("-nologo");
7891
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00007892 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007893 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007894
Hans Wennborgf1a74252013-09-10 20:18:04 +00007895 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
Hans Wennborgf1a74252013-09-10 20:18:04 +00007896 if (DLL) {
7897 CmdArgs.push_back(Args.MakeArgString("-dll"));
7898
7899 SmallString<128> ImplibName(Output.getFilename());
7900 llvm::sys::path::replace_extension(ImplibName, "lib");
7901 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7902 ImplibName.str()));
7903 }
7904
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007905 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007906 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007907 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007908 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007909 static const char *CompilerRTComponents[] = {
7910 "asan_dynamic",
7911 "asan_dynamic_runtime_thunk",
7912 };
7913 for (const auto &Component : CompilerRTComponents)
7914 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00007915 // Make sure the dynamic runtime thunk is not optimized out at link time
7916 // to ensure proper SEH handling.
7917 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00007918 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007919 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00007920 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00007921 static const char *CompilerRTComponents[] = {
7922 "asan",
7923 "asan_cxx",
7924 };
7925 for (const auto &Component : CompilerRTComponents)
7926 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00007927 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007928 }
7929
Hans Wennborg2e274592013-08-13 23:38:57 +00007930 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007931
Reid Kleckner337188f2014-09-16 19:22:00 +00007932 // Add filenames, libraries, and other linker inputs.
7933 for (const auto &Input : Inputs) {
7934 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007935 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00007936 continue;
7937 }
7938
7939 const Arg &A = Input.getInputArg();
7940
7941 // Render -l options differently for the MSVC linker.
7942 if (A.getOption().matches(options::OPT_l)) {
7943 StringRef Lib = A.getValue();
7944 const char *LinkLibArg;
7945 if (Lib.endswith(".lib"))
7946 LinkLibArg = Args.MakeArgString(Lib);
7947 else
7948 LinkLibArg = Args.MakeArgString(Lib + ".lib");
7949 CmdArgs.push_back(LinkLibArg);
7950 continue;
7951 }
7952
7953 // Otherwise, this is some other kind of linker input option like -Wl, -z,
7954 // or -L. Render it, even if MSVC doesn't understand it.
7955 A.renderAsInput(Args, CmdArgs);
7956 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007957
Zachary Turner719f58c2014-12-01 23:06:47 +00007958 // We need to special case some linker paths. In the case of lld, we need to
7959 // translate 'lld' into 'lld-link', and in the case of the regular msvc
7960 // linker, we need to use a special search algorithm.
7961 llvm::SmallString<128> linkPath;
7962 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
7963 if (Linker.equals_lower("lld"))
7964 Linker = "lld-link";
7965
7966 if (Linker.equals_lower("link")) {
7967 // If we're using the MSVC linker, it's not sufficient to just use link
7968 // from the program PATH, because other environments like GnuWin32 install
7969 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007970 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00007971 C.getDriver().getClangProgramPath());
7972 } else {
7973 linkPath = Linker;
7974 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00007975 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00007976 }
7977
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00007978 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00007979 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007980}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007981
7982void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7983 const InputInfo &Output,
7984 const InputInfoList &Inputs,
7985 const ArgList &Args,
7986 const char *LinkingOutput) const {
7987 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7988}
7989
David Blaikiec11bf802014-09-04 16:04:28 +00007990std::unique_ptr<Command> visualstudio::Compile::GetCommand(
7991 Compilation &C, const JobAction &JA, const InputInfo &Output,
7992 const InputInfoList &Inputs, const ArgList &Args,
7993 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00007994 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007995 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007996 CmdArgs.push_back("/c"); // Compile only.
7997 CmdArgs.push_back("/W0"); // No warnings.
7998
7999 // The goal is to be able to invoke this tool correctly based on
8000 // any flag accepted by clang-cl.
8001
8002 // These are spelled the same way in clang and cl.exe,.
8003 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8004 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008005
8006 // Optimization level.
8007 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8008 if (A->getOption().getID() == options::OPT_O0) {
8009 CmdArgs.push_back("/Od");
8010 } else {
8011 StringRef OptLevel = A->getValue();
8012 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8013 A->render(Args, CmdArgs);
8014 else if (OptLevel == "3")
8015 CmdArgs.push_back("/Ox");
8016 }
8017 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008018
8019 // Flags for which clang-cl have an alias.
8020 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8021
David Majnemerf6072342014-07-01 22:24:56 +00008022 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8023 /*default=*/false))
8024 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008025 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8026 options::OPT_fno_function_sections))
8027 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8028 ? "/Gy"
8029 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008030 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8031 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008032 CmdArgs.push_back(
8033 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008034 if (Args.hasArg(options::OPT_fsyntax_only))
8035 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008036 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8037 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008038
Hans Wennborg260ff402013-09-27 17:54:18 +00008039 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008040 for (const auto &Include : Includes)
8041 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008042
Hans Wennborg87cfa712013-09-19 20:32:16 +00008043 // Flags that can simply be passed through.
8044 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8045 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008046 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008047
8048 // The order of these flags is relevant, so pick the last one.
8049 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8050 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8051 A->render(Args, CmdArgs);
8052
8053
8054 // Input filename.
8055 assert(Inputs.size() == 1);
8056 const InputInfo &II = Inputs[0];
8057 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8058 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8059 if (II.isFilename())
8060 CmdArgs.push_back(II.getFilename());
8061 else
8062 II.getInputArg().renderAsInput(Args, CmdArgs);
8063
8064 // Output filename.
8065 assert(Output.getType() == types::TY_Object);
8066 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8067 Output.getFilename());
8068 CmdArgs.push_back(Fo);
8069
Hans Wennborg188382e2013-09-20 18:16:35 +00008070 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008071 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8072 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008073 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8074 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008075}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008076
8077
8078/// XCore Tools
8079// We pass assemble and link construction to the xcc tool.
8080
8081void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8082 const InputInfo &Output,
8083 const InputInfoList &Inputs,
8084 const ArgList &Args,
8085 const char *LinkingOutput) const {
8086 ArgStringList CmdArgs;
8087
8088 CmdArgs.push_back("-o");
8089 CmdArgs.push_back(Output.getFilename());
8090
8091 CmdArgs.push_back("-c");
8092
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008093 if (Args.hasArg(options::OPT_v))
8094 CmdArgs.push_back("-v");
8095
Robert Lytton894d25c2014-05-02 09:33:25 +00008096 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8097 if (!A->getOption().matches(options::OPT_g0))
8098 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008099
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008100 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8101 false))
8102 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008103
8104 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8105 options::OPT_Xassembler);
8106
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008107 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008108 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008109
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008110 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008111 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008112}
8113
8114void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8115 const InputInfo &Output,
8116 const InputInfoList &Inputs,
8117 const ArgList &Args,
8118 const char *LinkingOutput) const {
8119 ArgStringList CmdArgs;
8120
8121 if (Output.isFilename()) {
8122 CmdArgs.push_back("-o");
8123 CmdArgs.push_back(Output.getFilename());
8124 } else {
8125 assert(Output.isNothing() && "Invalid output.");
8126 }
8127
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008128 if (Args.hasArg(options::OPT_v))
8129 CmdArgs.push_back("-v");
8130
David Majnemer8de68642014-12-05 08:11:58 +00008131 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008132 CmdArgs.push_back("-fexceptions");
8133
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008134 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8135
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008136 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008137 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008138}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008139
8140void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8141 const InputInfo &Output,
8142 const InputInfoList &Inputs,
8143 const ArgList &Args,
8144 const char *LinkingOutput) const {
8145 const auto &TC =
8146 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8147 ArgStringList CmdArgs;
8148 const char *Exec;
8149
8150 switch (TC.getArch()) {
8151 default: llvm_unreachable("unsupported architecture");
8152 case llvm::Triple::arm:
8153 case llvm::Triple::thumb:
8154 break;
8155 case llvm::Triple::x86:
8156 CmdArgs.push_back("--32");
8157 break;
8158 case llvm::Triple::x86_64:
8159 CmdArgs.push_back("--64");
8160 break;
8161 }
8162
8163 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8164
8165 CmdArgs.push_back("-o");
8166 CmdArgs.push_back(Output.getFilename());
8167
8168 for (const auto &Input : Inputs)
8169 CmdArgs.push_back(Input.getFilename());
8170
8171 const std::string Assembler = TC.GetProgramPath("as");
8172 Exec = Args.MakeArgString(Assembler);
8173
8174 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8175}
8176
8177void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8178 const InputInfo &Output,
8179 const InputInfoList &Inputs,
8180 const ArgList &Args,
8181 const char *LinkingOutput) const {
8182 const auto &TC =
8183 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8184 const llvm::Triple &T = TC.getTriple();
8185 const Driver &D = TC.getDriver();
8186 SmallString<128> EntryPoint;
8187 ArgStringList CmdArgs;
8188 const char *Exec;
8189
8190 // Silence warning for "clang -g foo.o -o foo"
8191 Args.ClaimAllArgs(options::OPT_g_Group);
8192 // and "clang -emit-llvm foo.o -o foo"
8193 Args.ClaimAllArgs(options::OPT_emit_llvm);
8194 // and for "clang -w foo.o -o foo"
8195 Args.ClaimAllArgs(options::OPT_w);
8196 // Other warning options are already handled somewhere else.
8197
8198 if (!D.SysRoot.empty())
8199 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8200
8201 if (Args.hasArg(options::OPT_pie))
8202 CmdArgs.push_back("-pie");
8203 if (Args.hasArg(options::OPT_rdynamic))
8204 CmdArgs.push_back("-export-dynamic");
8205 if (Args.hasArg(options::OPT_s))
8206 CmdArgs.push_back("--strip-all");
8207
8208 CmdArgs.push_back("-m");
8209 switch (TC.getArch()) {
8210 default: llvm_unreachable("unsupported architecture");
8211 case llvm::Triple::arm:
8212 case llvm::Triple::thumb:
8213 // FIXME: this is incorrect for WinCE
8214 CmdArgs.push_back("thumb2pe");
8215 break;
8216 case llvm::Triple::x86:
8217 CmdArgs.push_back("i386pe");
8218 EntryPoint.append("_");
8219 break;
8220 case llvm::Triple::x86_64:
8221 CmdArgs.push_back("i386pep");
8222 break;
8223 }
8224
8225 if (Args.hasArg(options::OPT_shared)) {
8226 switch (T.getArch()) {
8227 default: llvm_unreachable("unsupported architecture");
8228 case llvm::Triple::arm:
8229 case llvm::Triple::thumb:
8230 case llvm::Triple::x86_64:
8231 EntryPoint.append("_DllMainCRTStartup");
8232 break;
8233 case llvm::Triple::x86:
8234 EntryPoint.append("_DllMainCRTStartup@12");
8235 break;
8236 }
8237
8238 CmdArgs.push_back("-shared");
8239 CmdArgs.push_back("-Bdynamic");
8240
8241 CmdArgs.push_back("--enable-auto-image-base");
8242
8243 CmdArgs.push_back("--entry");
8244 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8245 } else {
8246 EntryPoint.append("mainCRTStartup");
8247
8248 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
8249 : "-Bdynamic");
8250
8251 if (!Args.hasArg(options::OPT_nostdlib) &&
8252 !Args.hasArg(options::OPT_nostartfiles)) {
8253 CmdArgs.push_back("--entry");
8254 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8255 }
8256
8257 // FIXME: handle subsystem
8258 }
8259
8260 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00008261 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008262
8263 CmdArgs.push_back("-o");
8264 CmdArgs.push_back(Output.getFilename());
8265
8266 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
8267 SmallString<261> ImpLib(Output.getFilename());
8268 llvm::sys::path::replace_extension(ImpLib, ".lib");
8269
8270 CmdArgs.push_back("--out-implib");
8271 CmdArgs.push_back(Args.MakeArgString(ImpLib));
8272 }
8273
8274 if (!Args.hasArg(options::OPT_nostdlib) &&
8275 !Args.hasArg(options::OPT_nostartfiles)) {
8276 const std::string CRTPath(D.SysRoot + "/usr/lib/");
8277 const char *CRTBegin;
8278
8279 CRTBegin =
8280 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
8281 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
8282 }
8283
8284 Args.AddAllArgs(CmdArgs, options::OPT_L);
8285
8286 const auto &Paths = TC.getFilePaths();
8287 for (const auto &Path : Paths)
8288 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8289
8290 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
8291
8292 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8293 !Args.hasArg(options::OPT_nodefaultlibs)) {
8294 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
8295 !Args.hasArg(options::OPT_static);
8296 if (StaticCXX)
8297 CmdArgs.push_back("-Bstatic");
8298 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
8299 if (StaticCXX)
8300 CmdArgs.push_back("-Bdynamic");
8301 }
8302
8303 if (!Args.hasArg(options::OPT_nostdlib)) {
8304 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8305 // TODO handle /MT[d] /MD[d]
8306 CmdArgs.push_back("-lmsvcrt");
8307 AddRunTimeLibs(TC, D, CmdArgs, Args);
8308 }
8309 }
8310
8311 const std::string Linker = TC.GetProgramPath("ld");
8312 Exec = Args.MakeArgString(Linker);
8313
8314 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8315}