blob: a2f3c196d9c42d7348d23ba5f33fb319c0dfbaac [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"
Ben Langmuire056ec32015-02-04 18:34:23 +000013#include "clang/Basic/CharInfo.h"
Josh Mageee0fc1a82014-02-11 01:35:14 +000014#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000015#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000016#include "clang/Basic/Version.h"
Rafael Espindola3e34e652015-02-03 16:33:53 +000017#include "clang/Config/config.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000018#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000019#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000020#include "clang/Driver/Driver.h"
21#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000022#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000023#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000024#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000025#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000026#include "clang/Driver/Util.h"
Benjamin Kramer33335df2015-03-01 21:36:40 +000027#include "llvm/ADT/STLExtras.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000028#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000029#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000030#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000031#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000032#include "llvm/Option/Arg.h"
33#include "llvm/Option/ArgList.h"
34#include "llvm/Option/Option.h"
Renato Golin0600e1e2015-05-08 21:04:50 +000035#include "llvm/Support/TargetParser.h"
David Blaikie24bbfed22014-03-31 23:29:38 +000036#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000037#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000038#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000039#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000040#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000041#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000042#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000043#include "llvm/Support/raw_ostream.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000044
Ben Langmuir3b7b5402015-02-03 19:28:37 +000045#ifdef LLVM_ON_UNIX
46#include <unistd.h> // For getuid().
47#endif
48
Daniel Dunbar1a093d22009-03-18 06:00:36 +000049using namespace clang::driver;
50using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000051using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000052using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000053
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000054static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
55 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
56 options::OPT_fpic, options::OPT_fno_pic,
57 options::OPT_fPIE, options::OPT_fno_PIE,
58 options::OPT_fpie, options::OPT_fno_pie);
59 if (!LastPICArg)
60 return;
61 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
62 LastPICArg->getOption().matches(options::OPT_fpic) ||
63 LastPICArg->getOption().matches(options::OPT_fPIE) ||
64 LastPICArg->getOption().matches(options::OPT_fpie)) {
65 CmdArgs.push_back("-KPIC");
66 }
67}
68
Daniel Dunbar64198ef2009-09-10 01:21:05 +000069/// CheckPreprocessingOptions - Perform some validation of preprocessing
70/// arguments that is shared with gcc.
71static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000072 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
73 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
74 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000075 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000076 << A->getBaseArg().getAsString(Args)
77 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
78 }
79 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000080}
81
Daniel Dunbar4eadb602009-09-10 01:21:12 +000082/// CheckCodeGenerationOptions - Perform some validation of code generation
83/// arguments that is shared with gcc.
84static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
85 // In gcc, only ARM checks this, but it seems reasonable to check universally.
86 if (Args.hasArg(options::OPT_static))
87 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
88 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000089 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000090 << A->getAsString(Args) << "-static";
91}
92
Bob Wilsond5aad2a2014-11-04 22:28:48 +000093// Add backslashes to escape spaces and other backslashes.
94// This is used for the space-separated argument list specified with
95// the -dwarf-debug-flags option.
96static void EscapeSpacesAndBackslashes(const char *Arg,
97 SmallVectorImpl<char> &Res) {
98 for ( ; *Arg; ++Arg) {
99 switch (*Arg) {
100 default: break;
101 case ' ':
102 case '\\':
103 Res.push_back('\\');
104 break;
105 }
106 Res.push_back(*Arg);
107 }
108}
109
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000110// Quote target names for inclusion in GNU Make dependency files.
111// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000112static void QuoteTarget(StringRef Target,
113 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000114 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
115 switch (Target[i]) {
116 case ' ':
117 case '\t':
118 // Escape the preceding backslashes
119 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
120 Res.push_back('\\');
121
122 // Escape the space/tab
123 Res.push_back('\\');
124 break;
125 case '$':
126 Res.push_back('$');
127 break;
128 case '#':
129 Res.push_back('\\');
130 break;
131 default:
132 break;
133 }
134
135 Res.push_back(Target[i]);
136 }
137}
138
Bill Wendlingc0938f32012-03-12 22:10:06 +0000139static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000140 ArgStringList &CmdArgs,
141 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000142 const char *EnvVar) {
143 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000144 bool CombinedArg = false;
145
Bill Wendling281ca292012-03-12 21:22:35 +0000146 if (!DirList)
147 return; // Nothing to do.
148
Chad Rosier616e8a52012-10-30 21:42:09 +0000149 StringRef Name(ArgName);
150 if (Name.equals("-I") || Name.equals("-L"))
151 CombinedArg = true;
152
Bill Wendling281ca292012-03-12 21:22:35 +0000153 StringRef Dirs(DirList);
154 if (Dirs.empty()) // Empty string should not add '.'.
155 return;
156
157 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000158 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000159 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000160 if (CombinedArg) {
161 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
162 } else {
163 CmdArgs.push_back(ArgName);
164 CmdArgs.push_back(".");
165 }
Bill Wendling281ca292012-03-12 21:22:35 +0000166 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000167 if (CombinedArg) {
168 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
169 } else {
170 CmdArgs.push_back(ArgName);
171 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
172 }
Bill Wendling281ca292012-03-12 21:22:35 +0000173 }
Nico Weber89355782012-03-19 15:00:03 +0000174 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000175 }
176
177 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000178 if (CombinedArg) {
179 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
180 } else {
181 CmdArgs.push_back(ArgName);
182 CmdArgs.push_back(".");
183 }
Bill Wendling281ca292012-03-12 21:22:35 +0000184 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000185 if (CombinedArg) {
186 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
187 } else {
188 CmdArgs.push_back(ArgName);
189 CmdArgs.push_back(Args.MakeArgString(Dirs));
190 }
Bill Wendling281ca292012-03-12 21:22:35 +0000191 }
192}
193
Daniel Dunbar54423b22010-09-17 00:24:54 +0000194static void AddLinkerInputs(const ToolChain &TC,
195 const InputInfoList &Inputs, const ArgList &Args,
196 ArgStringList &CmdArgs) {
197 const Driver &D = TC.getDriver();
198
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000199 // Add extra linker input arguments which are not treated as inputs
200 // (constructed via -Xarch_).
201 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
202
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000203 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000204 if (!TC.HasNativeLLVMSupport()) {
205 // Don't try to pass LLVM inputs unless we have native support.
206 if (II.getType() == types::TY_LLVM_IR ||
207 II.getType() == types::TY_LTO_IR ||
208 II.getType() == types::TY_LLVM_BC ||
209 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000210 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000211 << TC.getTripleString();
212 }
213
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000214 // Add filenames immediately.
215 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000216 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000217 continue;
218 }
219
220 // Otherwise, this is a linker input argument.
221 const Arg &A = II.getInputArg();
222
223 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000224 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000225 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000226 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000227 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000228 else if (A.getOption().matches(options::OPT_z)) {
229 // Pass -z prefix for gcc linker compatibility.
230 A.claim();
231 A.render(Args, CmdArgs);
232 } else {
233 A.renderAsInput(Args, CmdArgs);
234 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000235 }
Bill Wendling281ca292012-03-12 21:22:35 +0000236
237 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000238 // and only supported on native toolchains.
239 if (!TC.isCrossCompiling())
240 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000241}
242
John McCall31168b02011-06-15 23:02:42 +0000243/// \brief Determine whether Objective-C automated reference counting is
244/// enabled.
245static bool isObjCAutoRefCount(const ArgList &Args) {
246 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
247}
248
Ted Kremeneke65b0862012-03-06 20:05:56 +0000249/// \brief Determine whether we are linking the ObjC runtime.
250static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000251 if (isObjCAutoRefCount(Args)) {
252 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000253 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000254 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000255 return Args.hasArg(options::OPT_fobjc_link_runtime);
256}
257
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000258static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000259 // Don't forward inputs from the original command line. They are added from
260 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000261 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000262 !O.hasFlag(options::DriverOption) &&
263 !O.hasFlag(options::LinkerInput);
264}
265
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000266void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000267 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000268 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000269 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000270 ArgStringList &CmdArgs,
271 const InputInfo &Output,
272 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000273 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000274
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000275 CheckPreprocessingOptions(D, Args);
276
277 Args.AddLastArg(CmdArgs, options::OPT_C);
278 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000279
280 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000281 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000282 (A = Args.getLastArg(options::OPT_MD)) ||
283 (A = Args.getLastArg(options::OPT_MMD))) {
284 // Determine the output location.
285 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000286 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000287 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000288 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000289 } else if (Output.getType() == types::TY_Dependencies) {
290 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000291 } else if (A->getOption().matches(options::OPT_M) ||
292 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000293 DepFile = "-";
294 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000295 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000296 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000297 }
298 CmdArgs.push_back("-dependency-file");
299 CmdArgs.push_back(DepFile);
300
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000301 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
303 const char *DepTarget;
304
305 // If user provided -o, that is the dependency target, except
306 // when we are only generating a dependency file.
307 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
308 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000309 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000310 } else {
311 // Otherwise derive from the base input.
312 //
313 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000314 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000315 llvm::sys::path::replace_extension(P, "o");
316 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000317 }
318
319 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000320 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000321 QuoteTarget(DepTarget, Quoted);
322 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000323 }
324
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000325 if (A->getOption().matches(options::OPT_M) ||
326 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000327 CmdArgs.push_back("-sys-header-deps");
Manuel Klimekc68aa162015-03-19 12:00:22 +0000328 if ((isa<PrecompileJobAction>(JA) &&
329 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
330 Args.hasArg(options::OPT_fmodule_file_deps))
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000331 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000332 }
333
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000334 if (Args.hasArg(options::OPT_MG)) {
335 if (!A || A->getOption().matches(options::OPT_MD) ||
336 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000337 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000338 CmdArgs.push_back("-MG");
339 }
340
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000341 Args.AddLastArg(CmdArgs, options::OPT_MP);
Paul Robinsond7214a72015-04-27 18:14:32 +0000342 Args.AddLastArg(CmdArgs, options::OPT_MV);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000343
344 // Convert all -MQ <target> args to -MT <quoted target>
Sean Silva14facf32015-06-09 01:57:17 +0000345 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000346 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000347
Daniel Dunbara442fd52010-06-11 22:00:13 +0000348 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000349 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000350 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000351 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000352 CmdArgs.push_back(Args.MakeArgString(Quoted));
353
354 // -MT flag - no change
355 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000356 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000357 }
358 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000359
Douglas Gregor111af7d2009-04-18 00:34:01 +0000360 // Add -i* options, and automatically translate to
361 // -include-pch/-include-pth for transparent PCH support. It's
362 // wonky, but we include looking for .gch so we can support seamless
363 // replacement into a build system already set up to be generating
364 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000365 bool RenderedImplicitInclude = false;
Sean Silva14facf32015-06-09 01:57:17 +0000366 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000367 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000368 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
369 RenderedImplicitInclude = true;
370
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000371 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000372 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000373
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000374 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000375 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000376 SmallString<128> P(A->getValue());
377 // We want the files to have a name like foo.h.pch. Add a dummy extension
378 // so that replace_extension does the right thing.
379 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000380 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000381 llvm::sys::path::replace_extension(P, "pch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000382 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000383 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000384 }
385
Douglas Gregor111af7d2009-04-18 00:34:01 +0000386 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000387 llvm::sys::path::replace_extension(P, "pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000388 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000389 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000390 }
391
Douglas Gregor111af7d2009-04-18 00:34:01 +0000392 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000393 llvm::sys::path::replace_extension(P, "gch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000394 if (llvm::sys::fs::exists(P)) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000395 FoundPCH = UsePCH;
396 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000397 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000398 }
399
400 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000401 if (IsFirstImplicitInclude) {
402 A->claim();
403 if (UsePCH)
404 CmdArgs.push_back("-include-pch");
405 else
406 CmdArgs.push_back("-include-pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000407 CmdArgs.push_back(Args.MakeArgString(P));
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000408 continue;
409 } else {
410 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000411 D.Diag(diag::warn_drv_pch_not_first_include)
Yaron Keren92e1b622015-03-18 10:17:07 +0000412 << P << A->getAsString(Args);
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000413 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000414 }
415 }
416
417 // Not translated, render as usual.
418 A->claim();
419 A->render(Args, CmdArgs);
420 }
421
422 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000423 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
424 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000425
426 // Add -Wp, and -Xassembler if using the preprocessor.
427
428 // FIXME: There is a very unfortunate problem here, some troubled
429 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
430 // really support that we would have to parse and then translate
431 // those options. :(
432 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
433 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000434
435 // -I- is a deprecated GCC feature, reject it.
436 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000437 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000438
439 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
440 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000441 StringRef sysroot = C.getSysRoot();
442 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000443 if (!Args.hasArg(options::OPT_isysroot)) {
444 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000445 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000446 }
447 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000448
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000449 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000450 // FIXME: We should probably sink the logic for handling these from the
451 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000452 // CPATH - included following the user specified includes (but prior to
453 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000454 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000455 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000456 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000457 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000458 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000459 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000460 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000461 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000462 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000463
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000464 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000465 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000466 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000467
468 // Add system include arguments.
469 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000470}
471
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000472// FIXME: Move to target hook.
473static bool isSignedCharDefault(const llvm::Triple &Triple) {
474 switch (Triple.getArch()) {
475 default:
476 return true;
477
Tim Northover9bb857a2013-01-31 12:13:10 +0000478 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000479 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000480 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000481 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000482 case llvm::Triple::thumb:
483 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000484 if (Triple.isOSDarwin() || Triple.isOSWindows())
485 return true;
486 return false;
487
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000488 case llvm::Triple::ppc:
489 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000490 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000491 return true;
492 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000493
David Majnemerdcecd932015-05-23 19:23:55 +0000494 case llvm::Triple::hexagon:
Bill Schmidt778d3872013-07-26 01:36:11 +0000495 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000496 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000497 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000498 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000499 }
500}
501
Robert Lytton0e076492013-08-13 09:43:10 +0000502static bool isNoCommonDefault(const llvm::Triple &Triple) {
503 switch (Triple.getArch()) {
504 default:
505 return false;
506
507 case llvm::Triple::xcore:
508 return true;
509 }
510}
511
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000512// Handle -mhwdiv=.
513static void getARMHWDivFeatures(const Driver &D, const Arg *A,
514 const ArgList &Args,
515 std::vector<const char *> &Features) {
516 StringRef HWDiv = A->getValue();
517 if (HWDiv == "arm") {
518 Features.push_back("+hwdiv-arm");
519 Features.push_back("-hwdiv");
520 } else if (HWDiv == "thumb") {
521 Features.push_back("-hwdiv-arm");
522 Features.push_back("+hwdiv");
523 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
524 Features.push_back("+hwdiv-arm");
525 Features.push_back("+hwdiv");
526 } else if (HWDiv == "none") {
527 Features.push_back("-hwdiv-arm");
528 Features.push_back("-hwdiv");
529 } else
530 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
531}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000532
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000533// Handle -mfpu=.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000534static void getARMFPUFeatures(const Driver &D, const Arg *A,
535 const ArgList &Args,
536 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000537 StringRef FPU = A->getValue();
John Brawn5a589ad2015-06-05 13:34:11 +0000538 unsigned FPUID = llvm::ARMTargetParser::parseFPU(FPU);
539 if (!llvm::ARMTargetParser::getFPUFeatures(FPUID, Features))
Chad Rosiercfbfc582012-04-04 20:51:35 +0000540 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
541}
542
John Brawn94fd9632015-05-21 12:19:49 +0000543static int getARMSubArchVersionNumber(const llvm::Triple &Triple) {
Renato Golinf6c154d2015-05-22 18:18:25 +0000544 llvm::StringRef Arch = Triple.getArchName();
545 return llvm::ARMTargetParser::parseArchVersion(Arch);
John Brawn94fd9632015-05-21 12:19:49 +0000546}
547
John Brawn94fd9632015-05-21 12:19:49 +0000548static bool isARMMProfile(const llvm::Triple &Triple) {
Renato Golinf6c154d2015-05-22 18:18:25 +0000549 llvm::StringRef Arch = Triple.getArchName();
550 unsigned Profile = llvm::ARMTargetParser::parseArchProfile(Arch);
551 return Profile == llvm::ARM::PK_M;
John Brawn94fd9632015-05-21 12:19:49 +0000552}
553
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000554// Select the float ABI as determined by -msoft-float, -mhard-float, and
555// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000556StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000557 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000558 StringRef FloatABI;
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000559 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
560 options::OPT_mhard_float,
561 options::OPT_mfloat_abi_EQ)) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000562 if (A->getOption().matches(options::OPT_msoft_float))
563 FloatABI = "soft";
564 else if (A->getOption().matches(options::OPT_mhard_float))
565 FloatABI = "hard";
566 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000567 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000568 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000569 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000570 << A->getAsString(Args);
571 FloatABI = "soft";
572 }
573 }
574 }
575
576 // If unspecified, choose the default based on the platform.
577 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000578 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000579 case llvm::Triple::Darwin:
580 case llvm::Triple::MacOSX:
581 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000582 // Darwin defaults to "softfp" for v6 and v7.
583 //
John Brawn94fd9632015-05-21 12:19:49 +0000584 if (getARMSubArchVersionNumber(Triple) == 6 ||
585 getARMSubArchVersionNumber(Triple) == 7)
Daniel Dunbar78485922009-09-10 23:00:09 +0000586 FloatABI = "softfp";
587 else
588 FloatABI = "soft";
589 break;
590 }
591
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000592 // FIXME: this is invalid for WindowsCE
593 case llvm::Triple::Win32:
594 FloatABI = "hard";
595 break;
596
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000597 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000598 switch(Triple.getEnvironment()) {
599 case llvm::Triple::GNUEABIHF:
600 FloatABI = "hard";
601 break;
602 default:
603 // FreeBSD defaults to soft float
604 FloatABI = "soft";
605 break;
606 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000607 break;
608
Daniel Dunbar78485922009-09-10 23:00:09 +0000609 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000610 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000611 case llvm::Triple::GNUEABIHF:
612 FloatABI = "hard";
613 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000614 case llvm::Triple::GNUEABI:
615 FloatABI = "softfp";
616 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000617 case llvm::Triple::EABIHF:
618 FloatABI = "hard";
619 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000620 case llvm::Triple::EABI:
621 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
622 FloatABI = "softfp";
623 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000624 case llvm::Triple::Android: {
John Brawn94fd9632015-05-21 12:19:49 +0000625 if (getARMSubArchVersionNumber(Triple) == 7)
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000626 FloatABI = "softfp";
627 else
628 FloatABI = "soft";
629 break;
630 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000631 default:
632 // Assume "soft", but warn the user we are guessing.
633 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000634 if (Triple.getOS() != llvm::Triple::UnknownOS ||
635 !Triple.isOSBinFormatMachO())
636 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000637 break;
638 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000639 }
640 }
641
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000642 return FloatABI;
643}
644
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000645static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
646 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000647 std::vector<const char *> &Features,
648 bool ForAS) {
Nico Weber6e0ebae2015-04-29 21:16:40 +0000649 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
650 if (!ForAS) {
651 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
652 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
653 // stripped out by the ARM target. We should probably pass this a new
654 // -target-option, which is handled by the -cc1/-cc1as invocation.
655 //
656 // FIXME2: For consistency, it would be ideal if we set up the target
657 // machine state the same when using the frontend or the assembler. We don't
658 // currently do that for the assembler, we pass the options directly to the
659 // backend and never even instantiate the frontend TargetInfo. If we did,
660 // and used its handleTargetFeatures hook, then we could ensure the
661 // assembler and the frontend behave the same.
662
663 // Use software floating point operations?
664 if (FloatABI == "soft")
665 Features.push_back("+soft-float");
666
667 // Use software floating point argument passing?
668 if (FloatABI != "hard")
669 Features.push_back("+soft-float-abi");
670 }
671
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000672 // Honor -mfpu=.
673 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000674 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000675 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
676 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000677
John Brawna8f82342015-05-29 13:10:44 +0000678 // Check if -march is valid by checking if it can be canonicalised and parsed.
679 // getARMArch is used here instead of just checking the -march value in order
680 // to handle -march=native correctly.
John Brawn94fd9632015-05-21 12:19:49 +0000681 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +0000682 std::string Arch = arm::getARMArch(Args, Triple);
John Brawna8f82342015-05-29 13:10:44 +0000683 if (llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_INVALID)
John Brawna95c1a82015-05-08 12:52:18 +0000684 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000685 }
686
687 // We do a similar thing with -mcpu, but here things are complicated because
688 // the only function we have to check if a cpu is valid is
689 // getLLVMArchSuffixForARM which also needs an architecture.
690 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Gabor Ballabas208826c2015-06-04 17:56:32 +0000691 std::string CPU = arm::getARMTargetCPU(Args, Triple);
Gabor Ballabascebcb3b2015-06-11 12:29:56 +0000692 std::string Arch = arm::getARMArch(Args, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000693 if (strcmp(arm::getLLVMArchSuffixForARM(CPU, Arch), "") == 0)
694 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
695 }
John Brawna95c1a82015-05-08 12:52:18 +0000696
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000697 // Setting -msoft-float effectively disables NEON because of the GCC
698 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000699 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000700 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000701 // Also need to explicitly disable features which imply NEON.
702 Features.push_back("-crypto");
703 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000704
Eric Christopher269c2a22015-04-04 03:34:43 +0000705 // En/disable crc code generation.
706 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bernard Ogden18b57012013-10-29 09:47:51 +0000707 if (A->getOption().matches(options::OPT_mcrc))
708 Features.push_back("+crc");
709 else
710 Features.push_back("-crc");
711 }
Vladimir Sukharevc6dab752015-05-14 08:25:18 +0000712
713 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
714 Features.insert(Features.begin(), "+v8.1a");
715 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000716}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000717
718void Clang::AddARMTargetArgs(const ArgList &Args,
719 ArgStringList &CmdArgs,
720 bool KernelOrKext) const {
721 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000722 // Get the effective triple, which takes into account the deployment target.
723 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
724 llvm::Triple Triple(TripleStr);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000725
726 // Select the ABI to use.
727 //
728 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +0000729 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +0000730 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000731 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000732 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000733 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000734 // The backend is hardwired to assume AAPCS for M-class processors, ensure
735 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000736 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Eric Christopher610952e2014-12-05 00:22:48 +0000737 Triple.getOS() == llvm::Triple::UnknownOS ||
John Brawn94fd9632015-05-21 12:19:49 +0000738 isARMMProfile(Triple)) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000739 ABIName = "aapcs";
740 } else {
741 ABIName = "apcs-gnu";
742 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000743 } else if (Triple.isOSWindows()) {
744 // FIXME: this is invalid for WindowsCE
745 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000746 } else {
747 // Select the default based on the platform.
748 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000749 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000750 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000751 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000752 ABIName = "aapcs-linux";
753 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000754 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000755 case llvm::Triple::EABI:
756 ABIName = "aapcs";
757 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000758 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +0000759 if (Triple.getOS() == llvm::Triple::NetBSD)
760 ABIName = "apcs-gnu";
761 else
762 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000763 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000764 }
765 }
766 CmdArgs.push_back("-target-abi");
767 CmdArgs.push_back(ABIName);
768
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000769 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000770 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000771 if (FloatABI == "soft") {
772 // Floating point operations and argument passing are soft.
773 //
774 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000775 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000776 CmdArgs.push_back("-mfloat-abi");
777 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000778 } else if (FloatABI == "softfp") {
779 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000780 CmdArgs.push_back("-mfloat-abi");
781 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000782 } else {
783 // Floating point operations and argument passing are hard.
784 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000785 CmdArgs.push_back("-mfloat-abi");
786 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000787 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000788
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000789 // Kernel code has more strict alignment requirements.
790 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000791 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000792 CmdArgs.push_back("-backend-option");
793 CmdArgs.push_back("-arm-long-calls");
794 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000795
Daniel Dunbar12100e22011-03-22 16:48:17 +0000796 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000797 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000798
799 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000800 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000801 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000802 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000803
Bob Wilson0874e532014-07-29 00:23:18 +0000804 // -mkernel implies -mstrict-align; don't add the redundant option.
805 if (!KernelOrKext) {
806 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
807 options::OPT_munaligned_access)) {
808 CmdArgs.push_back("-backend-option");
809 if (A->getOption().matches(options::OPT_mno_unaligned_access))
810 CmdArgs.push_back("-arm-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000811 else {
Jonathan Roelofs2b00d542014-10-07 15:11:32 +0000812 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
Oliver Stannard76244be2014-08-13 09:18:12 +0000813 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
Bob Wilson0874e532014-07-29 00:23:18 +0000814 CmdArgs.push_back("-arm-no-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000815 }
Bob Wilson0874e532014-07-29 00:23:18 +0000816 }
817 }
818
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000819 // Forward the -mglobal-merge option for explicit control over the pass.
Chad Rosierba3df1d2011-08-26 00:26:29 +0000820 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
821 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000822 CmdArgs.push_back("-backend-option");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000823 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000824 CmdArgs.push_back("-arm-global-merge=false");
825 else
826 CmdArgs.push_back("-arm-global-merge=true");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000827 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000828
Bob Wilson9c8af452013-04-11 18:53:25 +0000829 if (!Args.hasFlag(options::OPT_mimplicit_float,
830 options::OPT_mno_implicit_float,
831 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000832 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000833
Logan Chien749763e2014-04-03 13:12:44 +0000834 // llvm does not support reserving registers in general. There is support
835 // for reserving r9 on ARM though (defined as a platform-specific register
836 // in ARM EABI).
837 if (Args.hasArg(options::OPT_ffixed_r9)) {
838 CmdArgs.push_back("-backend-option");
839 CmdArgs.push_back("-arm-reserve-r9");
840 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000841}
842
Tim Northover573cbee2014-05-24 12:52:07 +0000843/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
844/// targeting.
845static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000846 Arg *A;
847 std::string CPU;
848 // If we have -mtune or -mcpu, use that.
849 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
850 CPU = A->getValue();
851 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
Renato Golin4045f662015-05-08 15:44:36 +0000852 StringRef Mcpu = A->getValue();
Gabor Ballabas726ce7f2015-06-12 17:33:37 +0000853 CPU = Mcpu.split("+").first.lower();
Tim Northovera2ee4332014-03-29 15:09:45 +0000854 }
855
Kevin Qin110db6f2014-07-18 07:03:22 +0000856 // Handle CPU name is 'native'.
857 if (CPU == "native")
858 return llvm::sys::getHostCPUName();
859 else if (CPU.size())
860 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000861
James Molloy9b1586b2014-04-17 12:51:17 +0000862 // Make sure we pick "cyclone" if -arch is used.
863 // FIXME: Should this be picked by checking the target triple instead?
864 if (Args.getLastArg(options::OPT_arch))
865 return "cyclone";
866
867 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000868}
869
Tim Northover573cbee2014-05-24 12:52:07 +0000870void Clang::AddAArch64TargetArgs(const ArgList &Args,
871 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000872 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
873 llvm::Triple Triple(TripleStr);
874
875 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
876 Args.hasArg(options::OPT_mkernel) ||
877 Args.hasArg(options::OPT_fapple_kext))
878 CmdArgs.push_back("-disable-red-zone");
879
880 if (!Args.hasFlag(options::OPT_mimplicit_float,
881 options::OPT_mno_implicit_float, true))
882 CmdArgs.push_back("-no-implicit-float");
883
Craig Topper92fc2df2014-05-17 16:56:41 +0000884 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000885 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
886 ABIName = A->getValue();
887 else if (Triple.isOSDarwin())
888 ABIName = "darwinpcs";
889 else
890 ABIName = "aapcs";
891
892 CmdArgs.push_back("-target-abi");
893 CmdArgs.push_back(ABIName);
894
Bob Wilson0874e532014-07-29 00:23:18 +0000895 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
896 options::OPT_munaligned_access)) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000897 CmdArgs.push_back("-backend-option");
Bob Wilson0874e532014-07-29 00:23:18 +0000898 if (A->getOption().matches(options::OPT_mno_unaligned_access))
899 CmdArgs.push_back("-aarch64-strict-align");
900 else
901 CmdArgs.push_back("-aarch64-no-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000902 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000903
Bradley Smith9ff64332014-10-13 10:16:06 +0000904 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
905 options::OPT_mno_fix_cortex_a53_835769)) {
906 CmdArgs.push_back("-backend-option");
907 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
908 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
909 else
910 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Bradley Smith04ee8aa2014-10-16 16:35:14 +0000911 } else if (Triple.getEnvironment() == llvm::Triple::Android) {
912 // Enabled A53 errata (835769) workaround by default on android
913 CmdArgs.push_back("-backend-option");
914 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +0000915 }
916
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000917 // Forward the -mglobal-merge option for explicit control over the pass.
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000918 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
919 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000920 CmdArgs.push_back("-backend-option");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000921 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000922 CmdArgs.push_back("-aarch64-global-merge=false");
923 else
924 CmdArgs.push_back("-aarch64-global-merge=true");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000925 }
Renato Golinb625f482015-01-25 23:17:48 +0000926
927 if (Args.hasArg(options::OPT_ffixed_x18)) {
928 CmdArgs.push_back("-backend-option");
929 CmdArgs.push_back("-aarch64-reserve-x18");
930 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000931}
932
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000933// Get CPU and ABI names. They are not independent
934// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000935void mips::getMipsCPUAndABI(const ArgList &Args,
936 const llvm::Triple &Triple,
937 StringRef &CPUName,
938 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000939 const char *DefMips32CPU = "mips32r2";
940 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000941
Daniel Sanders2bf13662014-07-10 14:40:57 +0000942 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
943 // default for mips64(el)?-img-linux-gnu.
944 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
945 Triple.getEnvironment() == llvm::Triple::GNU) {
946 DefMips32CPU = "mips32r6";
947 DefMips64CPU = "mips64r6";
948 }
949
Brad Smithba26f582015-01-06 02:53:17 +0000950 // MIPS3 is the default for mips64*-unknown-openbsd.
951 if (Triple.getOS() == llvm::Triple::OpenBSD)
952 DefMips64CPU = "mips3";
953
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000954 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000955 options::OPT_mcpu_EQ))
956 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000957
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000958 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000959 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000960 // Convert a GNU style Mips ABI name to the name
961 // accepted by LLVM Mips backend.
962 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
963 .Case("32", "o32")
964 .Case("64", "n64")
965 .Default(ABIName);
966 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000967
968 // Setup default CPU and ABI names.
969 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000970 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000971 default:
972 llvm_unreachable("Unexpected triple arch name");
973 case llvm::Triple::mips:
974 case llvm::Triple::mipsel:
975 CPUName = DefMips32CPU;
976 break;
977 case llvm::Triple::mips64:
978 case llvm::Triple::mips64el:
979 CPUName = DefMips64CPU;
980 break;
981 }
982 }
983
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000984 if (ABIName.empty()) {
985 // Deduce ABI name from the target triple.
986 if (Triple.getArch() == llvm::Triple::mips ||
987 Triple.getArch() == llvm::Triple::mipsel)
988 ABIName = "o32";
989 else
990 ABIName = "n64";
991 }
992
993 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000994 // Deduce CPU name from ABI name.
995 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000996 .Cases("o32", "eabi", DefMips32CPU)
997 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000998 .Default("");
999 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001000
1001 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001002}
1003
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001004// Convert ABI name to the GNU tools acceptable variant.
1005static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1006 return llvm::StringSwitch<llvm::StringRef>(ABI)
1007 .Case("o32", "32")
1008 .Case("n64", "64")
1009 .Default(ABI);
1010}
1011
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001012// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1013// and -mfloat-abi=.
1014static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001015 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001016 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001017 options::OPT_mhard_float,
1018 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001019 if (A->getOption().matches(options::OPT_msoft_float))
1020 FloatABI = "soft";
1021 else if (A->getOption().matches(options::OPT_mhard_float))
1022 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001023 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001024 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001025 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001026 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001027 FloatABI = "hard";
1028 }
1029 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001030 }
1031
1032 // If unspecified, choose the default based on the platform.
1033 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001034 // Assume "hard", because it's a default value used by gcc.
1035 // When we start to recognize specific target MIPS processors,
1036 // we will be able to select the default more correctly.
1037 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001038 }
1039
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001040 return FloatABI;
1041}
1042
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001043static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001044 std::vector<const char *> &Features,
1045 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001046 StringRef FeatureName) {
1047 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001048 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001049 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001050 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001051 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001052 }
1053}
1054
Daniel Sanders379d44b2014-07-16 11:52:23 +00001055static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1056 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001057 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001058 StringRef CPUName;
1059 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001060 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001061 ABIName = getGnuCompatibleMipsABIName(ABIName);
1062
Daniel Sandersfeb61302014-08-08 15:47:17 +00001063 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1064 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001065
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001066 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001067 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001068 // FIXME: Note, this is a hack. We need to pass the selected float
1069 // mode to the MipsTargetInfoBase to define appropriate macros there.
1070 // Now it is the only method.
1071 Features.push_back("+soft-float");
1072 }
1073
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001074 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001075 StringRef Val = StringRef(A->getValue());
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00001076 if (Val == "2008") {
1077 if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1078 Features.push_back("+nan2008");
1079 else {
1080 Features.push_back("-nan2008");
1081 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1082 }
1083 } else if (Val == "legacy") {
1084 if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1085 Features.push_back("-nan2008");
1086 else {
1087 Features.push_back("+nan2008");
1088 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1089 }
1090 } else
Matheus Almeida602bff32014-05-07 16:16:07 +00001091 D.Diag(diag::err_drv_unsupported_option_argument)
1092 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001093 }
1094
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001095 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1096 options::OPT_mdouble_float, "single-float");
1097 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1098 "mips16");
1099 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1100 options::OPT_mno_micromips, "micromips");
1101 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1102 "dsp");
1103 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1104 "dspr2");
1105 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1106 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001107
1108 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1109 // pass -mfpxx
1110 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1111 options::OPT_mfp64)) {
1112 if (A->getOption().matches(options::OPT_mfp32))
1113 Features.push_back(Args.MakeArgString("-fp64"));
1114 else if (A->getOption().matches(options::OPT_mfpxx)) {
1115 Features.push_back(Args.MakeArgString("+fpxx"));
1116 Features.push_back(Args.MakeArgString("+nooddspreg"));
1117 } else
1118 Features.push_back(Args.MakeArgString("+fp64"));
1119 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001120 Features.push_back(Args.MakeArgString("+fpxx"));
1121 Features.push_back(Args.MakeArgString("+nooddspreg"));
1122 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001123
Daniel Sanders28e5d392014-07-10 10:39:51 +00001124 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1125 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001126}
1127
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001128void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001129 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001130 const Driver &D = getToolChain().getDriver();
1131 StringRef CPUName;
1132 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001133 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001134 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001135
1136 CmdArgs.push_back("-target-abi");
1137 CmdArgs.push_back(ABIName.data());
1138
1139 StringRef FloatABI = getMipsFloatABI(D, Args);
1140
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001141 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001142 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001143 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001144 CmdArgs.push_back("-mfloat-abi");
1145 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001146 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001147 else {
1148 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001149 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001150 CmdArgs.push_back("-mfloat-abi");
1151 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001152 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001153
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001154 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1155 if (A->getOption().matches(options::OPT_mxgot)) {
1156 CmdArgs.push_back("-mllvm");
1157 CmdArgs.push_back("-mxgot");
1158 }
1159 }
1160
Simon Atanasyanc580b322013-05-11 06:33:44 +00001161 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1162 options::OPT_mno_ldc1_sdc1)) {
1163 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1164 CmdArgs.push_back("-mllvm");
1165 CmdArgs.push_back("-mno-ldc1-sdc1");
1166 }
1167 }
1168
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001169 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1170 options::OPT_mno_check_zero_division)) {
1171 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1172 CmdArgs.push_back("-mllvm");
1173 CmdArgs.push_back("-mno-check-zero-division");
1174 }
1175 }
1176
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001177 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001178 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001179 CmdArgs.push_back("-mllvm");
1180 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1181 A->claim();
1182 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001183}
1184
Hal Finkel8eb59282012-06-11 22:35:19 +00001185/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1186static std::string getPPCTargetCPU(const ArgList &Args) {
1187 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001188 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001189
1190 if (CPUName == "native") {
1191 std::string CPU = llvm::sys::getHostCPUName();
1192 if (!CPU.empty() && CPU != "generic")
1193 return CPU;
1194 else
1195 return "";
1196 }
1197
1198 return llvm::StringSwitch<const char *>(CPUName)
1199 .Case("common", "generic")
1200 .Case("440", "440")
1201 .Case("440fp", "440")
1202 .Case("450", "450")
1203 .Case("601", "601")
1204 .Case("602", "602")
1205 .Case("603", "603")
1206 .Case("603e", "603e")
1207 .Case("603ev", "603ev")
1208 .Case("604", "604")
1209 .Case("604e", "604e")
1210 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001211 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001212 .Case("G3", "g3")
1213 .Case("7400", "7400")
1214 .Case("G4", "g4")
1215 .Case("7450", "7450")
1216 .Case("G4+", "g4+")
1217 .Case("750", "750")
1218 .Case("970", "970")
1219 .Case("G5", "g5")
1220 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001221 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001222 .Case("e500mc", "e500mc")
1223 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001224 .Case("power3", "pwr3")
1225 .Case("power4", "pwr4")
1226 .Case("power5", "pwr5")
1227 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001228 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001229 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001230 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001231 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001232 .Case("pwr3", "pwr3")
1233 .Case("pwr4", "pwr4")
1234 .Case("pwr5", "pwr5")
1235 .Case("pwr5x", "pwr5x")
1236 .Case("pwr6", "pwr6")
1237 .Case("pwr6x", "pwr6x")
1238 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001239 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001240 .Case("powerpc", "ppc")
1241 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001242 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001243 .Default("");
1244 }
1245
1246 return "";
1247}
1248
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001249static void getPPCTargetFeatures(const ArgList &Args,
1250 std::vector<const char *> &Features) {
Sean Silva14facf32015-06-09 01:57:17 +00001251 for (const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1252 StringRef Name = A->getOption().getName();
1253 A->claim();
Eric Christopher643bb6a2013-10-16 20:40:08 +00001254
1255 // Skip over "-m".
1256 assert(Name.startswith("m") && "Invalid feature name.");
1257 Name = Name.substr(1);
1258
1259 bool IsNegative = Name.startswith("no-");
1260 if (IsNegative)
1261 Name = Name.substr(3);
1262
1263 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1264 // pass the correct option to the backend while calling the frontend
1265 // option the same.
1266 // TODO: Change the LLVM backend option maybe?
1267 if (Name == "mfcrf")
1268 Name = "mfocrf";
1269
1270 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1271 }
1272
1273 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001274 AddTargetFeature(Args, Features, options::OPT_faltivec,
1275 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001276}
1277
Ulrich Weigand8afad612014-07-28 13:17:52 +00001278void Clang::AddPPCTargetArgs(const ArgList &Args,
1279 ArgStringList &CmdArgs) const {
1280 // Select the ABI to use.
1281 const char *ABIName = nullptr;
1282 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1283 ABIName = A->getValue();
1284 } else if (getToolChain().getTriple().isOSLinux())
1285 switch(getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001286 case llvm::Triple::ppc64: {
1287 // When targeting a processor that supports QPX, or if QPX is
1288 // specifically enabled, default to using the ABI that supports QPX (so
1289 // long as it is not specifically disabled).
1290 bool HasQPX = false;
1291 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1292 HasQPX = A->getValue() == StringRef("a2q");
1293 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1294 if (HasQPX) {
1295 ABIName = "elfv1-qpx";
1296 break;
1297 }
1298
Ulrich Weigand8afad612014-07-28 13:17:52 +00001299 ABIName = "elfv1";
1300 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001301 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001302 case llvm::Triple::ppc64le:
1303 ABIName = "elfv2";
1304 break;
1305 default:
1306 break;
1307 }
1308
1309 if (ABIName) {
1310 CmdArgs.push_back("-target-abi");
1311 CmdArgs.push_back(ABIName);
1312 }
1313}
1314
1315bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1316 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1317 return A && (A->getValue() == StringRef(Value));
1318}
1319
Tom Stellard6674c702013-04-01 20:56:53 +00001320/// Get the (LLVM) name of the R600 gpu we are targeting.
1321static std::string getR600TargetGPU(const ArgList &Args) {
1322 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001323 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001324 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001325 .Cases("rv630", "rv635", "r600")
1326 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001327 .Case("rv740", "rv770")
1328 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001329 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001330 .Case("hemlock", "cypress")
1331 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001332 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001333 }
1334 return "";
1335}
1336
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001337static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001338 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001339 bool SoftFloatABI = true;
1340 if (Arg *A =
1341 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1342 if (A->getOption().matches(options::OPT_mhard_float))
1343 SoftFloatABI = false;
1344 }
1345 if (SoftFloatABI)
1346 Features.push_back("+soft-float");
1347}
1348
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001349void Clang::AddSparcTargetArgs(const ArgList &Args,
1350 ArgStringList &CmdArgs) const {
1351 const Driver &D = getToolChain().getDriver();
1352
Brad Smith10cd0f42014-07-11 20:12:08 +00001353 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001354 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001355 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1356 options::OPT_mhard_float)) {
1357 if (A->getOption().matches(options::OPT_msoft_float))
1358 FloatABI = "soft";
1359 else if (A->getOption().matches(options::OPT_mhard_float))
1360 FloatABI = "hard";
1361 }
1362
1363 // If unspecified, choose the default based on the platform.
1364 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001365 // Assume "soft", but warn the user we are guessing.
1366 FloatABI = "soft";
1367 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001368 }
1369
1370 if (FloatABI == "soft") {
1371 // Floating point operations and argument passing are soft.
1372 //
1373 // FIXME: This changes CPP defines, we need -target-soft-float.
1374 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001375 } else {
1376 assert(FloatABI == "hard" && "Invalid float abi!");
1377 CmdArgs.push_back("-mhard-float");
1378 }
1379}
1380
Richard Sandiford4652d892013-07-19 16:51:51 +00001381static const char *getSystemZTargetCPU(const ArgList &Args) {
1382 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1383 return A->getValue();
1384 return "z10";
1385}
1386
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001387static void getSystemZTargetFeatures(const ArgList &Args,
1388 std::vector<const char *> &Features) {
1389 // -m(no-)htm overrides use of the transactional-execution facility.
1390 if (Arg *A = Args.getLastArg(options::OPT_mhtm,
1391 options::OPT_mno_htm)) {
1392 if (A->getOption().matches(options::OPT_mhtm))
1393 Features.push_back("+transactional-execution");
1394 else
1395 Features.push_back("-transactional-execution");
1396 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001397 // -m(no-)vx overrides use of the vector facility.
1398 if (Arg *A = Args.getLastArg(options::OPT_mvx,
1399 options::OPT_mno_vx)) {
1400 if (A->getOption().matches(options::OPT_mvx))
1401 Features.push_back("+vector");
1402 else
1403 Features.push_back("-vector");
1404 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001405}
1406
Chandler Carruth953fb082013-01-13 11:46:33 +00001407static const char *getX86TargetCPU(const ArgList &Args,
1408 const llvm::Triple &Triple) {
1409 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001410 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001411 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001412 return "core-avx2";
1413
Chandler Carruth953fb082013-01-13 11:46:33 +00001414 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001415 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001416
1417 // FIXME: Reject attempts to use -march=native unless the target matches
1418 // the host.
1419 //
1420 // FIXME: We should also incorporate the detected target features for use
1421 // with -native.
1422 std::string CPU = llvm::sys::getHostCPUName();
1423 if (!CPU.empty() && CPU != "generic")
1424 return Args.MakeArgString(CPU);
1425 }
1426
1427 // Select the default CPU if none was given (or detection failed).
1428
1429 if (Triple.getArch() != llvm::Triple::x86_64 &&
1430 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001431 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001432
1433 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1434
1435 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001436 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001437 if (Triple.getArchName() == "x86_64h")
1438 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001439 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001440 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001441
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001442 // Set up default CPU name for PS4 compilers.
1443 if (Triple.isPS4CPU())
1444 return "btver2";
1445
Alexey Bataev286d1b92014-01-31 04:07:13 +00001446 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001447 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001448 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001449
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001450 // Everything else goes to x86-64 in 64-bit mode.
1451 if (Is64Bit)
1452 return "x86-64";
1453
1454 switch (Triple.getOS()) {
1455 case llvm::Triple::FreeBSD:
1456 case llvm::Triple::NetBSD:
1457 case llvm::Triple::OpenBSD:
1458 return "i486";
1459 case llvm::Triple::Haiku:
1460 return "i586";
1461 case llvm::Triple::Bitrig:
1462 return "i686";
1463 default:
1464 // Fallback to p4.
1465 return "pentium4";
1466 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001467}
1468
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001469static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1470 switch(T.getArch()) {
1471 default:
1472 return "";
1473
Amara Emerson703da2e2013-10-31 09:32:33 +00001474 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001475 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001476 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001477
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001478 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001479 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001480 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001481 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001482 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001483
1484 case llvm::Triple::mips:
1485 case llvm::Triple::mipsel:
1486 case llvm::Triple::mips64:
1487 case llvm::Triple::mips64el: {
1488 StringRef CPUName;
1489 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001490 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001491 return CPUName;
1492 }
1493
1494 case llvm::Triple::ppc:
1495 case llvm::Triple::ppc64:
1496 case llvm::Triple::ppc64le: {
1497 std::string TargetCPUName = getPPCTargetCPU(Args);
1498 // LLVM may default to generating code for the native CPU,
1499 // but, like gcc, we default to a more generic option for
1500 // each architecture. (except on Darwin)
1501 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1502 if (T.getArch() == llvm::Triple::ppc64)
1503 TargetCPUName = "ppc64";
1504 else if (T.getArch() == llvm::Triple::ppc64le)
1505 TargetCPUName = "ppc64le";
1506 else
1507 TargetCPUName = "ppc";
1508 }
1509 return TargetCPUName;
1510 }
1511
1512 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001513 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001514 case llvm::Triple::sparcv9:
1515 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001516 return A->getValue();
1517 return "";
1518
1519 case llvm::Triple::x86:
1520 case llvm::Triple::x86_64:
1521 return getX86TargetCPU(Args, T);
1522
1523 case llvm::Triple::hexagon:
1524 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1525
1526 case llvm::Triple::systemz:
1527 return getSystemZTargetCPU(Args);
1528
1529 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001530 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001531 return getR600TargetGPU(Args);
1532 }
1533}
1534
Alp Tokerce365ca2013-12-02 12:43:03 +00001535static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1536 ArgStringList &CmdArgs) {
1537 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1538 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1539 // forward.
1540 CmdArgs.push_back("-plugin");
Rafael Espindola3e34e652015-02-03 16:33:53 +00001541 std::string Plugin = ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001542 CmdArgs.push_back(Args.MakeArgString(Plugin));
1543
1544 // Try to pass driver level flags relevant to LTO code generation down to
1545 // the plugin.
1546
1547 // Handle flags for selecting CPU variants.
1548 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1549 if (!CPU.empty())
1550 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1551}
1552
Sanjay Patel2987c292015-06-11 14:53:41 +00001553/// This is a helper function for validating the optional refinement step
1554/// parameter in reciprocal argument strings. Return false if there is an error
1555/// parsing the refinement step. Otherwise, return true and set the Position
1556/// of the refinement step in the input string.
1557static bool getRefinementStep(const StringRef &In, const Driver &D,
1558 const Arg &A, size_t &Position) {
1559 const char RefinementStepToken = ':';
1560 Position = In.find(RefinementStepToken);
1561 if (Position != StringRef::npos) {
1562 StringRef Option = A.getOption().getName();
1563 StringRef RefStep = In.substr(Position + 1);
1564 // Allow exactly one numeric character for the additional refinement
1565 // step parameter. This is reasonable for all currently-supported
1566 // operations and architectures because we would expect that a larger value
1567 // of refinement steps would cause the estimate "optimization" to
1568 // under-perform the native operation. Also, if the estimate does not
1569 // converge quickly, it probably will not ever converge, so further
1570 // refinement steps will not produce a better answer.
1571 if (RefStep.size() != 1) {
1572 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1573 return false;
1574 }
1575 char RefStepChar = RefStep[0];
1576 if (RefStepChar < '0' || RefStepChar > '9') {
1577 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1578 return false;
1579 }
1580 }
1581 return true;
1582}
1583
1584/// The -mrecip flag requires processing of many optional parameters.
1585static void ParseMRecip(const Driver &D, const ArgList &Args,
1586 ArgStringList &OutStrings) {
1587 StringRef DisabledPrefixIn = "!";
1588 StringRef DisabledPrefixOut = "!";
1589 StringRef EnabledPrefixOut = "";
1590 StringRef Out = "-mrecip=";
1591
1592 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1593 if (!A)
1594 return;
1595
1596 unsigned NumOptions = A->getNumValues();
1597 if (NumOptions == 0) {
1598 // No option is the same as "all".
1599 OutStrings.push_back(Args.MakeArgString(Out + "all"));
1600 return;
1601 }
1602
1603 // Pass through "all", "none", or "default" with an optional refinement step.
1604 if (NumOptions == 1) {
1605 StringRef Val = A->getValue(0);
1606 size_t RefStepLoc;
1607 if (!getRefinementStep(Val, D, *A, RefStepLoc))
1608 return;
1609 StringRef ValBase = Val.slice(0, RefStepLoc);
1610 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1611 OutStrings.push_back(Args.MakeArgString(Out + Val));
1612 return;
1613 }
1614 }
1615
1616 // Each reciprocal type may be enabled or disabled individually.
1617 // Check each input value for validity, concatenate them all back together,
1618 // and pass through.
1619
1620 llvm::StringMap<bool> OptionStrings;
1621 OptionStrings.insert(std::make_pair("divd", false));
1622 OptionStrings.insert(std::make_pair("divf", false));
1623 OptionStrings.insert(std::make_pair("vec-divd", false));
1624 OptionStrings.insert(std::make_pair("vec-divf", false));
1625 OptionStrings.insert(std::make_pair("sqrtd", false));
1626 OptionStrings.insert(std::make_pair("sqrtf", false));
1627 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
1628 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
1629
1630 for (unsigned i = 0; i != NumOptions; ++i) {
1631 StringRef Val = A->getValue(i);
1632
1633 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1634 // Ignore the disablement token for string matching.
1635 if (IsDisabled)
1636 Val = Val.substr(1);
1637
1638 size_t RefStep;
1639 if (!getRefinementStep(Val, D, *A, RefStep))
1640 return;
1641
1642 StringRef ValBase = Val.slice(0, RefStep);
1643 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1644 if (OptionIter == OptionStrings.end()) {
1645 // Try again specifying float suffix.
1646 OptionIter = OptionStrings.find(ValBase.str() + 'f');
1647 if (OptionIter == OptionStrings.end()) {
1648 // The input name did not match any known option string.
1649 D.Diag(diag::err_drv_unknown_argument) << Val;
1650 return;
1651 }
1652 // The option was specified without a float or double suffix.
1653 // Make sure that the double entry was not already specified.
1654 // The float entry will be checked below.
1655 if (OptionStrings[ValBase.str() + 'd']) {
1656 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1657 return;
1658 }
1659 }
1660
1661 if (OptionIter->second == true) {
1662 // Duplicate option specified.
1663 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1664 return;
1665 }
1666
1667 // Mark the matched option as found. Do not allow duplicate specifiers.
1668 OptionIter->second = true;
1669
1670 // If the precision was not specified, also mark the double entry as found.
1671 if (ValBase.back() != 'f' && ValBase.back() != 'd')
1672 OptionStrings[ValBase.str() + 'd'] = true;
1673
1674 // Build the output string.
1675 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1676 Out = Args.MakeArgString(Out + Prefix + Val);
1677 if (i != NumOptions - 1)
1678 Out = Args.MakeArgString(Out + ",");
1679 }
1680
1681 OutStrings.push_back(Args.MakeArgString(Out));
1682}
1683
Eric Christopherc54920a2015-03-23 19:26:05 +00001684static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001685 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001686 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001687 // If -march=native, autodetect the feature list.
1688 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1689 if (StringRef(A->getValue()) == "native") {
1690 llvm::StringMap<bool> HostFeatures;
1691 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1692 for (auto &F : HostFeatures)
1693 Features.push_back(Args.MakeArgString((F.second ? "+" : "-") +
1694 F.first()));
1695 }
1696 }
1697
Jim Grosbach82eee262013-11-16 00:53:35 +00001698 if (Triple.getArchName() == "x86_64h") {
1699 // x86_64h implies quite a few of the more modern subtarget features
1700 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1701 Features.push_back("-rdrnd");
1702 Features.push_back("-aes");
1703 Features.push_back("-pclmul");
1704 Features.push_back("-rtm");
1705 Features.push_back("-hle");
1706 Features.push_back("-fsgsbase");
1707 }
1708
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001709 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00001710 // Add features to be compatible with gcc for Android.
Alexey Bataev286d1b92014-01-31 04:07:13 +00001711 if (Triple.getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001712 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001713 Features.push_back("+sse4.2");
1714 Features.push_back("+popcnt");
1715 } else
1716 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001717 }
1718
Eric Christopherc54920a2015-03-23 19:26:05 +00001719 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001720 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1721 StringRef Arch = A->getValue();
1722 bool ArchUsed = false;
1723 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001724 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001725 if (Arch == "AVX" || Arch == "AVX2") {
1726 ArchUsed = true;
1727 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1728 }
1729 }
1730 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001731 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001732 if (Arch == "IA32") {
1733 ArchUsed = true;
1734 } else if (Arch == "SSE" || Arch == "SSE2") {
1735 ArchUsed = true;
1736 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1737 }
1738 }
1739 if (!ArchUsed)
1740 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1741 }
1742
Jim Grosbach82eee262013-11-16 00:53:35 +00001743 // Now add any that the user explicitly requested on the command line,
1744 // which may override the defaults.
Sean Silva14facf32015-06-09 01:57:17 +00001745 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1746 StringRef Name = A->getOption().getName();
1747 A->claim();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001748
1749 // Skip over "-m".
1750 assert(Name.startswith("m") && "Invalid feature name.");
1751 Name = Name.substr(1);
1752
1753 bool IsNegative = Name.startswith("no-");
1754 if (IsNegative)
1755 Name = Name.substr(3);
1756
1757 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1758 }
1759}
1760
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001761void Clang::AddX86TargetArgs(const ArgList &Args,
1762 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001763 if (!Args.hasFlag(options::OPT_mred_zone,
1764 options::OPT_mno_red_zone,
1765 true) ||
1766 Args.hasArg(options::OPT_mkernel) ||
1767 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001768 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001769
Bob Wilson2616e2e2013-02-10 16:01:41 +00001770 // Default to avoid implicit floating-point for kernel/kext code, but allow
1771 // that to be overridden with -mno-soft-float.
1772 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1773 Args.hasArg(options::OPT_fapple_kext));
1774 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1775 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001776 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001777 options::OPT_mno_implicit_float)) {
1778 const Option &O = A->getOption();
1779 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1780 O.matches(options::OPT_msoft_float));
1781 }
1782 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001783 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001784
1785 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1786 StringRef Value = A->getValue();
1787 if (Value == "intel" || Value == "att") {
1788 CmdArgs.push_back("-mllvm");
1789 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1790 } else {
1791 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1792 << A->getOption().getName() << Value;
1793 }
1794 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001795}
1796
Tony Linthicum76329bf2011-12-12 21:14:55 +00001797void Clang::AddHexagonTargetArgs(const ArgList &Args,
1798 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00001799 CmdArgs.push_back("-mqdsp6-compat");
1800 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001801
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001802 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
1803 std::string SmallDataThreshold="-hexagon-small-data-threshold=";
1804 SmallDataThreshold += v;
Tony Linthicum76329bf2011-12-12 21:14:55 +00001805 CmdArgs.push_back ("-mllvm");
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001806 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001807 }
1808
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001809 if (!Args.hasArg(options::OPT_fno_short_enums))
1810 CmdArgs.push_back("-fshort-enums");
1811 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1812 CmdArgs.push_back ("-mllvm");
1813 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1814 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001815 CmdArgs.push_back ("-mllvm");
1816 CmdArgs.push_back ("-machine-sink-split=0");
1817}
1818
Kevin Qin110db6f2014-07-18 07:03:22 +00001819// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001820static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001821 std::vector<const char *> &Features) {
1822 SmallVector<StringRef, 8> Split;
1823 text.split(Split, StringRef("+"), -1, false);
1824
1825 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1826 const char *result = llvm::StringSwitch<const char *>(Split[I])
1827 .Case("fp", "+fp-armv8")
1828 .Case("simd", "+neon")
1829 .Case("crc", "+crc")
1830 .Case("crypto", "+crypto")
1831 .Case("nofp", "-fp-armv8")
1832 .Case("nosimd", "-neon")
1833 .Case("nocrc", "-crc")
1834 .Case("nocrypto", "-crypto")
1835 .Default(nullptr);
1836 if (result)
1837 Features.push_back(result);
1838 else if (Split[I] == "neon" || Split[I] == "noneon")
1839 D.Diag(diag::err_drv_no_neon_modifier);
1840 else
1841 return false;
1842 }
1843 return true;
1844}
1845
1846// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1847// decode CPU and feature.
1848static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1849 std::vector<const char *> &Features) {
1850 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1851 CPU = Split.first;
Renato Golin84545d72015-02-04 13:31:56 +00001852 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001853 Features.push_back("+neon");
1854 Features.push_back("+crc");
1855 Features.push_back("+crypto");
1856 } else if (CPU == "generic") {
1857 Features.push_back("+neon");
1858 } else {
1859 return false;
1860 }
1861
1862 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1863 return false;
1864
1865 return true;
1866}
1867
1868static bool
1869getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1870 const ArgList &Args,
1871 std::vector<const char *> &Features) {
1872 std::pair<StringRef, StringRef> Split = March.split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001873
1874 if (Split.first == "armv8-a" ||
1875 Split.first == "armv8a") {
1876 // ok, no additional features.
1877 } else if (
1878 Split.first == "armv8.1-a" ||
1879 Split.first == "armv8.1a" ) {
1880 Features.push_back("+v8.1a");
1881 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00001882 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001883 }
Kevin Qin110db6f2014-07-18 07:03:22 +00001884
1885 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1886 return false;
1887
1888 return true;
1889}
1890
1891static bool
1892getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1893 const ArgList &Args,
1894 std::vector<const char *> &Features) {
1895 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001896 std::string McpuLowerCase = Mcpu.lower();
1897 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00001898 return false;
1899
1900 return true;
1901}
1902
1903static bool
1904getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1905 const ArgList &Args,
1906 std::vector<const char *> &Features) {
1907 // Handle CPU name is 'native'.
1908 if (Mtune == "native")
1909 Mtune = llvm::sys::getHostCPUName();
1910 if (Mtune == "cyclone") {
1911 Features.push_back("+zcm");
1912 Features.push_back("+zcz");
1913 }
1914 return true;
1915}
1916
1917static bool
1918getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1919 const ArgList &Args,
1920 std::vector<const char *> &Features) {
1921 StringRef CPU;
1922 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001923 std::string McpuLowerCase = Mcpu.lower();
1924 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00001925 return false;
1926
1927 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1928}
1929
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001930static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1931 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001932 Arg *A;
1933 bool success = true;
1934 // Enable NEON by default.
1935 Features.push_back("+neon");
1936 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1937 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1938 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1939 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001940 else if (Args.hasArg(options::OPT_arch))
1941 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1942 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001943
1944 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1945 success =
1946 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1947 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1948 success =
1949 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001950 else if (Args.hasArg(options::OPT_arch))
1951 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1952 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001953
1954 if (!success)
1955 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001956
1957 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1958 Features.push_back("-fp-armv8");
1959 Features.push_back("-crypto");
1960 Features.push_back("-neon");
1961 }
Bradley Smith418c5932014-05-02 15:17:51 +00001962
1963 // En/disable crc
1964 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1965 options::OPT_mnocrc)) {
1966 if (A->getOption().matches(options::OPT_mcrc))
1967 Features.push_back("+crc");
1968 else
1969 Features.push_back("-crc");
1970 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001971}
1972
1973static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001974 const ArgList &Args, ArgStringList &CmdArgs,
1975 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001976 std::vector<const char *> Features;
1977 switch (Triple.getArch()) {
1978 default:
1979 break;
1980 case llvm::Triple::mips:
1981 case llvm::Triple::mipsel:
1982 case llvm::Triple::mips64:
1983 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001984 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001985 break;
1986
1987 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001988 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001989 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001990 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001991 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001992 break;
1993
1994 case llvm::Triple::ppc:
1995 case llvm::Triple::ppc64:
1996 case llvm::Triple::ppc64le:
1997 getPPCTargetFeatures(Args, Features);
1998 break;
1999 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00002000 case llvm::Triple::sparcel:
Brad Smithf436e9e2014-08-19 21:50:15 +00002001 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002002 getSparcTargetFeatures(Args, Features);
2003 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00002004 case llvm::Triple::systemz:
2005 getSystemZTargetFeatures(Args, Features);
2006 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002007 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00002008 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002009 getAArch64TargetFeatures(D, Args, Features);
2010 break;
2011 case llvm::Triple::x86:
2012 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002013 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002014 break;
2015 }
Rafael Espindola43964802013-08-21 17:34:32 +00002016
2017 // Find the last of each feature.
2018 llvm::StringMap<unsigned> LastOpt;
2019 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2020 const char *Name = Features[I];
2021 assert(Name[0] == '-' || Name[0] == '+');
2022 LastOpt[Name + 1] = I;
2023 }
2024
2025 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2026 // If this feature was overridden, ignore it.
2027 const char *Name = Features[I];
2028 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2029 assert(LastI != LastOpt.end());
2030 unsigned Last = LastI->second;
2031 if (Last != I)
2032 continue;
2033
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002034 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002035 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002036 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002037}
2038
David Majnemerae394812014-12-09 00:12:30 +00002039static bool
2040shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2041 const llvm::Triple &Triple) {
2042 // We use the zero-cost exception tables for Objective-C if the non-fragile
2043 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2044 // later.
2045 if (runtime.isNonFragile())
2046 return true;
2047
2048 if (!Triple.isMacOSX())
2049 return false;
2050
2051 return (!Triple.isMacOSXVersionLT(10,5) &&
2052 (Triple.getArch() == llvm::Triple::x86_64 ||
2053 Triple.getArch() == llvm::Triple::arm));
2054}
2055
Nico Webere8e53112014-05-11 01:04:02 +00002056// exceptionSettings() exists to share the logic between -cc1 and linker
2057// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00002058static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002059 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00002060 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002061 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00002062 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002063
David Majnemer8de68642014-12-05 08:11:58 +00002064 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002065}
2066
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002067/// Adds exception related arguments to the driver command arguments. There's a
2068/// master flag, -fexceptions and also language specific flags to enable/disable
2069/// C++ and Objective-C exceptions. This makes it possible to for example
2070/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002071static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002072 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002073 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002074 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002075 const Driver &D = TC.getDriver();
2076 const llvm::Triple &Triple = TC.getTriple();
2077
Chad Rosier4fab82c2012-03-26 22:04:46 +00002078 if (KernelOrKext) {
2079 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2080 // arguments now to avoid warnings about unused arguments.
2081 Args.ClaimAllArgs(options::OPT_fexceptions);
2082 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2083 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2084 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2085 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2086 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002087 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002088 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002089
David Majnemer8de68642014-12-05 08:11:58 +00002090 // Gather the exception settings from the command line arguments.
2091 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002092
David Majnemerae394812014-12-09 00:12:30 +00002093 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2094 // is not necessarily sensible, but follows GCC.
2095 if (types::isObjC(InputType) &&
2096 Args.hasFlag(options::OPT_fobjc_exceptions,
2097 options::OPT_fno_objc_exceptions,
2098 true)) {
2099 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002100
David Majnemerae394812014-12-09 00:12:30 +00002101 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002102 }
2103
2104 if (types::isCXX(InputType)) {
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00002105 bool CXXExceptionsEnabled =
2106 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002107 Arg *ExceptionArg = Args.getLastArg(
2108 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2109 options::OPT_fexceptions, options::OPT_fno_exceptions);
2110 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002111 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002112 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2113 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002114
2115 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002116 if (Triple.isPS4CPU()) {
2117 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2118 assert(ExceptionArg &&
2119 "On the PS4 exceptions should only be enabled if passing "
2120 "an argument");
2121 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2122 const Arg *RTTIArg = TC.getRTTIArg();
2123 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2124 D.Diag(diag::err_drv_argument_not_allowed_with)
2125 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2126 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2127 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2128 } else
2129 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2130
Anders Carlssone96ab552011-02-28 02:27:16 +00002131 CmdArgs.push_back("-fcxx-exceptions");
2132
David Majnemer8de68642014-12-05 08:11:58 +00002133 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002134 }
2135 }
2136
David Majnemer8de68642014-12-05 08:11:58 +00002137 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002138 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002139}
2140
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002141static bool ShouldDisableAutolink(const ArgList &Args,
2142 const ToolChain &TC) {
2143 bool Default = true;
2144 if (TC.getTriple().isOSDarwin()) {
2145 // The native darwin assembler doesn't support the linker_option directives,
2146 // so we disable them if we think the .s file will be passed to it.
2147 Default = TC.useIntegratedAs();
2148 }
2149 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2150 Default);
2151}
2152
Ted Kremenek62093662013-03-12 17:02:12 +00002153static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2154 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002155 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
2156 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002157 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002158 return !UseDwarfDirectory;
2159}
2160
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002161/// \brief Check whether the given input tree contains any compilation actions.
2162static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002163 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002164 return true;
2165
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002166 for (const auto &Act : *A)
2167 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002168 return true;
2169
2170 return false;
2171}
2172
2173/// \brief Check if -relax-all should be passed to the internal assembler.
2174/// This is done by default when compiling non-assembler source with -O0.
2175static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2176 bool RelaxDefault = true;
2177
2178 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2179 RelaxDefault = A->getOption().matches(options::OPT_O0);
2180
2181 if (RelaxDefault) {
2182 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002183 for (const auto &Act : C.getActions()) {
2184 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002185 RelaxDefault = true;
2186 break;
2187 }
2188 }
2189 }
2190
2191 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2192 RelaxDefault);
2193}
2194
David Blaikie9260ed62013-07-25 21:19:01 +00002195static void CollectArgsForIntegratedAssembler(Compilation &C,
2196 const ArgList &Args,
2197 ArgStringList &CmdArgs,
2198 const Driver &D) {
2199 if (UseRelaxAll(C, Args))
2200 CmdArgs.push_back("-mrelax-all");
2201
David Peixottodfb66142013-11-14 22:52:58 +00002202 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002203 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002204 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2205 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2206 // arg after parsing the '-I' arg.
2207 bool TakeNextArg = false;
2208
David Blaikie9260ed62013-07-25 21:19:01 +00002209 // When using an integrated assembler, translate -Wa, and -Xassembler
2210 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002211 bool CompressDebugSections = false;
Sean Silva14facf32015-06-09 01:57:17 +00002212 for (const Arg *A :
2213 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
David Blaikie9260ed62013-07-25 21:19:01 +00002214 A->claim();
2215
2216 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2217 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002218 if (TakeNextArg) {
2219 CmdArgs.push_back(Value.data());
2220 TakeNextArg = false;
2221 continue;
2222 }
David Blaikie9260ed62013-07-25 21:19:01 +00002223
2224 if (Value == "-force_cpusubtype_ALL") {
2225 // Do nothing, this is the default and we don't support anything else.
2226 } else if (Value == "-L") {
2227 CmdArgs.push_back("-msave-temp-labels");
2228 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002229 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002230 } else if (Value == "--noexecstack") {
2231 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002232 } else if (Value == "-compress-debug-sections" ||
2233 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002234 CompressDebugSections = true;
2235 } else if (Value == "-nocompress-debug-sections" ||
2236 Value == "--nocompress-debug-sections") {
2237 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002238 } else if (Value.startswith("-I")) {
2239 CmdArgs.push_back(Value.data());
2240 // We need to consume the next argument if the current arg is a plain
2241 // -I. The next arg will be the include directory.
2242 if (Value == "-I")
2243 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002244 } else if (Value.startswith("-gdwarf-")) {
2245 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002246 } else {
2247 D.Diag(diag::err_drv_unsupported_option_argument)
2248 << A->getOption().getName() << Value;
2249 }
2250 }
2251 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002252 if (CompressDebugSections) {
2253 if (llvm::zlib::isAvailable())
2254 CmdArgs.push_back("-compress-debug-sections");
2255 else
2256 D.Diag(diag::warn_debug_compression_unavailable);
2257 }
David Blaikie9260ed62013-07-25 21:19:01 +00002258}
2259
Renato Goline807c122014-01-31 11:47:28 +00002260// Until ARM libraries are build separately, we have them all in one library
2261static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool61770ab2015-01-02 21:47:33 +00002262 // FIXME: handle 64-bit
2263 if (TC.getTriple().isOSWindows() &&
2264 !TC.getTriple().isWindowsItaniumEnvironment())
2265 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002266 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002267 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002268 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002269}
2270
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002271static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2272 // The runtimes are located in the OS-specific resource directory.
2273 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002274 const llvm::Triple &Triple = TC.getTriple();
2275 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002276 StringRef OSLibName =
2277 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002278 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002279 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002280}
2281
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002282static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
Dan Albert6f2875d2015-01-28 23:23:36 +00002283 bool Shared = false) {
2284 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2285 ? "-android"
2286 : "";
2287
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002288 bool IsOSWindows = TC.getTriple().isOSWindows();
2289 StringRef Arch = getArchNameForCompilerRTLib(TC);
2290 const char *Prefix = IsOSWindows ? "" : "lib";
2291 const char *Suffix =
2292 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2293
2294 SmallString<128> Path = getCompilerRTLibDir(TC);
2295 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2296 Arch + Env + Suffix);
2297
2298 return Path;
2299}
2300
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002301// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002302// FIXME: Make sure we can also emit shared objects if they're requested
2303// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002304static void addClangRT(const ToolChain &TC, const ArgList &Args,
2305 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002306 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002307
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002308 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002309 // FIXME: why do we link against gcc when we are using compiler-rt?
2310 CmdArgs.push_back("-lgcc_s");
2311 if (TC.getDriver().CCCIsCXX())
2312 CmdArgs.push_back("-lgcc_eh");
2313 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002314}
2315
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002316static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2317 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002318 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2319 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002320 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002321 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Justin Bognera71e6812015-04-30 23:49:42 +00002322 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002323 Args.hasArg(options::OPT_fcreate_profile) ||
2324 Args.hasArg(options::OPT_coverage)))
2325 return;
2326
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002327 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002328}
2329
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002330namespace {
2331enum OpenMPRuntimeKind {
2332 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2333 /// without knowing what runtime to target.
2334 OMPRT_Unknown,
2335
2336 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2337 /// the default for Clang.
2338 OMPRT_OMP,
2339
2340 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2341 /// this runtime but can swallow the pragmas, and find and link against the
2342 /// runtime library itself.
2343 OMPRT_GOMP,
2344
Chandler Carruthc6625c62015-05-28 21:10:31 +00002345 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002346 /// OpenMP runtime. We support this mode for users with existing dependencies
2347 /// on this runtime library name.
2348 OMPRT_IOMP5
2349};
2350}
2351
2352/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002353static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2354 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002355 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2356
2357 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2358 if (A)
2359 RuntimeName = A->getValue();
2360
2361 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2362 .Case("libomp", OMPRT_OMP)
2363 .Case("libgomp", OMPRT_GOMP)
2364 .Case("libiomp5", OMPRT_IOMP5)
2365 .Default(OMPRT_Unknown);
2366
2367 if (RT == OMPRT_Unknown) {
2368 if (A)
2369 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
2370 << A->getOption().getName() << A->getValue();
2371 else
2372 // FIXME: We could use a nicer diagnostic here.
2373 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2374 }
2375
2376 return RT;
2377}
2378
Alexey Samsonov52550342014-09-15 19:58:40 +00002379static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2380 ArgStringList &CmdArgs, StringRef Sanitizer,
2381 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002382 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002383 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002384 if (!IsShared)
2385 CmdArgs.push_back("-whole-archive");
Dan Albert6f2875d2015-01-28 23:23:36 +00002386 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002387 if (!IsShared)
2388 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002389}
2390
Alexey Samsonov52550342014-09-15 19:58:40 +00002391// Tries to use a file with the list of dynamic symbols that need to be exported
2392// from the runtime library. Returns true if the file was found.
2393static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2394 ArgStringList &CmdArgs,
2395 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002396 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2397 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2398 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002399 return true;
2400 }
2401 return false;
2402}
2403
2404static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2405 ArgStringList &CmdArgs) {
2406 // Force linking against the system libraries sanitizers depends on
2407 // (see PR15823 why this is necessary).
2408 CmdArgs.push_back("--no-as-needed");
2409 CmdArgs.push_back("-lpthread");
2410 CmdArgs.push_back("-lrt");
2411 CmdArgs.push_back("-lm");
2412 // There's no libdl on FreeBSD.
2413 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2414 CmdArgs.push_back("-ldl");
2415}
2416
2417static void
2418collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2419 SmallVectorImpl<StringRef> &SharedRuntimes,
2420 SmallVectorImpl<StringRef> &StaticRuntimes,
2421 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2422 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2423 // Collect shared runtimes.
2424 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2425 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002426 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002427
Alexey Samsonov52550342014-09-15 19:58:40 +00002428 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002429 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002430 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2431 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002432 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002433 }
2434 if (SanArgs.needsAsanRt()) {
2435 if (SanArgs.needsSharedAsanRt()) {
2436 HelperStaticRuntimes.push_back("asan-preinit");
2437 } else {
2438 StaticRuntimes.push_back("asan");
2439 if (SanArgs.linkCXXRuntimes())
2440 StaticRuntimes.push_back("asan_cxx");
2441 }
2442 }
2443 if (SanArgs.needsDfsanRt())
2444 StaticRuntimes.push_back("dfsan");
2445 if (SanArgs.needsLsanRt())
2446 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002447 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002448 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002449 if (SanArgs.linkCXXRuntimes())
2450 StaticRuntimes.push_back("msan_cxx");
2451 }
2452 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002453 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002454 if (SanArgs.linkCXXRuntimes())
2455 StaticRuntimes.push_back("tsan_cxx");
2456 }
Alexey Samsonov52550342014-09-15 19:58:40 +00002457 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002458 StaticRuntimes.push_back("ubsan_standalone");
2459 if (SanArgs.linkCXXRuntimes())
2460 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002461 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002462}
2463
Alexey Samsonov52550342014-09-15 19:58:40 +00002464// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2465// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2466static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002467 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002468 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2469 HelperStaticRuntimes;
2470 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2471 HelperStaticRuntimes);
2472 for (auto RT : SharedRuntimes)
2473 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2474 for (auto RT : HelperStaticRuntimes)
2475 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2476 bool AddExportDynamic = false;
2477 for (auto RT : StaticRuntimes) {
2478 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2479 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2480 }
2481 // If there is a static runtime with no dynamic list, force all the symbols
2482 // to be dynamic to be sure we export sanitizer interface functions.
2483 if (AddExportDynamic)
2484 CmdArgs.push_back("-export-dynamic");
2485 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002486}
2487
Reid Kleckner86ea7702015-02-04 23:45:07 +00002488static bool areOptimizationsEnabled(const ArgList &Args) {
2489 // Find the last -O arg and see if it is non-zero.
2490 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2491 return !A->getOption().matches(options::OPT_O0);
2492 // Defaults to -O0.
2493 return false;
2494}
2495
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002496static bool shouldUseFramePointerForTarget(const ArgList &Args,
2497 const llvm::Triple &Triple) {
Reid Kleckner86ea7702015-02-04 23:45:07 +00002498 // XCore never wants frame pointers, regardless of OS.
2499 if (Triple.getArch() == llvm::Triple::xcore) {
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002500 return false;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002501 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002502
2503 if (Triple.isOSLinux()) {
2504 switch (Triple.getArch()) {
2505 // Don't use a frame pointer on linux if optimizing for certain targets.
2506 case llvm::Triple::mips64:
2507 case llvm::Triple::mips64el:
2508 case llvm::Triple::mips:
2509 case llvm::Triple::mipsel:
2510 case llvm::Triple::systemz:
2511 case llvm::Triple::x86:
2512 case llvm::Triple::x86_64:
2513 return !areOptimizationsEnabled(Args);
2514 default:
2515 return true;
2516 }
2517 }
2518
2519 if (Triple.isOSWindows()) {
2520 switch (Triple.getArch()) {
2521 case llvm::Triple::x86:
2522 return !areOptimizationsEnabled(Args);
2523 default:
2524 // All other supported Windows ISAs use xdata unwind information, so frame
2525 // pointers are not generally useful.
2526 return false;
2527 }
2528 }
2529
2530 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002531}
2532
Rafael Espindola224dd632011-12-14 21:02:23 +00002533static bool shouldUseFramePointer(const ArgList &Args,
2534 const llvm::Triple &Triple) {
2535 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2536 options::OPT_fomit_frame_pointer))
2537 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2538
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002539 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002540}
2541
Eric Christopherb7d97e92013-04-03 01:58:53 +00002542static bool shouldUseLeafFramePointer(const ArgList &Args,
2543 const llvm::Triple &Triple) {
2544 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2545 options::OPT_momit_leaf_frame_pointer))
2546 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2547
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002548 if (Triple.isPS4CPU())
2549 return false;
2550
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002551 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002552}
2553
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002554/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002555static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002556 SmallString<128> cwd;
2557 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002558 CmdArgs.push_back("-fdebug-compilation-dir");
2559 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002560 }
2561}
2562
Eric Christopherd3804002013-02-22 20:12:52 +00002563static const char *SplitDebugName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00002564 const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00002565 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2566 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2567 SmallString<128> T(FinalOutput->getValue());
2568 llvm::sys::path::replace_extension(T, "dwo");
2569 return Args.MakeArgString(T);
2570 } else {
2571 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002572 SmallString<128> T(
2573 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00002574 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00002575 llvm::sys::path::replace_extension(F, "dwo");
2576 T += F;
2577 return Args.MakeArgString(F);
2578 }
2579}
2580
2581static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2582 const Tool &T, const JobAction &JA,
2583 const ArgList &Args, const InputInfo &Output,
2584 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002585 ArgStringList ExtractArgs;
2586 ExtractArgs.push_back("--extract-dwo");
2587
2588 ArgStringList StripArgs;
2589 StripArgs.push_back("--strip-dwo");
2590
2591 // Grabbing the output of the earlier compile step.
2592 StripArgs.push_back(Output.getFilename());
2593 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002594 ExtractArgs.push_back(OutFile);
2595
2596 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002597 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002598
2599 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002600 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002601
2602 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002603 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002604}
2605
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002606/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002607/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2608static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002609 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002610 if (A->getOption().matches(options::OPT_O4) ||
2611 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002612 return true;
2613
2614 if (A->getOption().matches(options::OPT_O0))
2615 return false;
2616
2617 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2618
Rafael Espindola91780de2013-08-26 14:05:41 +00002619 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002620 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002621 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002622 return true;
2623
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002624 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002625 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002626 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002627
2628 unsigned OptLevel = 0;
2629 if (S.getAsInteger(10, OptLevel))
2630 return false;
2631
2632 return OptLevel > 1;
2633 }
2634
2635 return false;
2636}
2637
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002638/// Add -x lang to \p CmdArgs for \p Input.
2639static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2640 ArgStringList &CmdArgs) {
2641 // When using -verify-pch, we don't want to provide the type
2642 // 'precompiled-header' if it was inferred from the file extension
2643 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2644 return;
2645
2646 CmdArgs.push_back("-x");
2647 if (Args.hasArg(options::OPT_rewrite_objc))
2648 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2649 else
2650 CmdArgs.push_back(types::getTypeName(Input.getType()));
2651}
2652
David Majnemerc371ff02015-03-22 08:39:22 +00002653static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002654 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002655 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002656
2657 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002658 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002659
2660 unsigned Build = 0, Factor = 1;
2661 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2662 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002663 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002664}
2665
Rafael Espindola577637a2015-01-03 00:06:04 +00002666// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002667// options that build systems might add but are unused when assembling or only
2668// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002669static void claimNoWarnArgs(const ArgList &Args) {
2670 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002671 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002672 Args.ClaimAllArgs(options::OPT_flto);
2673 Args.ClaimAllArgs(options::OPT_fno_lto);
2674}
2675
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002676static void appendUserToPath(SmallVectorImpl<char> &Result) {
2677#ifdef LLVM_ON_UNIX
2678 const char *Username = getenv("LOGNAME");
2679#else
2680 const char *Username = getenv("USERNAME");
2681#endif
2682 if (Username) {
2683 // Validate that LoginName can be used in a path, and get its length.
2684 size_t Len = 0;
2685 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002686 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002687 Username = nullptr;
2688 break;
2689 }
2690 }
2691
2692 if (Username && Len > 0) {
2693 Result.append(Username, Username + Len);
2694 return;
2695 }
2696 }
2697
2698 // Fallback to user id.
2699#ifdef LLVM_ON_UNIX
2700 std::string UID = llvm::utostr(getuid());
2701#else
2702 // FIXME: Windows seems to have an 'SID' that might work.
2703 std::string UID = "9999";
2704#endif
2705 Result.append(UID.begin(), UID.end());
2706}
2707
David Majnemere11d3732015-06-08 00:22:46 +00002708VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2709 const llvm::Triple &Triple,
2710 const llvm::opt::ArgList &Args,
2711 bool IsWindowsMSVC) {
2712 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2713 IsWindowsMSVC) ||
2714 Args.hasArg(options::OPT_fmsc_version) ||
2715 Args.hasArg(options::OPT_fms_compatibility_version)) {
2716 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2717 const Arg *MSCompatibilityVersion =
2718 Args.getLastArg(options::OPT_fms_compatibility_version);
2719
2720 if (MSCVersion && MSCompatibilityVersion) {
2721 if (D)
2722 D->Diag(diag::err_drv_argument_not_allowed_with)
2723 << MSCVersion->getAsString(Args)
2724 << MSCompatibilityVersion->getAsString(Args);
2725 return VersionTuple();
2726 }
2727
2728 if (MSCompatibilityVersion) {
2729 VersionTuple MSVT;
2730 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2731 D->Diag(diag::err_drv_invalid_value)
2732 << MSCompatibilityVersion->getAsString(Args)
2733 << MSCompatibilityVersion->getValue();
2734 return MSVT;
2735 }
2736
2737 if (MSCVersion) {
2738 unsigned Version = 0;
2739 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2740 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2741 << MSCVersion->getValue();
2742 return getMSCompatibilityVersion(Version);
2743 }
2744
2745 unsigned Major, Minor, Micro;
2746 Triple.getEnvironmentVersion(Major, Minor, Micro);
2747 if (Major || Minor || Micro)
2748 return VersionTuple(Major, Minor, Micro);
2749
2750 return VersionTuple(18);
2751 }
2752 return VersionTuple();
2753}
2754
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002755void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002756 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002757 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002758 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002759 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002760 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2761 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002762 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002763 ArgStringList CmdArgs;
2764
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002765 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002766 bool IsWindowsCygnus =
2767 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002768 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2769
Daniel Dunbare521a892009-03-31 20:53:55 +00002770 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
Artem Belevichba558952015-05-06 18:20:23 +00002771 const InputInfo &Input = Inputs[0];
Daniel Dunbare521a892009-03-31 20:53:55 +00002772
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002773 // Invoke ourselves in -cc1 mode.
2774 //
2775 // FIXME: Implement custom jobs for internal actions.
2776 CmdArgs.push_back("-cc1");
2777
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002778 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002779 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002780 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002781 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002782
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002783 const llvm::Triple TT(TripleStr);
2784 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2785 TT.getArch() == llvm::Triple::thumb)) {
2786 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2787 unsigned Version;
2788 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2789 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002790 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2791 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002792 }
2793
Tim Northover336f1892014-03-29 13:16:12 +00002794 // Push all default warning arguments that are specific to
2795 // the given target. These come before user provided warning options
2796 // are provided.
2797 getToolChain().addClangWarningOptions(CmdArgs);
2798
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002799 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002800 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002801
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002802 if (isa<AnalyzeJobAction>(JA)) {
2803 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2804 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002805 } else if (isa<MigrateJobAction>(JA)) {
2806 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002807 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002808 if (Output.getType() == types::TY_Dependencies)
2809 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002810 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002811 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002812 if (Args.hasArg(options::OPT_rewrite_objc) &&
2813 !Args.hasArg(options::OPT_g_Group))
2814 CmdArgs.push_back("-P");
2815 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002816 } else if (isa<AssembleJobAction>(JA)) {
2817 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002818
David Blaikie9260ed62013-07-25 21:19:01 +00002819 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002820
2821 // Also ignore explicit -force_cpusubtype_ALL option.
2822 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002823 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002824 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002825 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002826
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002827 if (JA.getType() == types::TY_Nothing)
2828 CmdArgs.push_back("-fsyntax-only");
2829 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002830 CmdArgs.push_back("-emit-pch");
2831 else
2832 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002833 } else if (isa<VerifyPCHJobAction>(JA)) {
2834 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002835 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002836 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2837 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002838
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002839 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002840 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002841 } else if (JA.getType() == types::TY_LLVM_IR ||
2842 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002843 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002844 } else if (JA.getType() == types::TY_LLVM_BC ||
2845 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002846 CmdArgs.push_back("-emit-llvm-bc");
2847 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002848 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002849 } else if (JA.getType() == types::TY_AST) {
2850 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002851 } else if (JA.getType() == types::TY_ModuleFile) {
2852 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002853 } else if (JA.getType() == types::TY_RewrittenObjC) {
2854 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002855 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002856 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2857 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002858 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002859 } else {
2860 assert(JA.getType() == types::TY_PP_Asm &&
2861 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002862 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00002863
2864 // Preserve use-list order by default when emitting bitcode, so that
2865 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
2866 // same result as running passes here. For LTO, we don't need to preserve
2867 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00002868 if (JA.getType() == types::TY_LLVM_BC)
2869 CmdArgs.push_back("-emit-llvm-uselists");
Daniel Dunbara3246a02009-03-18 08:07:30 +00002870 }
2871
Justin Bognera88f0122014-06-20 22:59:50 +00002872 // We normally speed up the clang process a bit by skipping destructors at
2873 // exit, but when we're generating diagnostics we can rely on some of the
2874 // cleanup.
2875 if (!C.isForDiagnostics())
2876 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002877
John McCallbb79b5f2010-02-13 03:50:24 +00002878 // Disable the verification pass in -asserts builds.
2879#ifdef NDEBUG
2880 CmdArgs.push_back("-disable-llvm-verifier");
2881#endif
2882
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002883 // Set the main file name, so that debug info works even with
2884 // -save-temps.
2885 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00002886 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002887
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002888 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002889 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002890 if (Args.hasArg(options::OPT_static))
2891 CmdArgs.push_back("-static-define");
2892
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002893 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002894 // Enable region store model by default.
2895 CmdArgs.push_back("-analyzer-store=region");
2896
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002897 // Treat blocks as analysis entry points.
2898 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2899
Ted Kremenek49c79792011-03-24 00:28:47 +00002900 CmdArgs.push_back("-analyzer-eagerly-assume");
2901
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002902 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002903 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002904 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002905
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002906 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002907 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002908
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002909 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002910 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002911
2912 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002913
Artem Belevichba558952015-05-06 18:20:23 +00002914 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00002915 CmdArgs.push_back("-analyzer-checker=cplusplus");
2916
Nico Webere8e53112014-05-11 01:04:02 +00002917 // Enable the following experimental checkers for testing.
2918 CmdArgs.push_back(
2919 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002920 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2921 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2922 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2923 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2924 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002925 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002926
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002927 // Set the output format. The default is plist, for (lame) historical
2928 // reasons.
2929 CmdArgs.push_back("-analyzer-output");
2930 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002931 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002932 else
2933 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002934
Ted Kremenekfe449a22010-03-22 22:32:05 +00002935 // Disable the presentation of standard compiler warnings when
2936 // using --analyze. We only want to show static analyzer diagnostics
2937 // or frontend errors.
2938 CmdArgs.push_back("-w");
2939
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002940 // Add -Xanalyzer arguments when running as analyzer.
2941 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002942 }
2943
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002944 CheckCodeGenerationOptions(D, Args);
2945
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002946 bool PIE = getToolChain().isPIEDefault();
2947 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002948 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002949
Alexey Bataev40e75222014-01-28 06:30:35 +00002950 // Android-specific defaults for PIC/PIE
2951 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002952 switch (getToolChain().getArch()) {
Alexey Bataev40e75222014-01-28 06:30:35 +00002953 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002954 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002955 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002956 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002957 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002958 case llvm::Triple::mips:
2959 case llvm::Triple::mipsel:
2960 case llvm::Triple::mips64:
2961 case llvm::Triple::mips64el:
2962 PIC = true; // "-fpic"
2963 break;
2964
2965 case llvm::Triple::x86:
2966 case llvm::Triple::x86_64:
2967 PIC = true; // "-fPIC"
2968 IsPICLevelTwo = true;
2969 break;
2970
2971 default:
2972 break;
2973 }
2974 }
2975
Brad Smith5b05db82014-06-24 19:51:29 +00002976 // OpenBSD-specific defaults for PIE
2977 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002978 switch (getToolChain().getArch()) {
Brad Smith5b05db82014-06-24 19:51:29 +00002979 case llvm::Triple::mips64:
2980 case llvm::Triple::mips64el:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00002981 case llvm::Triple::sparcel:
Brad Smith5b05db82014-06-24 19:51:29 +00002982 case llvm::Triple::x86:
2983 case llvm::Triple::x86_64:
2984 IsPICLevelTwo = false; // "-fpie"
2985 break;
2986
2987 case llvm::Triple::ppc:
Brad Smithb58159a2015-06-04 08:45:23 +00002988 case llvm::Triple::sparc:
Brad Smith5b05db82014-06-24 19:51:29 +00002989 case llvm::Triple::sparcv9:
2990 IsPICLevelTwo = true; // "-fPIE"
2991 break;
2992
2993 default:
2994 break;
2995 }
2996 }
2997
Alexey Samsonov090301e2013-04-09 12:28:19 +00002998 // For the PIC and PIE flag options, this logic is different from the
2999 // legacy logic in very old versions of GCC, as that logic was just
3000 // a bug no one had ever fixed. This logic is both more rational and
3001 // consistent with GCC's new logic now that the bugs are fixed. The last
3002 // argument relating to either PIC or PIE wins, and no other argument is
3003 // used. If the last argument is any flavor of the '-fno-...' arguments,
3004 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
3005 // at the same level.
3006 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3007 options::OPT_fpic, options::OPT_fno_pic,
3008 options::OPT_fPIE, options::OPT_fno_PIE,
3009 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00003010 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3011 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003012 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00003013 if (LastPICArg) {
3014 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003015 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3016 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3017 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3018 PIC = PIE || O.matches(options::OPT_fPIC) ||
3019 O.matches(options::OPT_fpic);
3020 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
3021 O.matches(options::OPT_fPIC);
3022 } else {
3023 PIE = PIC = false;
3024 }
3025 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003026 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00003027
Nick Lewycky609dd662013-10-11 03:33:53 +00003028 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00003029 // specified while enabling PIC enabled level 1 PIC, just force it back to
3030 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
3031 // informal testing).
3032 if (PIC && getToolChain().getTriple().isOSDarwin())
3033 IsPICLevelTwo |= getToolChain().isPICDefault();
3034
Chandler Carruthc0c04552012-04-08 16:40:35 +00003035 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
3036 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00003037 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00003038 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00003039 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00003040 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00003041 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00003042
Chandler Carruth76a943b2012-11-19 03:52:03 +00003043 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3044 // This is a very special mode. It trumps the other modes, almost no one
3045 // uses it, and it isn't even valid on any OS but Darwin.
3046 if (!getToolChain().getTriple().isOSDarwin())
3047 D.Diag(diag::err_drv_unsupported_opt_for_target)
3048 << A->getSpelling() << getToolChain().getTriple().str();
3049
3050 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3051
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003052 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003053 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00003054
Chandler Carruth76a943b2012-11-19 03:52:03 +00003055 // Only a forced PIC mode can cause the actual compile to have PIC defines
3056 // etc., no flags are sufficient. This behavior was selected to closely
3057 // match that of llvm-gcc and Apple GCC before that.
3058 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
3059 CmdArgs.push_back("-pic-level");
3060 CmdArgs.push_back("2");
3061 }
3062 } else {
3063 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
3064 // handled in Clang's IRGen by the -pie-level flag.
3065 CmdArgs.push_back("-mrelocation-model");
3066 CmdArgs.push_back(PIC ? "pic" : "static");
3067
3068 if (PIC) {
3069 CmdArgs.push_back("-pic-level");
3070 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3071 if (PIE) {
3072 CmdArgs.push_back("-pie-level");
3073 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3074 }
3075 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003076 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003077
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003078 CmdArgs.push_back("-mthread-model");
3079 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3080 CmdArgs.push_back(A->getValue());
3081 else
3082 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3083
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003084 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3085
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003086 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3087 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003088 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003089
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003090 // LLVM Code Generator Options.
3091
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003092 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3093 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003094 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3095 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003096 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003097 CmdArgs.push_back(A->getValue());
3098 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003099 }
3100 }
3101
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003102 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3103 StringRef v = A->getValue();
3104 CmdArgs.push_back("-mllvm");
3105 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3106 A->claim();
3107 }
3108
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003109 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3110 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003111 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003112 }
3113
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003114 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3115 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003116 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00003117 D.Diag(diag::err_drv_unsupported_opt_for_target)
3118 << A->getSpelling() << getToolChain().getTriple().str();
3119 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3120 CmdArgs.push_back("-fpcc-struct-return");
3121 } else {
3122 assert(A->getOption().matches(options::OPT_freg_struct_return));
3123 CmdArgs.push_back("-freg-struct-return");
3124 }
3125 }
3126
Roman Divacky65b88cd2011-03-01 17:40:53 +00003127 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
3128 CmdArgs.push_back("-mrtd");
3129
Rafael Espindola224dd632011-12-14 21:02:23 +00003130 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003131 CmdArgs.push_back("-mdisable-fp-elim");
3132 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3133 options::OPT_fno_zero_initialized_in_bss))
3134 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003135
3136 bool OFastEnabled = isOptimizationLevelFast(Args);
3137 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3138 // enabled. This alias option is being used to simplify the hasFlag logic.
3139 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
3140 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003141 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3142 // doesn't do any TBAA.
3143 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003144 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003145 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003146 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003147 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3148 options::OPT_fno_struct_path_tbaa))
3149 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003150 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3151 false))
3152 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00003153 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3154 options::OPT_fno_optimize_sibling_calls))
3155 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003156
Eric Christopher006208c2013-04-04 06:29:47 +00003157 // Handle segmented stacks.
3158 if (Args.hasArg(options::OPT_fsplit_stack))
3159 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003160
3161 // If -Ofast is the optimization level, then -ffast-math should be enabled.
3162 // This alias option is being used to simplify the getLastArg logic.
3163 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
3164 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00003165
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003166 // Handle various floating point optimization flags, mapping them to the
3167 // appropriate LLVM code generation flags. The pattern for all of these is to
3168 // default off the codegen optimizations, and if any flag enables them and no
3169 // flag disables them after the flag enabling them, enable the codegen
3170 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003171 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003172 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003173 options::OPT_ffinite_math_only,
3174 options::OPT_fno_finite_math_only,
3175 options::OPT_fhonor_infinities,
3176 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003177 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3178 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003179 A->getOption().getID() != options::OPT_fhonor_infinities)
3180 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003181 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003182 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003183 options::OPT_ffinite_math_only,
3184 options::OPT_fno_finite_math_only,
3185 options::OPT_fhonor_nans,
3186 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003187 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3188 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003189 A->getOption().getID() != options::OPT_fhonor_nans)
3190 CmdArgs.push_back("-menable-no-nans");
3191
Benjamin Kramerc242ef22012-05-02 14:55:48 +00003192 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3193 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003194 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003195 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003196 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00003197 options::OPT_fno_math_errno)) {
3198 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3199 // However, turning *off* -ffast_math merely restores the toolchain default
3200 // (which may be false).
3201 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3202 A->getOption().getID() == options::OPT_ffast_math ||
3203 A->getOption().getID() == options::OPT_Ofast)
3204 MathErrno = false;
3205 else if (A->getOption().getID() == options::OPT_fmath_errno)
3206 MathErrno = true;
3207 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003208 if (MathErrno)
3209 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003210
3211 // There are several flags which require disabling very specific
3212 // optimizations. Any of these being disabled forces us to turn off the
3213 // entire set of LLVM optimizations, so collect them through all the flag
3214 // madness.
3215 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003216 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003217 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003218 options::OPT_funsafe_math_optimizations,
3219 options::OPT_fno_unsafe_math_optimizations,
3220 options::OPT_fassociative_math,
3221 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003222 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3223 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003224 A->getOption().getID() != options::OPT_fno_associative_math)
3225 AssociativeMath = true;
3226 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003227 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003228 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003229 options::OPT_funsafe_math_optimizations,
3230 options::OPT_fno_unsafe_math_optimizations,
3231 options::OPT_freciprocal_math,
3232 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003233 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3234 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003235 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3236 ReciprocalMath = true;
3237 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003238 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003239 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003240 options::OPT_funsafe_math_optimizations,
3241 options::OPT_fno_unsafe_math_optimizations,
3242 options::OPT_fsigned_zeros,
3243 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003244 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3245 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003246 A->getOption().getID() != options::OPT_fsigned_zeros)
3247 SignedZeros = false;
3248 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003249 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003250 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003251 options::OPT_funsafe_math_optimizations,
3252 options::OPT_fno_unsafe_math_optimizations,
3253 options::OPT_ftrapping_math,
3254 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003255 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3256 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003257 A->getOption().getID() != options::OPT_ftrapping_math)
3258 TrappingMath = false;
3259 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3260 !TrappingMath)
3261 CmdArgs.push_back("-menable-unsafe-fp-math");
3262
Sanjay Patel76c9e092015-01-23 16:40:50 +00003263 if (!SignedZeros)
3264 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003265
Sanjay Patel359b1052015-04-09 15:03:23 +00003266 if (ReciprocalMath)
3267 CmdArgs.push_back("-freciprocal-math");
3268
Lang Hamesaa53b932012-07-06 00:59:19 +00003269 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003270 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003271 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003272 options::OPT_ffp_contract)) {
3273 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003274 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003275 if (Val == "fast" || Val == "on" || Val == "off") {
3276 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3277 } else {
3278 D.Diag(diag::err_drv_unsupported_option_argument)
3279 << A->getOption().getName() << Val;
3280 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003281 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3282 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003283 // If fast-math is set then set the fp-contract mode to fast.
3284 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3285 }
3286 }
Sanjay Patel2987c292015-06-11 14:53:41 +00003287
3288 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00003289
Bob Wilson6a039162012-07-19 03:52:53 +00003290 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3291 // and if we find them, tell the frontend to provide the appropriate
3292 // preprocessor macros. This is distinct from enabling any optimizations as
3293 // these options induce language changes which must survive serialization
3294 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003295 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3296 options::OPT_fno_fast_math))
3297 if (!A->getOption().matches(options::OPT_fno_fast_math))
3298 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003299 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3300 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003301 if (A->getOption().matches(options::OPT_ffinite_math_only))
3302 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003303
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003304 // Decide whether to use verbose asm. Verbose assembly is the default on
3305 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003306 bool IsIntegratedAssemblerDefault =
3307 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003308 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003309 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003310 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003311 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003312
Rafael Espindolab8a12932015-05-22 20:44:03 +00003313 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3314 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003315 CmdArgs.push_back("-no-integrated-as");
3316
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003317 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3318 CmdArgs.push_back("-mdebug-pass");
3319 CmdArgs.push_back("Structure");
3320 }
3321 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3322 CmdArgs.push_back("-mdebug-pass");
3323 CmdArgs.push_back("Arguments");
3324 }
3325
John McCall8517abc2010-02-19 02:45:38 +00003326 // Enable -mconstructor-aliases except on darwin, where we have to
3327 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003328 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003329 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003330
John McCall7ef5cb32011-03-18 02:56:14 +00003331 // Darwin's kernel doesn't support guard variables; just die if we
3332 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003333 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003334 CmdArgs.push_back("-fforbid-guard-variables");
3335
Douglas Gregordbe39272011-02-01 15:15:22 +00003336 if (Args.hasArg(options::OPT_mms_bitfields)) {
3337 CmdArgs.push_back("-mms-bitfields");
3338 }
John McCall8517abc2010-02-19 02:45:38 +00003339
Daniel Dunbar306945d2009-09-16 06:17:29 +00003340 // This is a coarse approximation of what llvm-gcc actually does, both
3341 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3342 // complicated ways.
3343 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003344 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3345 options::OPT_fno_asynchronous_unwind_tables,
3346 (getToolChain().IsUnwindTablesDefault() ||
3347 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3348 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003349 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3350 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003351 CmdArgs.push_back("-munwind-tables");
3352
Chandler Carruth05fb5852012-11-21 23:40:23 +00003353 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003354
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003355 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3356 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003357 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003358 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003359
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003360 // FIXME: Handle -mtune=.
3361 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003362
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003363 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003364 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003365 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003366 }
3367
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003368 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00003369 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003370 if (!CPU.empty()) {
3371 CmdArgs.push_back("-target-cpu");
3372 CmdArgs.push_back(Args.MakeArgString(CPU));
3373 }
3374
Rafael Espindolaeb265472013-08-21 21:59:03 +00003375 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3376 CmdArgs.push_back("-mfpmath");
3377 CmdArgs.push_back(A->getValue());
3378 }
3379
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003380 // Add the target features
John Brawn94fd9632015-05-21 12:19:49 +00003381 getTargetFeatures(D, Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003382
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003383 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003384 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003385 default:
3386 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003387
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003388 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003389 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003390 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003391 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003392 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003393 break;
3394
Tim Northover573cbee2014-05-24 12:52:07 +00003395 case llvm::Triple::aarch64:
3396 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003397 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003398 break;
3399
Eric Christopher0b26a612010-03-02 02:41:08 +00003400 case llvm::Triple::mips:
3401 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003402 case llvm::Triple::mips64:
3403 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003404 AddMIPSTargetArgs(Args, CmdArgs);
3405 break;
3406
Ulrich Weigand8afad612014-07-28 13:17:52 +00003407 case llvm::Triple::ppc:
3408 case llvm::Triple::ppc64:
3409 case llvm::Triple::ppc64le:
3410 AddPPCTargetArgs(Args, CmdArgs);
3411 break;
3412
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003413 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00003414 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00003415 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003416 AddSparcTargetArgs(Args, CmdArgs);
3417 break;
3418
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003419 case llvm::Triple::x86:
3420 case llvm::Triple::x86_64:
3421 AddX86TargetArgs(Args, CmdArgs);
3422 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003423
3424 case llvm::Triple::hexagon:
3425 AddHexagonTargetArgs(Args, CmdArgs);
3426 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003427 }
3428
Hans Wennborg75958c42013-08-08 00:17:41 +00003429 // Add clang-cl arguments.
3430 if (getToolChain().getDriver().IsCLMode())
3431 AddClangCLArgs(Args, CmdArgs);
3432
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003433 // Pass the linker version in use.
3434 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3435 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003436 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003437 }
3438
Eric Christopherb7d97e92013-04-03 01:58:53 +00003439 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003440 CmdArgs.push_back("-momit-leaf-frame-pointer");
3441
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003442 // Explicitly error on some things we know we don't support and can't just
3443 // ignore.
Artem Belevichba558952015-05-06 18:20:23 +00003444 types::ID InputType = Input.getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003445 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3446 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003447 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003448 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003449 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003450 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3451 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003452 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003453 << Unsupported->getOption().getName();
3454 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003455 }
3456
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003457 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003458 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003459 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003460 CmdArgs.push_back("-header-include-file");
3461 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3462 D.CCPrintHeadersFilename : "-");
3463 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003464 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003465 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003466
Chad Rosierbe10f982011-08-02 17:58:04 +00003467 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003468 CmdArgs.push_back("-diagnostic-log-file");
3469 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3470 D.CCLogDiagnosticsFilename : "-");
3471 }
3472
Manman Ren17bdb0f2013-11-20 20:22:14 +00003473 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3474 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003475 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003476 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003477 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3478 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003479 // FIXME: we should support specifying dwarf version with
3480 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003481 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003482 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003483 const llvm::Triple &Triple = getToolChain().getTriple();
3484 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003485 Triple.getOS() == llvm::Triple::FreeBSD ||
3486 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003487 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003488 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003489 CmdArgs.push_back("-gdwarf-2");
3490 else if (A->getOption().matches(options::OPT_gdwarf_3))
3491 CmdArgs.push_back("-gdwarf-3");
3492 else if (A->getOption().matches(options::OPT_gdwarf_4))
3493 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003494 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003495 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003496 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003497 const llvm::Triple &Triple = getToolChain().getTriple();
3498 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003499 Triple.getOS() == llvm::Triple::FreeBSD ||
3500 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003501 CmdArgs.push_back("-gdwarf-2");
3502 else
3503 CmdArgs.push_back("-g");
3504 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003505 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003506
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003507 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3508 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003509 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3510 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003511 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003512
Eric Christopher138c32b2013-09-13 22:37:55 +00003513 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003514 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3515 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003516 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003517 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003518 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003519 CmdArgs.push_back("-g");
3520 CmdArgs.push_back("-backend-option");
3521 CmdArgs.push_back("-split-dwarf=Enable");
3522 }
3523
Eric Christopher138c32b2013-09-13 22:37:55 +00003524 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3525 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3526 CmdArgs.push_back("-backend-option");
3527 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3528 }
Eric Christophereec89c22013-06-18 00:03:50 +00003529
Eric Christopher0d403d22014-02-14 01:27:03 +00003530 // -gdwarf-aranges turns on the emission of the aranges section in the
3531 // backend.
3532 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3533 CmdArgs.push_back("-backend-option");
3534 CmdArgs.push_back("-generate-arange-section");
3535 }
3536
David Blaikief36d9ba2014-01-27 18:52:43 +00003537 if (Args.hasFlag(options::OPT_fdebug_types_section,
3538 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003539 CmdArgs.push_back("-backend-option");
3540 CmdArgs.push_back("-generate-type-units");
3541 }
Eric Christophereec89c22013-06-18 00:03:50 +00003542
Ed Schouten6e576152015-03-26 17:50:28 +00003543 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3544 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3545
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003546 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003547 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003548 CmdArgs.push_back("-ffunction-sections");
3549 }
3550
3551 if (Args.hasFlag(options::OPT_fdata_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003552 options::OPT_fno_data_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003553 CmdArgs.push_back("-fdata-sections");
3554 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003555
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003556 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00003557 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003558 CmdArgs.push_back("-fno-unique-section-names");
3559
Chris Lattner3c77a352010-06-22 00:03:40 +00003560 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3561
Justin Bognera71e6812015-04-30 23:49:42 +00003562 if ((Args.hasArg(options::OPT_fprofile_instr_generate) ||
3563 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)) &&
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003564 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3565 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3566 D.Diag(diag::err_drv_argument_not_allowed_with)
3567 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3568
Justin Bognera71e6812015-04-30 23:49:42 +00003569 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_generate_EQ))
3570 A->render(Args, CmdArgs);
3571 else
3572 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003573
3574 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3575 A->render(Args, CmdArgs);
3576 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3577 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3578
Nick Lewycky207bce32011-04-21 23:44:07 +00003579 if (Args.hasArg(options::OPT_ftest_coverage) ||
3580 Args.hasArg(options::OPT_coverage))
3581 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003582 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3583 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003584 Args.hasArg(options::OPT_coverage))
3585 CmdArgs.push_back("-femit-coverage-data");
3586
Alex Lorenzee024992014-08-04 18:41:51 +00003587 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
Justin Bognera71e6812015-04-30 23:49:42 +00003588 !(Args.hasArg(options::OPT_fprofile_instr_generate) ||
3589 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)))
Alex Lorenzee024992014-08-04 18:41:51 +00003590 D.Diag(diag::err_drv_argument_only_allowed_with)
3591 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3592
3593 if (Args.hasArg(options::OPT_fcoverage_mapping))
3594 CmdArgs.push_back("-fcoverage-mapping");
3595
Nick Lewycky480cb992011-05-04 20:46:58 +00003596 if (C.getArgs().hasArg(options::OPT_c) ||
3597 C.getArgs().hasArg(options::OPT_S)) {
3598 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003599 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003600 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003601 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003602 CoverageFilename = FinalOutput->getValue();
3603 } else {
3604 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3605 }
Yaron Keren92e1b622015-03-18 10:17:07 +00003606 if (llvm::sys::path::is_relative(CoverageFilename)) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003607 SmallString<128> Pwd;
3608 if (!llvm::sys::fs::current_path(Pwd)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00003609 llvm::sys::path::append(Pwd, CoverageFilename);
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003610 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003611 }
3612 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003613 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003614 }
3615 }
3616
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003617 // Pass options for controlling the default header search paths.
3618 if (Args.hasArg(options::OPT_nostdinc)) {
3619 CmdArgs.push_back("-nostdsysteminc");
3620 CmdArgs.push_back("-nobuiltininc");
3621 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003622 if (Args.hasArg(options::OPT_nostdlibinc))
3623 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003624 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3625 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3626 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003627
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003628 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003629 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003630 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003631
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003632 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3633
Ted Kremenekf7639e12012-03-06 20:06:33 +00003634 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003635 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003636 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003637 options::OPT_ccc_arcmt_modify,
3638 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003639 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003640 switch (A->getOption().getID()) {
3641 default:
3642 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003643 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003644 CmdArgs.push_back("-arcmt-check");
3645 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003646 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003647 CmdArgs.push_back("-arcmt-modify");
3648 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003649 case options::OPT_ccc_arcmt_migrate:
3650 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003651 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003652 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003653
3654 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3655 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003656 break;
John McCalld70fb982011-06-15 23:25:17 +00003657 }
3658 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003659 } else {
3660 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3661 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3662 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003663 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003664
Ted Kremenekf7639e12012-03-06 20:06:33 +00003665 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3666 if (ARCMTEnabled) {
3667 D.Diag(diag::err_drv_argument_not_allowed_with)
3668 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3669 }
3670 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003671 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003672
3673 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003674 options::OPT_objcmt_migrate_subscripting,
3675 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003676 // None specified, means enable them all.
3677 CmdArgs.push_back("-objcmt-migrate-literals");
3678 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003679 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003680 } else {
3681 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3682 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003683 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003684 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003685 } else {
3686 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3687 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3688 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3689 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3690 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3691 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00003692 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003693 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3694 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3695 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3696 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3697 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3698 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3699 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003700 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003701 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003702 }
3703
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003704 // Add preprocessing options like -I, -D, etc. if we are using the
3705 // preprocessor.
3706 //
3707 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003708 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003709 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003710
Rafael Espindolaa7431922011-07-21 23:40:37 +00003711 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3712 // that "The compiler can only warn and ignore the option if not recognized".
3713 // When building with ccache, it will pass -D options to clang even on
3714 // preprocessed inputs and configure concludes that -fPIC is not supported.
3715 Args.ClaimAllArgs(options::OPT_D);
3716
Alp Toker7874bdc2013-11-15 20:40:58 +00003717 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003718 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3719 if (A->getOption().matches(options::OPT_O4)) {
3720 CmdArgs.push_back("-O3");
3721 D.Diag(diag::warn_O4_is_O3);
3722 } else {
3723 A->render(Args, CmdArgs);
3724 }
3725 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003726
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003727 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00003728 for (const Arg *A :
3729 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3730 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003731 }
3732
Rafael Espindola577637a2015-01-03 00:06:04 +00003733 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003734
Richard Smith3be1cb22014-08-07 00:24:21 +00003735 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003736 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003737 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3738 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003739 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003740 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003741
3742 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003743 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003744 //
3745 // If a std is supplied, only add -trigraphs if it follows the
3746 // option.
David Majnemer8db91762015-05-18 04:49:30 +00003747 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003748 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3749 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003750 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003751 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003752 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003753 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003754 else
3755 Std->render(Args, CmdArgs);
3756
Nico Weber00721502014-12-23 22:32:37 +00003757 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003758 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003759 options::OPT_ftrigraphs,
3760 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003761 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003762 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003763 } else {
3764 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003765 //
3766 // FIXME: Clang doesn't correctly handle -std= when the input language
3767 // doesn't match. For the time being just ignore this for C++ inputs;
3768 // eventually we want to do all the standard defaulting here instead of
3769 // splitting it between the driver and clang -cc1.
3770 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003771 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3772 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003773 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00003774 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00003775
Nico Weber00721502014-12-23 22:32:37 +00003776 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3777 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003778 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003779
Richard Smith282b4492013-09-04 22:50:31 +00003780 // GCC's behavior for -Wwrite-strings is a bit strange:
3781 // * In C, this "warning flag" changes the types of string literals from
3782 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3783 // for the discarded qualifier.
3784 // * In C++, this is just a normal warning flag.
3785 //
3786 // Implementing this warning correctly in C is hard, so we follow GCC's
3787 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3788 // a non-const char* in C, rather than using this crude hack.
3789 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003790 // FIXME: This should behave just like a warning flag, and thus should also
3791 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3792 Arg *WriteStrings =
3793 Args.getLastArg(options::OPT_Wwrite_strings,
3794 options::OPT_Wno_write_strings, options::OPT_w);
3795 if (WriteStrings &&
3796 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003797 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003798 }
3799
Chandler Carruth61fbf622011-04-23 09:27:53 +00003800 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003801 // during C++ compilation, which it is by default. GCC keeps this define even
3802 // in the presence of '-w', match this behavior bug-for-bug.
3803 if (types::isCXX(InputType) &&
3804 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3805 true)) {
3806 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003807 }
3808
Chandler Carruthe0391482010-05-22 02:21:53 +00003809 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3810 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3811 if (Asm->getOption().matches(options::OPT_fasm))
3812 CmdArgs.push_back("-fgnu-keywords");
3813 else
3814 CmdArgs.push_back("-fno-gnu-keywords");
3815 }
3816
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003817 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3818 CmdArgs.push_back("-fno-dwarf-directory-asm");
3819
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003820 if (ShouldDisableAutolink(Args, getToolChain()))
3821 CmdArgs.push_back("-fno-autolink");
3822
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003823 // Add in -fdebug-compilation-dir if necessary.
3824 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003825
Richard Smith9a568822011-11-21 19:36:32 +00003826 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3827 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003828 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003829 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003830 }
3831
Richard Smith79c927b2013-11-06 19:31:51 +00003832 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3833 CmdArgs.push_back("-foperator-arrow-depth");
3834 CmdArgs.push_back(A->getValue());
3835 }
3836
Richard Smith9a568822011-11-21 19:36:32 +00003837 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3838 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003839 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003840 }
3841
Richard Smitha3d3bd22013-05-08 02:12:03 +00003842 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3843 CmdArgs.push_back("-fconstexpr-steps");
3844 CmdArgs.push_back(A->getValue());
3845 }
3846
Richard Smithb3a14522013-02-22 01:59:51 +00003847 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3848 CmdArgs.push_back("-fbracket-depth");
3849 CmdArgs.push_back(A->getValue());
3850 }
3851
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003852 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3853 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003854 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003855 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003856 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3857 } else
3858 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003859 }
3860
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003861
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003862 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003863 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003864
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003865 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3866 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003867 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003868 }
David Chisnall5778fce2009-08-31 16:41:57 +00003869
Chris Lattnere23003d2010-01-09 21:54:33 +00003870 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3871 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003872 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003873 }
3874
Chris Lattnerb35583d2010-04-07 20:49:23 +00003875 CmdArgs.push_back("-ferror-limit");
3876 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003877 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003878 else
3879 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003880
Chandler Carrutha77a7272010-05-06 04:55:18 +00003881 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3882 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003883 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003884 }
3885
3886 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3887 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003888 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003889 }
3890
Richard Smithf6f003a2011-12-16 19:06:07 +00003891 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3892 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003893 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003894 }
3895
Nick Lewycky24653262014-12-16 21:39:02 +00003896 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3897 CmdArgs.push_back("-fspell-checking-limit");
3898 CmdArgs.push_back(A->getValue());
3899 }
3900
Daniel Dunbar2c978472009-11-04 06:24:47 +00003901 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003902 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003903 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003904 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003905 } else {
3906 // If -fmessage-length=N was not specified, determine whether this is a
3907 // terminal and, if so, implicitly define -fmessage-length appropriately.
3908 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003909 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003910 }
3911
John McCallb4a99d32013-02-19 01:57:35 +00003912 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3913 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3914 options::OPT_fvisibility_ms_compat)) {
3915 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3916 CmdArgs.push_back("-fvisibility");
3917 CmdArgs.push_back(A->getValue());
3918 } else {
3919 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3920 CmdArgs.push_back("-fvisibility");
3921 CmdArgs.push_back("hidden");
3922 CmdArgs.push_back("-ftype-visibility");
3923 CmdArgs.push_back("default");
3924 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003925 }
3926
Douglas Gregor08329632010-06-15 17:05:35 +00003927 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003928
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003929 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3930
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003931 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003932 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3933 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003934 CmdArgs.push_back("-ffreestanding");
3935
Daniel Dunbare357d562009-12-03 18:42:11 +00003936 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003937 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003938 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003939 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3940 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003941 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003942 // AltiVec language extensions aren't relevant for assembling.
3943 if (!isa<PreprocessJobAction>(JA) ||
3944 Output.getType() != types::TY_PP_Asm)
3945 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003946 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3947 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003948
Alexey Bataevdb390212015-05-20 04:24:19 +00003949 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00003950 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3951 options::OPT_fno_openmp, false))
3952 switch (getOpenMPRuntime(getToolChain(), Args)) {
3953 case OMPRT_OMP:
3954 case OMPRT_IOMP5:
3955 // Clang can generate useful OpenMP code for these two runtime libraries.
3956 CmdArgs.push_back("-fopenmp");
3957 break;
3958 default:
3959 // By default, if Clang doesn't know how to generate useful OpenMP code
3960 // for a specific runtime library, we just don't pass the '-fopenmp' flag
3961 // down to the actual compilation.
3962 // FIXME: It would be better to have a mode which *only* omits IR
3963 // generation based on the OpenMP support so that we get consistent
3964 // semantic analysis, etc.
3965 break;
3966 }
Alexey Bataevdb390212015-05-20 04:24:19 +00003967
Peter Collingbourne32701642013-11-01 18:16:25 +00003968 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3969 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003970
Eric Christopher459d2712013-02-19 06:16:53 +00003971 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00003972 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
3973 const llvm::Triple::ArchType Arch = getToolChain().getArch();
3974 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
3975 Arch == llvm::Triple::ppc64le))
3976 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3977 << "ppc/ppc64/ppc64le";
3978 }
Chad Rosier864dfe12012-03-13 23:45:51 +00003979
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003980 if (getToolChain().SupportsProfiling())
3981 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003982
3983 // -flax-vector-conversions is default.
3984 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3985 options::OPT_fno_lax_vector_conversions))
3986 CmdArgs.push_back("-fno-lax-vector-conversions");
3987
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003988 if (Args.getLastArg(options::OPT_fapple_kext))
3989 CmdArgs.push_back("-fapple-kext");
3990
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003991 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003992 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003993 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003994 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3995 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003996
3997 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3998 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003999 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00004000 }
4001
Bob Wilson14adb362012-02-03 06:27:22 +00004002 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00004003
Chandler Carruth6e501032011-03-27 00:04:55 +00004004 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4005 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
4006 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
4007 options::OPT_fno_wrapv)) {
4008 if (A->getOption().matches(options::OPT_fwrapv))
4009 CmdArgs.push_back("-fwrapv");
4010 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4011 options::OPT_fno_strict_overflow)) {
4012 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4013 CmdArgs.push_back("-fwrapv");
4014 }
Hal Finkelce0697f2013-11-17 16:03:29 +00004015
4016 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4017 options::OPT_fno_reroll_loops))
4018 if (A->getOption().matches(options::OPT_freroll_loops))
4019 CmdArgs.push_back("-freroll-loops");
4020
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004021 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00004022 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4023 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004024
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004025 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4026
Mahesha S6a682be42012-10-27 07:47:56 +00004027
Daniel Dunbar4930e332009-11-17 08:07:36 +00004028 // -stack-protector=0 is default.
4029 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004030 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4031 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00004032 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004033 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004034 if (A->getOption().matches(options::OPT_fstack_protector)) {
4035 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
4036 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
4037 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004038 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004039 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004040 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004041 } else {
4042 StackProtectorLevel =
4043 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
4044 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004045 if (StackProtectorLevel) {
4046 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004047 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004048 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004049
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004050 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004051 for (const Arg *A : Args.filtered(options::OPT__param)) {
4052 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004053 if (Str.startswith("ssp-buffer-size=")) {
4054 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004055 CmdArgs.push_back("-stack-protector-buffer-size");
4056 // FIXME: Verify the argument is a valid integer.
4057 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004058 }
Sean Silva14facf32015-06-09 01:57:17 +00004059 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004060 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004061 }
4062
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004063 // Translate -mstackrealign
4064 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4065 false)) {
4066 CmdArgs.push_back("-backend-option");
4067 CmdArgs.push_back("-force-align-stack");
4068 }
4069 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
4070 false)) {
4071 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
4072 }
4073
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004074 if (Args.hasArg(options::OPT_mstack_alignment)) {
4075 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4076 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00004077 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004078
Hans Wennborg77dc2362015-01-20 19:45:50 +00004079 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4080 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4081
4082 if (!Size.empty())
4083 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4084 else
4085 CmdArgs.push_back("-mstack-probe-size=0");
4086 }
4087
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004088 if (getToolChain().getArch() == llvm::Triple::aarch64 ||
4089 getToolChain().getArch() == llvm::Triple::aarch64_be)
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004090 CmdArgs.push_back("-fallow-half-arguments-and-returns");
4091
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004092 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4093 options::OPT_mno_restrict_it)) {
4094 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4095 CmdArgs.push_back("-backend-option");
4096 CmdArgs.push_back("-arm-restrict-it");
4097 } else {
4098 CmdArgs.push_back("-backend-option");
4099 CmdArgs.push_back("-arm-no-restrict-it");
4100 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00004101 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
4102 TT.getArch() == llvm::Triple::thumb)) {
4103 // Windows on ARM expects restricted IT blocks
4104 CmdArgs.push_back("-backend-option");
4105 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004106 }
4107
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00004108 if (TT.getArch() == llvm::Triple::arm ||
4109 TT.getArch() == llvm::Triple::thumb) {
4110 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
4111 options::OPT_mno_long_calls)) {
4112 if (A->getOption().matches(options::OPT_mlong_calls)) {
4113 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00004114 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00004115 }
4116 }
4117 }
4118
Daniel Dunbard18049a2009-04-07 21:16:11 +00004119 // Forward -f options with positive and negative forms; we translate
4120 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00004121 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4122 StringRef fname = A->getValue();
4123 if (!llvm::sys::fs::exists(fname))
4124 D.Diag(diag::err_drv_no_such_file) << fname;
4125 else
4126 A->render(Args, CmdArgs);
4127 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004128
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004129 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00004130 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004131 CmdArgs.push_back("-fapple-kext");
4132 if (!Args.hasArg(options::OPT_fbuiltin))
4133 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00004134 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004135 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004136 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004137 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00004138 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00004139
Nuno Lopes13c88c72009-12-16 16:59:22 +00004140 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4141 options::OPT_fno_assume_sane_operator_new))
4142 CmdArgs.push_back("-fno-assume-sane-operator-new");
4143
Daniel Dunbar4930e332009-11-17 08:07:36 +00004144 // -fblocks=0 is default.
4145 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00004146 getToolChain().IsBlocksDefault()) ||
4147 (Args.hasArg(options::OPT_fgnu_runtime) &&
4148 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4149 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00004150 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00004151
4152 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4153 !getToolChain().hasBlocksRuntime())
4154 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00004155 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004156
Richard Smithffb65082014-09-30 23:10:19 +00004157 // -fmodules enables modules (off by default).
4158 // Users can pass -fno-cxx-modules to turn off modules support for
4159 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00004160 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00004161 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
4162 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4163 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00004164 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00004165 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00004166 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00004167 HaveModules = true;
4168 }
4169 }
4170
Daniel Jasper07e6c402013-08-05 20:26:17 +00004171 // -fmodule-maps enables module map processing (off by default) for header
4172 // checking. It is implied by -fmodules.
4173 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
4174 false)) {
4175 CmdArgs.push_back("-fmodule-maps");
4176 }
4177
Daniel Jasperac42b752013-10-21 06:34:34 +00004178 // -fmodules-decluse checks that modules used are declared so (off by
4179 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004180 if (Args.hasFlag(options::OPT_fmodules_decluse,
4181 options::OPT_fno_modules_decluse,
4182 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00004183 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004184 }
4185
Daniel Jasper962b38e2014-04-11 11:47:45 +00004186 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4187 // all #included headers are part of modules.
4188 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4189 options::OPT_fno_modules_strict_decluse,
4190 false)) {
4191 CmdArgs.push_back("-fmodules-strict-decluse");
4192 }
4193
Manuel Klimekd2e8b042015-02-20 11:44:41 +00004194 // -fno-implicit-modules turns off implicitly compiling modules on demand.
4195 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4196 options::OPT_fno_implicit_modules)) {
4197 CmdArgs.push_back("-fno-implicit-modules");
4198 }
4199
Daniel Jasperac42b752013-10-21 06:34:34 +00004200 // -fmodule-name specifies the module that is currently being built (or
4201 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00004202 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00004203
Richard Smith9887d792014-10-17 01:42:53 +00004204 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00004205 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00004206 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00004207
Richard Smithe842a472014-10-22 02:05:46 +00004208 // -fmodule-file can be used to specify files containing precompiled modules.
4209 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4210
4211 // -fmodule-cache-path specifies where our implicitly-built module files
4212 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00004213 SmallString<128> ModuleCachePath;
4214 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4215 ModuleCachePath = A->getValue();
4216 if (HaveModules) {
4217 if (C.isForDiagnostics()) {
4218 // When generating crash reports, we want to emit the modules along with
4219 // the reproduction sources, so we ignore any provided module path.
4220 ModuleCachePath = Output.getFilename();
4221 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
4222 llvm::sys::path::append(ModuleCachePath, "modules");
4223 } else if (ModuleCachePath.empty()) {
4224 // No module path was provided: use the default.
4225 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
4226 ModuleCachePath);
Ben Langmuir3b7b5402015-02-03 19:28:37 +00004227 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang.");
4228 appendUserToPath(ModuleCachePath);
Justin Bognera88f0122014-06-20 22:59:50 +00004229 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
4230 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004231 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00004232 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
4233 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
4234 }
4235
4236 // When building modules and generating crashdumps, we need to dump a module
4237 // dependency VFS alongside the output.
4238 if (HaveModules && C.isForDiagnostics()) {
4239 SmallString<128> VFSDir(Output.getFilename());
4240 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004241 // Add the cache directory as a temp so the crash diagnostics pick it up.
4242 C.addTempFile(Args.MakeArgString(VFSDir));
4243
Justin Bognera88f0122014-06-20 22:59:50 +00004244 llvm::sys::path::append(VFSDir, "vfs");
4245 CmdArgs.push_back("-module-dependency-dir");
4246 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004247 }
4248
Richard Smith9887d792014-10-17 01:42:53 +00004249 if (HaveModules)
4250 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004251
Douglas Gregor35b04d62013-02-07 19:01:24 +00004252 // Pass through all -fmodules-ignore-macro arguments.
4253 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004254 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4255 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004256
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004257 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4258
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004259 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4260 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4261 D.Diag(diag::err_drv_argument_not_allowed_with)
4262 << A->getAsString(Args) << "-fbuild-session-timestamp";
4263
4264 llvm::sys::fs::file_status Status;
4265 if (llvm::sys::fs::status(A->getValue(), Status))
4266 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004267 CmdArgs.push_back(Args.MakeArgString(
4268 "-fbuild-session-timestamp=" +
4269 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004270 }
4271
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004272 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004273 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4274 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004275 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4276
4277 Args.AddLastArg(CmdArgs,
4278 options::OPT_fmodules_validate_once_per_build_session);
4279 }
4280
Ben Langmuirdcf73862014-03-12 00:06:17 +00004281 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4282
John McCalldfea9982010-04-09 19:12:06 +00004283 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004284 if (Args.hasFlag(options::OPT_fno_access_control,
4285 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00004286 false))
John McCall3155f572010-04-09 19:03:51 +00004287 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004288
Anders Carlssond470fef2010-11-21 00:09:52 +00004289 // -felide-constructors is the default.
4290 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4291 options::OPT_felide_constructors,
4292 false))
4293 CmdArgs.push_back("-fno-elide-constructors");
4294
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004295 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004296
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004297 if (KernelOrKext || (types::isCXX(InputType) &&
4298 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4299 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004300 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004301
Tony Linthicum76329bf2011-12-12 21:14:55 +00004302 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004303 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00004304 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004305 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00004306 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004307 CmdArgs.push_back("-fshort-enums");
4308
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004309 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00004310 if (Arg *A = Args.getLastArg(
4311 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4312 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4313 if (A->getOption().matches(options::OPT_funsigned_char) ||
4314 A->getOption().matches(options::OPT_fno_signed_char)) {
4315 CmdArgs.push_back("-fno-signed-char");
4316 }
4317 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004318 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00004319 }
Eli Friedman327f0b52009-06-05 07:21:14 +00004320
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004321 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004322 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4323 options::OPT_fno_use_cxa_atexit,
4324 !IsWindowsCygnus && !IsWindowsGNU &&
4325 getToolChain().getArch() != llvm::Triple::hexagon &&
4326 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004327 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004328 CmdArgs.push_back("-fno-use-cxa-atexit");
4329
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004330 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004331 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004332 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004333 CmdArgs.push_back("-fms-extensions");
4334
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004335 // -fno-use-line-directives is default.
4336 if (Args.hasFlag(options::OPT_fuse_line_directives,
4337 options::OPT_fno_use_line_directives, false))
4338 CmdArgs.push_back("-fuse-line-directives");
4339
Francois Pichet1b4f1632011-09-17 04:32:15 +00004340 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004341 if (Args.hasFlag(options::OPT_fms_compatibility,
4342 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004343 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
4344 options::OPT_fno_ms_extensions,
4345 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004346 CmdArgs.push_back("-fms-compatibility");
4347
David Majnemerc371ff02015-03-22 08:39:22 +00004348 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00004349 VersionTuple MSVT = visualstudio::getMSVCVersion(
4350 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4351 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00004352 CmdArgs.push_back(
4353 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004354
David Majnemer8db91762015-05-18 04:49:30 +00004355 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4356 if (ImplyVCPPCXXVer) {
4357 if (IsMSVC2015Compatible)
4358 CmdArgs.push_back("-std=c++14");
4359 else
4360 CmdArgs.push_back("-std=c++11");
4361 }
4362
Eric Christopher5ecce122013-02-18 00:38:31 +00004363 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004364 if (Args.hasFlag(options::OPT_fborland_extensions,
4365 options::OPT_fno_borland_extensions, false))
4366 CmdArgs.push_back("-fborland-extensions");
4367
David Majnemerc371ff02015-03-22 08:39:22 +00004368 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4369 // than 19.
4370 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4371 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00004372 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00004373 CmdArgs.push_back("-fno-threadsafe-statics");
4374
Francois Pichet02744872011-09-01 16:38:08 +00004375 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4376 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004377 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004378 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004379 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004380
Chandler Carruthe03aa552010-04-17 20:17:31 +00004381 // -fgnu-keywords default varies depending on language; only pass if
4382 // specified.
4383 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004384 options::OPT_fno_gnu_keywords))
4385 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004386
Rafael Espindola922a6242011-06-02 17:30:53 +00004387 if (Args.hasFlag(options::OPT_fgnu89_inline,
4388 options::OPT_fno_gnu89_inline,
4389 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004390 CmdArgs.push_back("-fgnu89-inline");
4391
Chad Rosier9c76d242012-03-15 22:31:42 +00004392 if (Args.hasArg(options::OPT_fno_inline))
4393 CmdArgs.push_back("-fno-inline");
4394
Chad Rosier64d6be92012-03-06 21:17:19 +00004395 if (Args.hasArg(options::OPT_fno_inline_functions))
4396 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004397
John McCall5fb5df92012-06-20 06:18:46 +00004398 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004399
John McCall5fb5df92012-06-20 06:18:46 +00004400 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004401 // legacy is the default. Except for deployment taget of 10.5,
4402 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4403 // gets ignored silently.
4404 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004405 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4406 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004407 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004408 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004409 if (getToolChain().UseObjCMixedDispatch())
4410 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4411 else
4412 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4413 }
4414 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004415
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004416 // When ObjectiveC legacy runtime is in effect on MacOSX,
4417 // turn on the option to do Array/Dictionary subscripting
4418 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004419 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004420 getToolChain().getTriple().isMacOSX() &&
4421 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4422 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004423 objcRuntime.isNeXTFamily())
4424 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4425
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004426 // -fencode-extended-block-signature=1 is default.
4427 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4428 CmdArgs.push_back("-fencode-extended-block-signature");
4429 }
4430
John McCall24fc0de2011-07-06 00:26:06 +00004431 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4432 // NOTE: This logic is duplicated in ToolChains.cpp.
4433 bool ARC = isObjCAutoRefCount(Args);
4434 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004435 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004436
John McCall24fc0de2011-07-06 00:26:06 +00004437 CmdArgs.push_back("-fobjc-arc");
4438
Chandler Carruth491db322011-11-04 07:34:47 +00004439 // FIXME: It seems like this entire block, and several around it should be
4440 // wrapped in isObjC, but for now we just use it here as this is where it
4441 // was being used previously.
4442 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4443 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4444 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4445 else
4446 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4447 }
4448
John McCall24fc0de2011-07-06 00:26:06 +00004449 // Allow the user to enable full exceptions code emission.
4450 // We define off for Objective-CC, on for Objective-C++.
4451 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4452 options::OPT_fno_objc_arc_exceptions,
4453 /*default*/ types::isCXX(InputType)))
4454 CmdArgs.push_back("-fobjc-arc-exceptions");
4455 }
4456
4457 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4458 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004459 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004460 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004461
John McCall24fc0de2011-07-06 00:26:06 +00004462 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4463 // takes precedence.
4464 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4465 if (!GCArg)
4466 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4467 if (GCArg) {
4468 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004469 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004470 << GCArg->getAsString(Args);
4471 } else if (getToolChain().SupportsObjCGC()) {
4472 GCArg->render(Args, CmdArgs);
4473 } else {
4474 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004475 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004476 << GCArg->getAsString(Args);
4477 }
4478 }
4479
Bob Wilsonb111ec92015-03-02 19:01:14 +00004480 if (Args.hasFlag(options::OPT_fapplication_extension,
4481 options::OPT_fno_application_extension, false))
4482 CmdArgs.push_back("-fapplication-extension");
4483
Reid Klecknerc542d372014-06-27 17:02:02 +00004484 // Handle GCC-style exception args.
4485 if (!C.getDriver().IsCLMode())
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004486 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext,
Reid Klecknerc542d372014-06-27 17:02:02 +00004487 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004488
4489 if (getToolChain().UseSjLjExceptions())
4490 CmdArgs.push_back("-fsjlj-exceptions");
4491
4492 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004493 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4494 options::OPT_fno_assume_sane_operator_new))
4495 CmdArgs.push_back("-fno-assume-sane-operator-new");
4496
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004497 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4498 // most platforms.
4499 if (Args.hasFlag(options::OPT_fsized_deallocation,
4500 options::OPT_fno_sized_deallocation, false))
4501 CmdArgs.push_back("-fsized-deallocation");
4502
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004503 // -fconstant-cfstrings is default, and may be subject to argument translation
4504 // on Darwin.
4505 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4506 options::OPT_fno_constant_cfstrings) ||
4507 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4508 options::OPT_mno_constant_cfstrings))
4509 CmdArgs.push_back("-fno-constant-cfstrings");
4510
John Thompsoned4e2952009-11-05 20:14:16 +00004511 // -fshort-wchar default varies depending on platform; only
4512 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004513 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4514 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004515 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004516
Hans Wennborg28c96312013-07-31 23:39:13 +00004517 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004518 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004519 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004520 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004521 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004522
Daniel Dunbar096ed292011-10-05 21:04:55 +00004523 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4524 // -fno-pack-struct doesn't apply to -fpack-struct=.
4525 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004526 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004527 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004528 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004529 } else if (Args.hasFlag(options::OPT_fpack_struct,
4530 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004531 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004532 }
4533
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004534 // Handle -fmax-type-align=N and -fno-type-align
4535 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4536 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4537 if (!SkipMaxTypeAlign) {
4538 std::string MaxTypeAlignStr = "-fmax-type-align=";
4539 MaxTypeAlignStr += A->getValue();
4540 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4541 }
4542 } else if (getToolChain().getTriple().isOSDarwin()) {
4543 if (!SkipMaxTypeAlign) {
4544 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4545 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4546 }
4547 }
4548
Robert Lytton0e076492013-08-13 09:43:10 +00004549 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004550 if (!Args.hasArg(options::OPT_fcommon))
4551 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004552 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004553 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004554
Daniel Dunbard18049a2009-04-07 21:16:11 +00004555 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004556 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004557 CmdArgs.push_back("-fno-common");
4558
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004559 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004560 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004561 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004562 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004563 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004564 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4565
Daniel Dunbar6358d682010-10-15 22:30:42 +00004566 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4567 if (!Args.hasFlag(options::OPT_ffor_scope,
4568 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004569 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004570 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4571
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004572 // -finput_charset=UTF-8 is default. Reject others
4573 if (Arg *inputCharset = Args.getLastArg(
4574 options::OPT_finput_charset_EQ)) {
4575 StringRef value = inputCharset->getValue();
4576 if (value != "UTF-8")
4577 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4578 }
4579
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004580 // -fexec_charset=UTF-8 is default. Reject others
4581 if (Arg *execCharset = Args.getLastArg(
4582 options::OPT_fexec_charset_EQ)) {
4583 StringRef value = execCharset->getValue();
4584 if (value != "UTF-8")
4585 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4586 }
4587
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004588 // -fcaret-diagnostics is default.
4589 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4590 options::OPT_fno_caret_diagnostics, true))
4591 CmdArgs.push_back("-fno-caret-diagnostics");
4592
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004593 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004594 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004595 options::OPT_fno_diagnostics_fixit_info))
4596 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004597
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004598 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004599 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004600 options::OPT_fno_diagnostics_show_option))
4601 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004602
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004603 if (const Arg *A =
4604 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4605 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004606 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004607 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004608
Douglas Gregor643c9222011-05-21 17:07:29 +00004609 if (const Arg *A =
4610 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4611 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004612 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004613 }
4614
Chandler Carruthb6766f02011-03-27 01:50:55 +00004615 if (Arg *A = Args.getLastArg(
4616 options::OPT_fdiagnostics_show_note_include_stack,
4617 options::OPT_fno_diagnostics_show_note_include_stack)) {
4618 if (A->getOption().matches(
4619 options::OPT_fdiagnostics_show_note_include_stack))
4620 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4621 else
4622 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4623 }
4624
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004625 // Color diagnostics are the default, unless the terminal doesn't support
4626 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004627 // Support both clang's -f[no-]color-diagnostics and gcc's
4628 // -f[no-]diagnostics-colors[=never|always|auto].
4629 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004630 for (const auto &Arg : Args) {
4631 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004632 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4633 !O.matches(options::OPT_fdiagnostics_color) &&
4634 !O.matches(options::OPT_fno_color_diagnostics) &&
4635 !O.matches(options::OPT_fno_diagnostics_color) &&
4636 !O.matches(options::OPT_fdiagnostics_color_EQ))
4637 continue;
4638
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004639 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004640 if (O.matches(options::OPT_fcolor_diagnostics) ||
4641 O.matches(options::OPT_fdiagnostics_color)) {
4642 ShowColors = Colors_On;
4643 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4644 O.matches(options::OPT_fno_diagnostics_color)) {
4645 ShowColors = Colors_Off;
4646 } else {
4647 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004648 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004649 if (value == "always")
4650 ShowColors = Colors_On;
4651 else if (value == "never")
4652 ShowColors = Colors_Off;
4653 else if (value == "auto")
4654 ShowColors = Colors_Auto;
4655 else
4656 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4657 << ("-fdiagnostics-color=" + value).str();
4658 }
4659 }
4660 if (ShowColors == Colors_On ||
4661 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004662 CmdArgs.push_back("-fcolor-diagnostics");
4663
Nico Rieck7857d462013-09-11 00:38:02 +00004664 if (Args.hasArg(options::OPT_fansi_escape_codes))
4665 CmdArgs.push_back("-fansi-escape-codes");
4666
Daniel Dunbardb097022009-06-08 21:13:54 +00004667 if (!Args.hasFlag(options::OPT_fshow_source_location,
4668 options::OPT_fno_show_source_location))
4669 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004670
Douglas Gregor643c9222011-05-21 17:07:29 +00004671 if (!Args.hasFlag(options::OPT_fshow_column,
4672 options::OPT_fno_show_column,
4673 true))
4674 CmdArgs.push_back("-fno-show-column");
4675
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004676 if (!Args.hasFlag(options::OPT_fspell_checking,
4677 options::OPT_fno_spell_checking))
4678 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004679
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004680
Chad Rosierc8e56e82012-12-05 21:08:21 +00004681 // -fno-asm-blocks is default.
4682 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4683 false))
4684 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004685
Steven Wucb0d13f2015-01-16 23:05:28 +00004686 // -fgnu-inline-asm is default.
4687 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4688 options::OPT_fno_gnu_inline_asm, true))
4689 CmdArgs.push_back("-fno-gnu-inline-asm");
4690
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004691 // Enable vectorization per default according to the optimization level
4692 // selected. For optimization levels that want vectorization we use the alias
4693 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004694 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004695 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004696 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004697 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004698 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004699 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004700
Chad Rosier136d67d2014-04-28 19:30:57 +00004701 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004702 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4703 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004704 options::OPT_fslp_vectorize;
4705 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004706 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004707 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004708
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004709 // -fno-slp-vectorize-aggressive is default.
4710 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004711 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004712 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004713
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004714 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4715 A->render(Args, CmdArgs);
4716
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004717 // -fdollars-in-identifiers default varies depending on platform and
4718 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004719 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004720 options::OPT_fno_dollars_in_identifiers)) {
4721 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004722 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004723 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004724 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004725 }
4726
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004727 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4728 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004729 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004730 options::OPT_fno_unit_at_a_time)) {
4731 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004732 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004733 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004734
Eli Friedman055c9702011-11-02 01:53:16 +00004735 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4736 options::OPT_fno_apple_pragma_pack, false))
4737 CmdArgs.push_back("-fapple-pragma-pack");
4738
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004739 // le32-specific flags:
4740 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4741 // by default.
4742 if (getToolChain().getArch() == llvm::Triple::le32) {
4743 CmdArgs.push_back("-fno-math-builtin");
4744 }
4745
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004746 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004747 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004748 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004749#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004750 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004751 (getToolChain().getArch() == llvm::Triple::arm ||
4752 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004753 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4754 CmdArgs.push_back("-fno-builtin-strcat");
4755 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4756 CmdArgs.push_back("-fno-builtin-strcpy");
4757 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004758#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004759
Justin Bognera88f0122014-06-20 22:59:50 +00004760 // Enable rewrite includes if the user's asked for it or if we're generating
4761 // diagnostics.
4762 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4763 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004764 if (Args.hasFlag(options::OPT_frewrite_includes,
4765 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004766 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004767 CmdArgs.push_back("-frewrite-includes");
4768
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004769 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004770 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004771 options::OPT_traditional_cpp)) {
4772 if (isa<PreprocessJobAction>(JA))
4773 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004774 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004775 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004776 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004777
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004778 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004779 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004780
4781 // Handle serialized diagnostics.
4782 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4783 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004784 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004785 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004786
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004787 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4788 CmdArgs.push_back("-fretain-comments-from-system-headers");
4789
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004790 // Forward -fcomment-block-commands to -cc1.
4791 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004792 // Forward -fparse-all-comments to -cc1.
4793 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004794
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004795 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4796 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004797 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004798 bool OptDisabled = false;
Sean Silva14facf32015-06-09 01:57:17 +00004799 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
4800 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004801
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004802 // We translate this by hand to the -cc1 argument, since nightly test uses
4803 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00004804 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004805 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004806 OptDisabled = true;
4807 } else
Sean Silva14facf32015-06-09 01:57:17 +00004808 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004809 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004810
Bob Wilson23a55f12014-12-21 07:00:00 +00004811 // With -save-temps, we want to save the unoptimized bitcode output from the
4812 // CompileJobAction, so disable optimizations if they are not already
4813 // disabled.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00004814 if (C.getDriver().isSaveTempsEnabled() && !OptDisabled &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004815 isa<CompileJobAction>(JA))
4816 CmdArgs.push_back("-disable-llvm-optzns");
4817
Daniel Dunbard67a3222009-03-30 06:36:42 +00004818 if (Output.getType() == types::TY_Dependencies) {
4819 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004820 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004821 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004822 CmdArgs.push_back(Output.getFilename());
4823 } else {
4824 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004825 }
4826
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004827 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004828 addDashXForInput(Args, II, CmdArgs);
4829
Daniel Dunbarb440f562010-08-02 02:38:21 +00004830 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004831 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004832 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004833 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004834 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004835
Chris Lattnere9d7d782009-11-03 19:50:27 +00004836 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4837
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004838 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004839
4840 // Optionally embed the -cc1 level arguments into the debug info, for build
4841 // analysis.
4842 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004843 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004844 for (const auto &Arg : Args)
4845 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004846
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004847 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004848 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004849 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004850 SmallString<128> EscapedArg;
4851 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004852 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004853 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004854 }
4855 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00004856 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004857 }
4858
Eric Christopherd3804002013-02-22 20:12:52 +00004859 // Add the split debug info name to the command lines here so we
4860 // can propagate it to the backend.
4861 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004862 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004863 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4864 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004865 const char *SplitDwarfOut;
4866 if (SplitDwarf) {
4867 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00004868 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00004869 CmdArgs.push_back(SplitDwarfOut);
4870 }
4871
4872 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004873 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004874 Output.getType() == types::TY_Object &&
4875 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004876 auto CLCommand =
4877 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4878 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4879 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004880 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004881 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004882 }
4883
Daniel Dunbar17731772009-03-23 19:03:36 +00004884
Eric Christopherf1545832013-02-22 23:50:16 +00004885 // Handle the debug info splitting at object creation time if we're
4886 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004887 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004888 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004889 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004890
Roman Divacky178e01602011-02-10 16:52:03 +00004891 if (Arg *A = Args.getLastArg(options::OPT_pg))
4892 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004893 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004894 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004895
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004896 // Claim some arguments which clang supports automatically.
4897
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004898 // -fpch-preprocess is used with gcc to add a special marker in the output to
4899 // include the PCH file. Clang's PTH solution is completely transparent, so we
4900 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004901 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004902
Daniel Dunbar17731772009-03-23 19:03:36 +00004903 // Claim some arguments which clang doesn't support, but we don't
4904 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004905 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4906 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004907
Rafael Espindolab0092d72013-09-04 19:37:35 +00004908 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004909 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004910}
4911
John McCall5fb5df92012-06-20 06:18:46 +00004912/// Add options related to the Objective-C runtime/ABI.
4913///
4914/// Returns true if the runtime is non-fragile.
4915ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4916 ArgStringList &cmdArgs,
4917 RewriteKind rewriteKind) const {
4918 // Look for the controlling runtime option.
4919 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4920 options::OPT_fgnu_runtime,
4921 options::OPT_fobjc_runtime_EQ);
4922
4923 // Just forward -fobjc-runtime= to the frontend. This supercedes
4924 // options about fragility.
4925 if (runtimeArg &&
4926 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4927 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004928 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004929 if (runtime.tryParse(value)) {
4930 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4931 << value;
4932 }
4933
4934 runtimeArg->render(args, cmdArgs);
4935 return runtime;
4936 }
4937
4938 // Otherwise, we'll need the ABI "version". Version numbers are
4939 // slightly confusing for historical reasons:
4940 // 1 - Traditional "fragile" ABI
4941 // 2 - Non-fragile ABI, version 1
4942 // 3 - Non-fragile ABI, version 2
4943 unsigned objcABIVersion = 1;
4944 // If -fobjc-abi-version= is present, use that to set the version.
4945 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004946 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004947 if (value == "1")
4948 objcABIVersion = 1;
4949 else if (value == "2")
4950 objcABIVersion = 2;
4951 else if (value == "3")
4952 objcABIVersion = 3;
4953 else
4954 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4955 << value;
4956 } else {
4957 // Otherwise, determine if we are using the non-fragile ABI.
4958 bool nonFragileABIIsDefault =
4959 (rewriteKind == RK_NonFragile ||
4960 (rewriteKind == RK_None &&
4961 getToolChain().IsObjCNonFragileABIDefault()));
4962 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4963 options::OPT_fno_objc_nonfragile_abi,
4964 nonFragileABIIsDefault)) {
4965 // Determine the non-fragile ABI version to use.
4966#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4967 unsigned nonFragileABIVersion = 1;
4968#else
4969 unsigned nonFragileABIVersion = 2;
4970#endif
4971
4972 if (Arg *abiArg = args.getLastArg(
4973 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004974 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004975 if (value == "1")
4976 nonFragileABIVersion = 1;
4977 else if (value == "2")
4978 nonFragileABIVersion = 2;
4979 else
4980 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4981 << value;
4982 }
4983
4984 objcABIVersion = 1 + nonFragileABIVersion;
4985 } else {
4986 objcABIVersion = 1;
4987 }
4988 }
4989
4990 // We don't actually care about the ABI version other than whether
4991 // it's non-fragile.
4992 bool isNonFragile = objcABIVersion != 1;
4993
4994 // If we have no runtime argument, ask the toolchain for its default runtime.
4995 // However, the rewriter only really supports the Mac runtime, so assume that.
4996 ObjCRuntime runtime;
4997 if (!runtimeArg) {
4998 switch (rewriteKind) {
4999 case RK_None:
5000 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5001 break;
5002 case RK_Fragile:
5003 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5004 break;
5005 case RK_NonFragile:
5006 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5007 break;
5008 }
5009
5010 // -fnext-runtime
5011 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5012 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005013 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00005014 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5015
5016 // Otherwise, build for a generic macosx port.
5017 } else {
5018 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5019 }
5020
5021 // -fgnu-runtime
5022 } else {
5023 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00005024 // Legacy behaviour is to target the gnustep runtime if we are i
5025 // non-fragile mode or the GCC runtime in fragile mode.
5026 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00005027 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00005028 else
5029 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00005030 }
5031
5032 cmdArgs.push_back(args.MakeArgString(
5033 "-fobjc-runtime=" + runtime.getAsString()));
5034 return runtime;
5035}
5036
Reid Klecknerc542d372014-06-27 17:02:02 +00005037static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5038 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5039 I += HaveDash;
5040 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00005041}
Reid Klecknerc542d372014-06-27 17:02:02 +00005042
5043struct EHFlags {
5044 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
5045 bool Synch;
5046 bool Asynch;
5047 bool NoExceptC;
5048};
5049
5050/// /EH controls whether to run destructor cleanups when exceptions are
5051/// thrown. There are three modifiers:
5052/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5053/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5054/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
5055/// - c: Assume that extern "C" functions are implicitly noexcept. This
5056/// modifier is an optimization, so we ignore it for now.
5057/// The default is /EHs-c-, meaning cleanups are disabled.
5058static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5059 EHFlags EH;
5060 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
5061 for (auto EHVal : EHArgs) {
5062 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
5063 switch (EHVal[I]) {
5064 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
5065 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
5066 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
5067 default: break;
5068 }
5069 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
5070 break;
5071 }
5072 }
5073 return EH;
5074}
5075
Hans Wennborg75958c42013-08-08 00:17:41 +00005076void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
5077 unsigned RTOptionID = options::OPT__SLASH_MT;
5078
Hans Wennborgf1a74252013-09-10 20:18:04 +00005079 if (Args.hasArg(options::OPT__SLASH_LDd))
5080 // The /LDd option implies /MTd. The dependent lib part can be overridden,
5081 // but defining _DEBUG is sticky.
5082 RTOptionID = options::OPT__SLASH_MTd;
5083
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00005084 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00005085 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00005086
Hans Wennborg75958c42013-08-08 00:17:41 +00005087 switch(RTOptionID) {
5088 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00005089 if (Args.hasArg(options::OPT__SLASH_LDd))
5090 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00005091 CmdArgs.push_back("-D_MT");
5092 CmdArgs.push_back("-D_DLL");
5093 CmdArgs.push_back("--dependent-lib=msvcrt");
5094 break;
5095 case options::OPT__SLASH_MDd:
5096 CmdArgs.push_back("-D_DEBUG");
5097 CmdArgs.push_back("-D_MT");
5098 CmdArgs.push_back("-D_DLL");
5099 CmdArgs.push_back("--dependent-lib=msvcrtd");
5100 break;
5101 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00005102 if (Args.hasArg(options::OPT__SLASH_LDd))
5103 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00005104 CmdArgs.push_back("-D_MT");
5105 CmdArgs.push_back("--dependent-lib=libcmt");
5106 break;
5107 case options::OPT__SLASH_MTd:
5108 CmdArgs.push_back("-D_DEBUG");
5109 CmdArgs.push_back("-D_MT");
5110 CmdArgs.push_back("--dependent-lib=libcmtd");
5111 break;
5112 default:
5113 llvm_unreachable("Unexpected option ID.");
5114 }
5115
Reid Kleckner6beca0e2013-08-08 19:33:10 +00005116 // This provides POSIX compatibility (maps 'open' to '_open'), which most
5117 // users want. The /Za flag to cl.exe turns this off, but it's not
5118 // implemented in clang.
5119 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00005120
Hans Wennborg8858a032014-07-21 23:42:07 +00005121 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
5122 // would produce interleaved output, so ignore /showIncludes in such cases.
5123 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5124 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5125 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00005126
David Majnemerf6072342014-07-01 22:24:56 +00005127 // This controls whether or not we emit RTTI data for polymorphic types.
5128 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5129 /*default=*/false))
5130 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00005131
Reid Klecknerc542d372014-06-27 17:02:02 +00005132 const Driver &D = getToolChain().getDriver();
5133 EHFlags EH = parseClangCLEHFlags(D, Args);
5134 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005135 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00005136 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005137 CmdArgs.push_back("-fexceptions");
5138 }
Reid Klecknerc542d372014-06-27 17:02:02 +00005139
Hans Wennborge50cec32014-06-13 20:59:54 +00005140 // /EP should expand to -E -P.
5141 if (Args.hasArg(options::OPT__SLASH_EP)) {
5142 CmdArgs.push_back("-E");
5143 CmdArgs.push_back("-P");
5144 }
5145
David Majnemera5b195a2015-02-14 01:35:12 +00005146 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005147 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5148 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00005149 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5150 else
5151 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5152
5153 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5154 VolatileOptionID = A->getOption().getID();
5155
5156 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5157 CmdArgs.push_back("-fms-volatile");
5158
David Majnemer86c318f2014-02-11 21:05:00 +00005159 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5160 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5161 if (MostGeneralArg && BestCaseArg)
5162 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5163 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5164
5165 if (MostGeneralArg) {
5166 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5167 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5168 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5169
5170 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5171 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5172 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5173 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5174 << FirstConflict->getAsString(Args)
5175 << SecondConflict->getAsString(Args);
5176
5177 if (SingleArg)
5178 CmdArgs.push_back("-fms-memptr-rep=single");
5179 else if (MultipleArg)
5180 CmdArgs.push_back("-fms-memptr-rep=multiple");
5181 else
5182 CmdArgs.push_back("-fms-memptr-rep=virtual");
5183 }
5184
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00005185 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5186 A->render(Args, CmdArgs);
5187
Hans Wennborg81f74482013-09-10 01:07:07 +00005188 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5189 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00005190 if (Args.hasArg(options::OPT__SLASH_fallback))
5191 CmdArgs.push_back("msvc-fallback");
5192 else
5193 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00005194 }
Hans Wennborg75958c42013-08-08 00:17:41 +00005195}
5196
Hans Wennborg1da044a2014-06-26 19:59:02 +00005197visualstudio::Compile *Clang::getCLFallback() const {
5198 if (!CLFallback)
5199 CLFallback.reset(new visualstudio::Compile(getToolChain()));
5200 return CLFallback.get();
5201}
5202
Daniel Sanders7f933f42015-01-30 17:35:23 +00005203void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5204 ArgStringList &CmdArgs) const {
5205 StringRef CPUName;
5206 StringRef ABIName;
5207 const llvm::Triple &Triple = getToolChain().getTriple();
5208 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5209
5210 CmdArgs.push_back("-target-abi");
5211 CmdArgs.push_back(ABIName.data());
5212}
5213
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005214void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005215 const InputInfo &Output,
5216 const InputInfoList &Inputs,
5217 const ArgList &Args,
5218 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005219 ArgStringList CmdArgs;
5220
5221 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5222 const InputInfo &Input = Inputs[0];
5223
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005224 // Don't warn about "clang -w -c foo.s"
5225 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005226 // and "clang -emit-llvm -c foo.s"
5227 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005228
Rafael Espindola577637a2015-01-03 00:06:04 +00005229 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005230
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005231 // Invoke ourselves in -cc1as mode.
5232 //
5233 // FIXME: Implement custom jobs for internal actions.
5234 CmdArgs.push_back("-cc1as");
5235
5236 // Add the "effective" target triple.
5237 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00005238 std::string TripleStr =
5239 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005240 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5241
5242 // Set the output mode, we currently only expect to be used as a real
5243 // assembler.
5244 CmdArgs.push_back("-filetype");
5245 CmdArgs.push_back("obj");
5246
Eric Christopher45f2e712012-12-18 00:31:10 +00005247 // Set the main file name, so that debug info works even with
5248 // -save-temps or preprocessed assembly.
5249 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00005250 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00005251
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005252 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00005253 const llvm::Triple Triple(TripleStr);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005254 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005255 if (!CPU.empty()) {
5256 CmdArgs.push_back("-target-cpu");
5257 CmdArgs.push_back(Args.MakeArgString(CPU));
5258 }
5259
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005260 // Add the target features
5261 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00005262 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005263
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005264 // Ignore explicit -force_cpusubtype_ALL option.
5265 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005266
Eric Christopherfc3ee562012-01-10 00:38:01 +00005267 // Determine the original source input.
5268 const Action *SourceAction = &JA;
5269 while (SourceAction->getKind() != Action::InputClass) {
5270 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5271 SourceAction = SourceAction->getInputs()[0];
5272 }
5273
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005274 // Forward -g and handle debug info related flags, assuming we are dealing
5275 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005276 if (SourceAction->getType() == types::TY_Asm ||
5277 SourceAction->getType() == types::TY_PP_Asm) {
5278 Args.ClaimAllArgs(options::OPT_g_Group);
5279 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5280 if (!A->getOption().matches(options::OPT_g0))
5281 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005282
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005283 if (Args.hasArg(options::OPT_gdwarf_2))
5284 CmdArgs.push_back("-gdwarf-2");
5285 if (Args.hasArg(options::OPT_gdwarf_3))
5286 CmdArgs.push_back("-gdwarf-3");
5287 if (Args.hasArg(options::OPT_gdwarf_4))
5288 CmdArgs.push_back("-gdwarf-4");
5289
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005290 // Add the -fdebug-compilation-dir flag if needed.
5291 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005292
5293 // Set the AT_producer to the clang version when using the integrated
5294 // assembler on assembly source files.
5295 CmdArgs.push_back("-dwarf-debug-producer");
5296 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00005297 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005298
5299 // Optionally embed the -cc1as level arguments into the debug info, for build
5300 // analysis.
5301 if (getToolChain().UseDwarfDebugFlags()) {
5302 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005303 for (const auto &Arg : Args)
5304 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005305
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005306 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005307 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5308 Flags += Exec;
5309 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005310 SmallString<128> EscapedArg;
5311 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005312 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005313 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005314 }
5315 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005316 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005317 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005318
5319 // FIXME: Add -static support, once we have it.
5320
Daniel Sanders7f933f42015-01-30 17:35:23 +00005321 // Add target specific flags.
5322 switch(getToolChain().getArch()) {
5323 default:
5324 break;
5325
5326 case llvm::Triple::mips:
5327 case llvm::Triple::mipsel:
5328 case llvm::Triple::mips64:
5329 case llvm::Triple::mips64el:
5330 AddMIPSTargetArgs(Args, CmdArgs);
5331 break;
5332 }
5333
David Blaikie372d9502014-01-17 03:17:40 +00005334 // Consume all the warning flags. Usually this would be handled more
5335 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5336 // doesn't handle that so rather than warning about unused flags that are
5337 // actually used, we'll lie by omission instead.
5338 // FIXME: Stop lying and consume only the appropriate driver flags
Sean Silva14facf32015-06-09 01:57:17 +00005339 for (const Arg *A : Args.filtered(options::OPT_W_Group))
5340 A->claim();
David Blaikie372d9502014-01-17 03:17:40 +00005341
David Blaikie9260ed62013-07-25 21:19:01 +00005342 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5343 getToolChain().getDriver());
5344
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005345 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005346
5347 assert(Output.isFilename() && "Unexpected lipo output.");
5348 CmdArgs.push_back("-o");
5349 CmdArgs.push_back(Output.getFilename());
5350
Daniel Dunbarb440f562010-08-02 02:38:21 +00005351 assert(Input.isFilename() && "Invalid input.");
5352 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005353
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005354 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00005355 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00005356
5357 // Handle the debug info splitting at object creation time if we're
5358 // creating an object.
5359 // TODO: Currently only works on linux with newer objcopy.
5360 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005361 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005362 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00005363 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005364}
5365
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005366void GnuTool::anchor() {}
5367
Daniel Dunbara3246a02009-03-18 08:07:30 +00005368void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005369 const InputInfo &Output,
5370 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005371 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005372 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005373 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005374 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005375
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005376 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005377 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005378 // Don't forward any -g arguments to assembly steps.
5379 if (isa<AssembleJobAction>(JA) &&
5380 A->getOption().matches(options::OPT_g_Group))
5381 continue;
5382
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005383 // Don't forward any -W arguments to assembly and link steps.
5384 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5385 A->getOption().matches(options::OPT_W_Group))
5386 continue;
5387
Daniel Dunbar2da02722009-03-19 07:55:12 +00005388 // It is unfortunate that we have to claim here, as this means
5389 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005390 // platforms using a generic gcc, even if we are just using gcc
5391 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005392 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005393 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005394 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005395 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005396
Daniel Dunbar4e295052010-01-25 22:35:08 +00005397 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005398
5399 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005400 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005401 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005402 CmdArgs.push_back(
5403 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005404 }
5405
Daniel Dunbar5716d872009-05-02 21:41:52 +00005406 // Try to force gcc to match the tool chain we want, if we recognize
5407 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005408 //
5409 // FIXME: The triple class should directly provide the information we want
5410 // here.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005411 const llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005412 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005413 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00005414 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5415 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005416 CmdArgs.push_back("-m64");
5417
Daniel Dunbarb440f562010-08-02 02:38:21 +00005418 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005419 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005420 CmdArgs.push_back(Output.getFilename());
5421 } else {
5422 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005423 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005424 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005425
Tony Linthicum76329bf2011-12-12 21:14:55 +00005426 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5427 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005428
5429 // Only pass -x if gcc will understand it; otherwise hope gcc
5430 // understands the suffix correctly. The main use case this would go
5431 // wrong in is for linker inputs if they happened to have an odd
5432 // suffix; really the only way to get this to happen is a command
5433 // like '-x foobar a.c' which will treat a.c like a linker input.
5434 //
5435 // FIXME: For the linker case specifically, can we safely convert
5436 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005437 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005438 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005439 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5440 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005441 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005442 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005443 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005444 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005445 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005446 else if (II.getType() == types::TY_ModuleFile)
5447 D.Diag(diag::err_drv_no_module_support)
5448 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005449
Daniel Dunbara3246a02009-03-18 08:07:30 +00005450 if (types::canTypeBeUserSpecified(II.getType())) {
5451 CmdArgs.push_back("-x");
5452 CmdArgs.push_back(types::getTypeName(II.getType()));
5453 }
5454
Daniel Dunbarb440f562010-08-02 02:38:21 +00005455 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005456 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005457 else {
5458 const Arg &A = II.getInputArg();
5459
5460 // Reverse translate some rewritten options.
5461 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5462 CmdArgs.push_back("-lstdc++");
5463 continue;
5464 }
5465
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005466 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005467 A.render(Args, CmdArgs);
5468 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005469 }
5470
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005471 const std::string customGCCName = D.getCCCGenericGCCName();
5472 const char *GCCName;
5473 if (!customGCCName.empty())
5474 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005475 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005476 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005477 } else
5478 GCCName = "gcc";
5479
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005480 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005481 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005482 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005483}
5484
Daniel Dunbar4e295052010-01-25 22:35:08 +00005485void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5486 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005487 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005488}
5489
Daniel Dunbar4e295052010-01-25 22:35:08 +00005490void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5491 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005492 const Driver &D = getToolChain().getDriver();
5493
Eric Christophercc7ff502015-01-29 00:56:17 +00005494 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005495 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005496 case types::TY_LLVM_IR:
5497 case types::TY_LTO_IR:
5498 case types::TY_LLVM_BC:
5499 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005500 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005501 break;
5502 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005503 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005504 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005505 case types::TY_Nothing:
5506 CmdArgs.push_back("-fsyntax-only");
5507 break;
5508 default:
5509 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005510 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005511}
5512
Daniel Dunbar4e295052010-01-25 22:35:08 +00005513void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5514 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005515 // The types are (hopefully) good enough.
5516}
5517
Tony Linthicum76329bf2011-12-12 21:14:55 +00005518// Hexagon tools start.
5519void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5520 ArgStringList &CmdArgs) const {
5521
5522}
5523void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5524 const InputInfo &Output,
5525 const InputInfoList &Inputs,
5526 const ArgList &Args,
5527 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005528 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005529
5530 const Driver &D = getToolChain().getDriver();
5531 ArgStringList CmdArgs;
5532
5533 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005534 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005535 CmdArgs.push_back(Args.MakeArgString(MarchString));
5536
5537 RenderExtraToolArgs(JA, CmdArgs);
5538
5539 if (Output.isFilename()) {
5540 CmdArgs.push_back("-o");
5541 CmdArgs.push_back(Output.getFilename());
5542 } else {
5543 assert(Output.isNothing() && "Unexpected output");
5544 CmdArgs.push_back("-fsyntax-only");
5545 }
5546
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005547 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args))
5548 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005549
Matthew Curtise5df3812012-12-07 17:23:04 +00005550 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5551 options::OPT_Xassembler);
5552
Tony Linthicum76329bf2011-12-12 21:14:55 +00005553 // Only pass -x if gcc will understand it; otherwise hope gcc
5554 // understands the suffix correctly. The main use case this would go
5555 // wrong in is for linker inputs if they happened to have an odd
5556 // suffix; really the only way to get this to happen is a command
5557 // like '-x foobar a.c' which will treat a.c like a linker input.
5558 //
5559 // FIXME: For the linker case specifically, can we safely convert
5560 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005561 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005562 // Don't try to pass LLVM or AST inputs to a generic gcc.
5563 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5564 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5565 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5566 << getToolChain().getTripleString();
5567 else if (II.getType() == types::TY_AST)
5568 D.Diag(clang::diag::err_drv_no_ast_support)
5569 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005570 else if (II.getType() == types::TY_ModuleFile)
5571 D.Diag(diag::err_drv_no_module_support)
5572 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005573
5574 if (II.isFilename())
5575 CmdArgs.push_back(II.getFilename());
5576 else
5577 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5578 II.getInputArg().render(Args, CmdArgs);
5579 }
5580
5581 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005582 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005583 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005584}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005585
Tony Linthicum76329bf2011-12-12 21:14:55 +00005586void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5587 ArgStringList &CmdArgs) const {
5588 // The types are (hopefully) good enough.
5589}
5590
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005591static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
5592 const toolchains::Hexagon_TC& ToolChain,
5593 const InputInfo &Output,
5594 const InputInfoList &Inputs,
5595 const ArgList &Args,
5596 ArgStringList &CmdArgs,
5597 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005598
Matthew Curtise689b052012-12-06 15:46:07 +00005599 const Driver &D = ToolChain.getDriver();
5600
Tony Linthicum76329bf2011-12-12 21:14:55 +00005601
Matthew Curtise689b052012-12-06 15:46:07 +00005602 //----------------------------------------------------------------------------
5603 //
5604 //----------------------------------------------------------------------------
5605 bool hasStaticArg = Args.hasArg(options::OPT_static);
5606 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005607 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005608 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5609 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5610 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005611 bool useG0 = false;
Matthew Curtise689b052012-12-06 15:46:07 +00005612 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005613
Matthew Curtise689b052012-12-06 15:46:07 +00005614 //----------------------------------------------------------------------------
5615 // Silence warnings for various options
5616 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005617
Matthew Curtise689b052012-12-06 15:46:07 +00005618 Args.ClaimAllArgs(options::OPT_g_Group);
5619 Args.ClaimAllArgs(options::OPT_emit_llvm);
5620 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5621 // handled somewhere else.
5622 Args.ClaimAllArgs(options::OPT_static_libgcc);
5623
5624 //----------------------------------------------------------------------------
5625 //
5626 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005627 for (const auto &Opt : ToolChain.ExtraOpts)
5628 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005629
Matthew Curtisf10a5952012-12-06 14:16:43 +00005630 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5631 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005632
Matthew Curtise689b052012-12-06 15:46:07 +00005633 if (buildingLib) {
5634 CmdArgs.push_back("-shared");
5635 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5636 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005637 }
5638
Matthew Curtise689b052012-12-06 15:46:07 +00005639 if (hasStaticArg)
5640 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005641
Matthew Curtise8f80a12012-12-06 17:49:03 +00005642 if (buildPIE && !buildingLib)
5643 CmdArgs.push_back("-pie");
5644
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005645 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
5646 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
5647 useG0 = toolchains::Hexagon_TC::UsesG0(v);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005648 }
5649
Matthew Curtise689b052012-12-06 15:46:07 +00005650 //----------------------------------------------------------------------------
5651 //
5652 //----------------------------------------------------------------------------
5653 CmdArgs.push_back("-o");
5654 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005655
Matthew Curtise689b052012-12-06 15:46:07 +00005656 const std::string MarchSuffix = "/" + MarchString;
5657 const std::string G0Suffix = "/G0";
5658 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005659 const std::string RootDir =
5660 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005661 const std::string StartFilesDir = RootDir
5662 + "hexagon/lib"
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005663 + (useG0 ? MarchG0Suffix : MarchSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00005664
5665 //----------------------------------------------------------------------------
5666 // moslib
5667 //----------------------------------------------------------------------------
5668 std::vector<std::string> oslibs;
5669 bool hasStandalone= false;
5670
Sean Silva14facf32015-06-09 01:57:17 +00005671 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5672 A->claim();
5673 oslibs.emplace_back(A->getValue());
Matthew Curtise689b052012-12-06 15:46:07 +00005674 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005675 }
Matthew Curtise689b052012-12-06 15:46:07 +00005676 if (oslibs.empty()) {
5677 oslibs.push_back("standalone");
5678 hasStandalone = true;
5679 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005680
Matthew Curtise689b052012-12-06 15:46:07 +00005681 //----------------------------------------------------------------------------
5682 // Start Files
5683 //----------------------------------------------------------------------------
5684 if (incStdLib && incStartFiles) {
5685
5686 if (!buildingLib) {
5687 if (hasStandalone) {
5688 CmdArgs.push_back(
5689 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5690 }
5691 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5692 }
5693 std::string initObj = useShared ? "/initS.o" : "/init.o";
5694 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5695 }
5696
5697 //----------------------------------------------------------------------------
5698 // Library Search Paths
5699 //----------------------------------------------------------------------------
5700 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005701 for (const auto &LibPath : LibPaths)
5702 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005703
5704 //----------------------------------------------------------------------------
5705 //
5706 //----------------------------------------------------------------------------
5707 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5708 Args.AddAllArgs(CmdArgs, options::OPT_e);
5709 Args.AddAllArgs(CmdArgs, options::OPT_s);
5710 Args.AddAllArgs(CmdArgs, options::OPT_t);
5711 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5712
5713 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5714
5715 //----------------------------------------------------------------------------
5716 // Libraries
5717 //----------------------------------------------------------------------------
5718 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005719 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005720 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5721 CmdArgs.push_back("-lm");
5722 }
5723
5724 CmdArgs.push_back("--start-group");
5725
5726 if (!buildingLib) {
5727 for(std::vector<std::string>::iterator i = oslibs.begin(),
5728 e = oslibs.end(); i != e; ++i)
5729 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5730 CmdArgs.push_back("-lc");
5731 }
5732 CmdArgs.push_back("-lgcc");
5733
5734 CmdArgs.push_back("--end-group");
5735 }
5736
5737 //----------------------------------------------------------------------------
5738 // End files
5739 //----------------------------------------------------------------------------
5740 if (incStdLib && incStartFiles) {
5741 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5742 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5743 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005744}
5745
5746void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5747 const InputInfo &Output,
5748 const InputInfoList &Inputs,
5749 const ArgList &Args,
5750 const char *LinkingOutput) const {
5751
5752 const toolchains::Hexagon_TC& ToolChain =
5753 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5754
5755 ArgStringList CmdArgs;
5756 constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
5757 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00005758
5759 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005760 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5761 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005762}
5763// Hexagon tools end.
5764
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005765const std::string arm::getARMArch(const ArgList &Args,
5766 const llvm::Triple &Triple) {
5767 std::string MArch;
Bernard Ogden31561762013-12-12 13:27:11 +00005768 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5769 // Otherwise, if we have -march= choose the base CPU for that arch.
5770 MArch = A->getValue();
5771 } else {
5772 // Otherwise, use the Arch from the triple.
5773 MArch = Triple.getArchName();
5774 }
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005775 MArch = StringRef(MArch).lower();
John Brawn94fd9632015-05-21 12:19:49 +00005776
5777 // Handle -march=native.
5778 if (MArch == "native") {
5779 std::string CPU = llvm::sys::getHostCPUName();
5780 if (CPU != "generic") {
5781 // Translate the native cpu into the architecture suffix for that CPU.
5782 const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch);
5783 // If there is no valid architecture suffix for this CPU we don't know how
5784 // to handle it, so return no architecture.
5785 if (strcmp(Suffix,"") == 0)
5786 MArch = "";
5787 else
5788 MArch = std::string("arm") + Suffix;
5789 }
5790 }
5791
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005792 return MArch;
5793}
5794/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
5795const char *arm::getARMCPUForMArch(const ArgList &Args,
5796 const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005797 std::string MArch = getARMArch(Args, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00005798 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
5799 // here means an -march=native that we can't handle, so instead return no CPU.
5800 if (MArch.empty())
5801 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005802
John Brawna95c1a82015-05-08 12:52:18 +00005803 // We need to return an empty string here on invalid MArch values as the
5804 // various places that call this function can't cope with a null result.
5805 const char *result = Triple.getARMCPUForArch(MArch);
5806 if (result)
5807 return result;
5808 else
5809 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005810}
5811
5812/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Gabor Ballabas208826c2015-06-04 17:56:32 +00005813std::string arm::getARMTargetCPU(const ArgList &Args,
Rafael Espindola80d333b2013-12-12 15:48:19 +00005814 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005815 // FIXME: Warn on inconsistent use of -mcpu and -march.
5816 // If we have -mcpu=, use that.
5817 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Gabor Ballabas208826c2015-06-04 17:56:32 +00005818 std::string MCPU = StringRef(A->getValue()).lower();
Bernard Ogden31561762013-12-12 13:27:11 +00005819 // Handle -mcpu=native.
5820 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005821 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005822 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005823 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005824 }
5825
5826 return getARMCPUForMArch(Args, Triple);
5827}
5828
5829/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005830/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00005831// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005832const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) {
Artyom Skrobov902ac2d2015-06-04 21:31:41 +00005833 if (CPU == "generic" &&
5834 llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_ARMV8_1A)
5835 return "v8.1a";
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005836
Renato Golin3c007252015-05-28 15:05:53 +00005837 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
5838 if (ArchKind == llvm::ARM::AK_INVALID)
5839 return "";
5840 return llvm::ARMTargetParser::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00005841}
5842
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005843void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
5844 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005845 if (Args.hasArg(options::OPT_r))
5846 return;
5847
John Brawn94fd9632015-05-21 12:19:49 +00005848 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
5849 // to generate BE-8 executables.
5850 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
5851 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005852}
5853
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00005854mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
5855 return (NanEncoding)llvm::StringSwitch<int>(CPU)
5856 .Case("mips1", NanLegacy)
5857 .Case("mips2", NanLegacy)
5858 .Case("mips3", NanLegacy)
5859 .Case("mips4", NanLegacy)
5860 .Case("mips5", NanLegacy)
5861 .Case("mips32", NanLegacy)
5862 .Case("mips32r2", NanLegacy)
5863 .Case("mips32r3", NanLegacy | Nan2008)
5864 .Case("mips32r5", NanLegacy | Nan2008)
5865 .Case("mips32r6", Nan2008)
5866 .Case("mips64", NanLegacy)
5867 .Case("mips64r2", NanLegacy)
5868 .Case("mips64r3", NanLegacy | Nan2008)
5869 .Case("mips64r5", NanLegacy | Nan2008)
5870 .Case("mips64r6", Nan2008)
5871 .Default(NanLegacy);
5872}
5873
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005874bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5875 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5876 return A && (A->getValue() == StringRef(Value));
5877}
5878
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005879bool mips::isUCLibc(const ArgList &Args) {
5880 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005881 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005882}
5883
Daniel Sanders2bf13662014-07-10 14:40:57 +00005884bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005885 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5886 return llvm::StringSwitch<bool>(NaNArg->getValue())
5887 .Case("2008", true)
5888 .Case("legacy", false)
5889 .Default(false);
5890
5891 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005892 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5893 .Cases("mips32r6", "mips64r6", true)
5894 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005895
5896 return false;
5897}
5898
Daniel Sanders379d44b2014-07-16 11:52:23 +00005899bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5900 StringRef ABIName) {
5901 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005902 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005903 return false;
5904
5905 if (ABIName != "32")
5906 return false;
5907
5908 return llvm::StringSwitch<bool>(CPUName)
5909 .Cases("mips2", "mips3", "mips4", "mips5", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005910 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
5911 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005912 .Default(false);
5913}
5914
Tim Northover157d9112014-01-16 08:48:16 +00005915llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005916 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5917 // archs which Darwin doesn't use.
5918
5919 // The matching this routine does is fairly pointless, since it is neither the
5920 // complete architecture list, nor a reasonable subset. The problem is that
5921 // historically the driver driver accepts this and also ties its -march=
5922 // handling to the architecture name, so we need to be careful before removing
5923 // support for it.
5924
5925 // This code must be kept in sync with Clang's Darwin specific argument
5926 // translation.
5927
5928 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5929 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5930 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5931 .Case("ppc64", llvm::Triple::ppc64)
5932 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5933 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5934 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005935 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005936 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005937 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005938 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005939 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005940 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005941 .Case("r600", llvm::Triple::r600)
Tom Stellardd8e38a32015-01-06 20:34:47 +00005942 .Case("amdgcn", llvm::Triple::amdgcn)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005943 .Case("nvptx", llvm::Triple::nvptx)
5944 .Case("nvptx64", llvm::Triple::nvptx64)
5945 .Case("amdil", llvm::Triple::amdil)
5946 .Case("spir", llvm::Triple::spir)
5947 .Default(llvm::Triple::UnknownArch);
5948}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005949
Tim Northover157d9112014-01-16 08:48:16 +00005950void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005951 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00005952 T.setArch(Arch);
5953
5954 if (Str == "x86_64h")
5955 T.setArchName(Str);
5956 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5957 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005958 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005959 }
5960}
5961
Bob Wilsondecc03e2012-11-23 06:14:39 +00005962const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00005963 const InputInfo &Input) {
5964 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005965}
5966
Bob Wilsondecc03e2012-11-23 06:14:39 +00005967const char *Clang::getBaseInputStem(const ArgList &Args,
5968 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00005969 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005970
Chris Lattner906bb902011-01-16 08:14:11 +00005971 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005972 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005973
5974 return Str;
5975}
5976
Bob Wilsondecc03e2012-11-23 06:14:39 +00005977const char *Clang::getDependencyFileName(const ArgList &Args,
5978 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005979 // FIXME: Think about this more.
5980 std::string Res;
5981
5982 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005983 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005984 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005985 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005986 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005987 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005988 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005989}
5990
Ed Schouten3c3e58c2015-03-26 11:13:44 +00005991void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA,
5992 const InputInfo &Output,
5993 const InputInfoList &Inputs,
5994 const ArgList &Args,
5995 const char *LinkingOutput) const {
5996 const ToolChain &ToolChain = getToolChain();
5997 const Driver &D = ToolChain.getDriver();
5998 ArgStringList CmdArgs;
5999
6000 // Silence warning for "clang -g foo.o -o foo"
6001 Args.ClaimAllArgs(options::OPT_g_Group);
6002 // and "clang -emit-llvm foo.o -o foo"
6003 Args.ClaimAllArgs(options::OPT_emit_llvm);
6004 // and for "clang -w foo.o -o foo". Other warning options are already
6005 // handled somewhere else.
6006 Args.ClaimAllArgs(options::OPT_w);
6007
6008 if (!D.SysRoot.empty())
6009 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6010
6011 // CloudABI only supports static linkage.
6012 CmdArgs.push_back("-Bstatic");
6013 CmdArgs.push_back("--eh-frame-hdr");
6014 CmdArgs.push_back("--gc-sections");
6015
6016 if (Output.isFilename()) {
6017 CmdArgs.push_back("-o");
6018 CmdArgs.push_back(Output.getFilename());
6019 } else {
6020 assert(Output.isNothing() && "Invalid output.");
6021 }
6022
6023 if (!Args.hasArg(options::OPT_nostdlib) &&
6024 !Args.hasArg(options::OPT_nostartfiles)) {
6025 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
6026 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
6027 }
6028
6029 Args.AddAllArgs(CmdArgs, options::OPT_L);
6030 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
6031 for (const auto &Path : Paths)
6032 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
6033 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6034 Args.AddAllArgs(CmdArgs, options::OPT_e);
6035 Args.AddAllArgs(CmdArgs, options::OPT_s);
6036 Args.AddAllArgs(CmdArgs, options::OPT_t);
6037 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6038 Args.AddAllArgs(CmdArgs, options::OPT_r);
6039
6040 if (D.IsUsingLTO(ToolChain, Args))
6041 AddGoldPlugin(ToolChain, Args, CmdArgs);
6042
6043 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6044
6045 if (!Args.hasArg(options::OPT_nostdlib) &&
6046 !Args.hasArg(options::OPT_nodefaultlibs)) {
6047 if (D.CCCIsCXX())
6048 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6049 CmdArgs.push_back("-lc");
6050 CmdArgs.push_back("-lcompiler_rt");
6051 }
6052
6053 if (!Args.hasArg(options::OPT_nostdlib) &&
6054 !Args.hasArg(options::OPT_nostartfiles))
6055 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6056
6057 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
6058 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6059}
6060
Daniel Dunbarbe220842009-03-20 16:06:39 +00006061void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006062 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006063 const InputInfoList &Inputs,
6064 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00006065 const char *LinkingOutput) const {
6066 ArgStringList CmdArgs;
6067
6068 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6069 const InputInfo &Input = Inputs[0];
6070
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006071 // Determine the original source input.
6072 const Action *SourceAction = &JA;
6073 while (SourceAction->getKind() != Action::InputClass) {
6074 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6075 SourceAction = SourceAction->getInputs()[0];
6076 }
6077
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006078 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00006079 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00006080 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
6081 // FIXME: at run-time detect assembler capabilities or rely on version
6082 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006083 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00006084 const llvm::Triple &T(getToolChain().getTriple());
6085 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00006086 CmdArgs.push_back("-Q");
6087 }
Kevin Enderby319baa42013-11-18 23:30:29 +00006088
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006089 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00006090 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006091 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006092 if (Args.hasArg(options::OPT_gstabs))
6093 CmdArgs.push_back("--gstabs");
6094 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00006095 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006096 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006097
Daniel Dunbarbe220842009-03-20 16:06:39 +00006098 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00006099 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006100
Daniel Dunbar6d484762010-07-22 01:47:22 +00006101 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006102 if (getToolChain().getArch() == llvm::Triple::x86 ||
6103 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00006104 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6105 CmdArgs.push_back("-force_cpusubtype_ALL");
6106
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006107 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006108 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00006109 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00006110 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006111 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006112 CmdArgs.push_back("-static");
6113
Daniel Dunbarbe220842009-03-20 16:06:39 +00006114 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6115 options::OPT_Xassembler);
6116
6117 assert(Output.isFilename() && "Unexpected lipo output.");
6118 CmdArgs.push_back("-o");
6119 CmdArgs.push_back(Output.getFilename());
6120
Daniel Dunbarb440f562010-08-02 02:38:21 +00006121 assert(Input.isFilename() && "Invalid input.");
6122 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00006123
6124 // asm_final spec is empty.
6125
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006126 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006127 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006128 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00006129}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006130
Tim Northover157d9112014-01-16 08:48:16 +00006131void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00006132
Tim Northover157d9112014-01-16 08:48:16 +00006133void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6134 ArgStringList &CmdArgs) const {
6135 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006136
Daniel Dunbarc1964212009-03-26 16:23:12 +00006137 // Derived from darwin_arch spec.
6138 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006139 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006140
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006141 // FIXME: Is this needed anymore?
6142 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006143 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00006144}
6145
Bill Wendling3b2000f2012-10-02 18:02:50 +00006146bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
6147 // We only need to generate a temp path for LTO if we aren't compiling object
6148 // files. When compiling source files, we run 'dsymutil' after linking. We
6149 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006150 for (const auto &Input : Inputs)
6151 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00006152 return true;
6153
6154 return false;
6155}
6156
Daniel Dunbarccbc4522010-09-09 21:51:05 +00006157void darwin::Link::AddLinkArgs(Compilation &C,
6158 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00006159 ArgStringList &CmdArgs,
6160 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006161 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00006162 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00006163
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006164 unsigned Version[3] = { 0, 0, 0 };
6165 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6166 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00006167 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006168 Version[1], Version[2], HadExtra) ||
6169 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006170 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006171 << A->getAsString(Args);
6172 }
6173
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006174 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006175 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006176 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6177 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006178
Bob Wilson3d27dad2013-08-02 22:25:34 +00006179 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6180 CmdArgs.push_back("-export_dynamic");
6181
Bob Wilsonb111ec92015-03-02 19:01:14 +00006182 // If we are using App Extension restrictions, pass a flag to the linker
6183 // telling it that the compiled code has been audited.
6184 if (Args.hasFlag(options::OPT_fapplication_extension,
6185 options::OPT_fno_application_extension, false))
6186 CmdArgs.push_back("-application_extension");
6187
Bill Wendling313b6bf2012-11-16 23:03:00 +00006188 // If we are using LTO, then automatically create a temporary file path for
6189 // the linker to use, so that it's lifetime will extend past a possible
6190 // dsymutil step.
Peter Collingbournea4ccff32015-02-20 20:30:56 +00006191 if (Version[0] >= 116 && D.IsUsingLTO(getToolChain(), Args) &&
6192 NeedsTempPath(Inputs)) {
Bill Wendling313b6bf2012-11-16 23:03:00 +00006193 const char *TmpPath = C.getArgs().MakeArgString(
6194 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
6195 C.addTempFile(TmpPath);
6196 CmdArgs.push_back("-object_path_lto");
6197 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00006198 }
6199
Daniel Dunbarc1964212009-03-26 16:23:12 +00006200 // Derived from the "link" spec.
6201 Args.AddAllArgs(CmdArgs, options::OPT_static);
6202 if (!Args.hasArg(options::OPT_static))
6203 CmdArgs.push_back("-dynamic");
6204 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6205 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6206 // here. How do we wish to handle such things?
6207 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006208
Daniel Dunbarc1964212009-03-26 16:23:12 +00006209 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00006210 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00006211 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00006212 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006213
6214 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6215 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6216 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6217
6218 Arg *A;
6219 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6220 (A = Args.getLastArg(options::OPT_current__version)) ||
6221 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006222 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006223 << A->getAsString(Args) << "-dynamiclib";
6224
6225 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6226 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6227 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6228 } else {
6229 CmdArgs.push_back("-dylib");
6230
6231 Arg *A;
6232 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6233 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6234 (A = Args.getLastArg(options::OPT_client__name)) ||
6235 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6236 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6237 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006238 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006239 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006240
Daniel Dunbarc1964212009-03-26 16:23:12 +00006241 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6242 "-dylib_compatibility_version");
6243 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6244 "-dylib_current_version");
6245
Tim Northover157d9112014-01-16 08:48:16 +00006246 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006247
6248 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6249 "-dylib_install_name");
6250 }
6251
6252 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6253 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6254 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006255 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006256 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006257 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6258 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6259 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6260 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6261 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6262 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006263 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006264 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6265 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6266 Args.AddAllArgs(CmdArgs, options::OPT_init);
6267
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006268 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006269 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006270
Daniel Dunbarc1964212009-03-26 16:23:12 +00006271 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6272 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6273 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6274 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6275 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006276
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006277 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6278 options::OPT_fno_pie,
6279 options::OPT_fno_PIE)) {
6280 if (A->getOption().matches(options::OPT_fpie) ||
6281 A->getOption().matches(options::OPT_fPIE))
6282 CmdArgs.push_back("-pie");
6283 else
6284 CmdArgs.push_back("-no_pie");
6285 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006286
6287 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6288 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6289 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6290 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6291 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6292 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6293 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6294 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6295 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6296 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6297 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6298 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6299 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6300 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6301 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6302 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006303
Daniel Dunbar84384642011-05-02 21:03:47 +00006304 // Give --sysroot= preference, over the Apple specific behavior to also use
6305 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006306 StringRef sysroot = C.getSysRoot();
6307 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006308 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006309 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006310 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6311 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006312 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006313 }
6314
Daniel Dunbarc1964212009-03-26 16:23:12 +00006315 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6316 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6317 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6318 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6319 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006320 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006321 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6322 Args.AddAllArgs(CmdArgs, options::OPT_y);
6323 Args.AddLastArg(CmdArgs, options::OPT_w);
6324 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6325 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6326 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6327 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6328 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6329 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6330 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6331 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6332 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6333 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6334 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6335 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6336}
6337
6338void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006339 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006340 const InputInfoList &Inputs,
6341 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00006342 const char *LinkingOutput) const {
6343 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006344
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006345 // If the number of arguments surpasses the system limits, we will encode the
6346 // input files in a separate file, shortening the command line. To this end,
6347 // build a list of input file names that can be passed via a file with the
6348 // -filelist linker option.
6349 llvm::opt::ArgStringList InputFileList;
6350
Daniel Dunbarc1964212009-03-26 16:23:12 +00006351 // The logic here is derived from gcc's behavior; most of which
6352 // comes from specs (starting with link_command). Consult gcc for
6353 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006354 ArgStringList CmdArgs;
6355
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006356 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6357 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6358 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006359 for (const auto &Arg : Args)
6360 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006361 const char *Exec =
6362 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
6363 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00006364 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006365 return;
6366 }
6367
Daniel Dunbarc1964212009-03-26 16:23:12 +00006368 // I'm not sure why this particular decomposition exists in gcc, but
6369 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006370 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006371
Daniel Dunbarc1964212009-03-26 16:23:12 +00006372 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6373 Args.AddAllArgs(CmdArgs, options::OPT_s);
6374 Args.AddAllArgs(CmdArgs, options::OPT_t);
6375 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6376 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006377 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006378 Args.AddAllArgs(CmdArgs, options::OPT_r);
6379
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006380 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6381 // members of static archive libraries which implement Objective-C classes or
6382 // categories.
6383 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6384 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006385
Daniel Dunbarc1964212009-03-26 16:23:12 +00006386 CmdArgs.push_back("-o");
6387 CmdArgs.push_back(Output.getFilename());
6388
Chad Rosier06fd3c62012-05-16 23:45:12 +00006389 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006390 !Args.hasArg(options::OPT_nostartfiles))
6391 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006392
6393 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006394
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006395 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6396 options::OPT_fno_openmp, false)) {
6397 switch (getOpenMPRuntime(getToolChain(), Args)) {
6398 case OMPRT_OMP:
6399 CmdArgs.push_back("-lomp");
6400 break;
6401 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00006402 CmdArgs.push_back("-lgomp");
6403 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006404 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00006405 CmdArgs.push_back("-liomp5");
6406 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006407 case OMPRT_Unknown:
6408 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00006409 break;
6410 }
Alexey Bataev186b28a2014-03-06 05:43:53 +00006411 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006412
Douglas Gregor9295df02012-05-15 21:00:27 +00006413 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006414 // Build the input file for -filelist (list of linker input files) in case we
6415 // need it later
6416 for (const auto &II : Inputs) {
6417 if (!II.isFilename()) {
6418 // This is a linker input argument.
6419 // We cannot mix input arguments and file names in a -filelist input, thus
6420 // we prematurely stop our list (remaining files shall be passed as
6421 // arguments).
6422 if (InputFileList.size() > 0)
6423 break;
6424
6425 continue;
6426 }
6427
6428 InputFileList.push_back(II.getFilename());
6429 }
6430
Bob Wilson16d93952012-05-15 18:57:39 +00006431 if (isObjCRuntimeLinked(Args) &&
6432 !Args.hasArg(options::OPT_nostdlib) &&
6433 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006434 // We use arclite library for both ARC and subscripting support.
6435 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6436
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006437 CmdArgs.push_back("-framework");
6438 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006439 // Link libobj.
6440 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006441 }
John McCall31168b02011-06-15 23:02:42 +00006442
Daniel Dunbarc1964212009-03-26 16:23:12 +00006443 if (LinkingOutput) {
6444 CmdArgs.push_back("-arch_multiple");
6445 CmdArgs.push_back("-final_output");
6446 CmdArgs.push_back(LinkingOutput);
6447 }
6448
Daniel Dunbarc1964212009-03-26 16:23:12 +00006449 if (Args.hasArg(options::OPT_fnested_functions))
6450 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006451
Justin Bognerc7701242015-05-12 05:44:36 +00006452 // TODO: It would be nice to use addProfileRT() here, but darwin's compiler-rt
6453 // paths are different enough from other toolchains that this needs a fair
6454 // amount of refactoring done first.
6455 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6456
Daniel Dunbarc1964212009-03-26 16:23:12 +00006457 if (!Args.hasArg(options::OPT_nostdlib) &&
6458 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006459 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006460 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006461
Daniel Dunbarc1964212009-03-26 16:23:12 +00006462 // link_ssp spec is empty.
6463
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006464 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006465 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006466 }
6467
Chad Rosier06fd3c62012-05-16 23:45:12 +00006468 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006469 !Args.hasArg(options::OPT_nostartfiles)) {
6470 // endfile_spec is empty.
6471 }
6472
6473 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6474 Args.AddAllArgs(CmdArgs, options::OPT_F);
6475
Steven Wu3ffb61b2015-02-06 18:08:29 +00006476 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00006477 for (const Arg *A : Args.filtered(options::OPT_iframework))
6478 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00006479
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006480 if (!Args.hasArg(options::OPT_nostdlib) &&
6481 !Args.hasArg(options::OPT_nodefaultlibs)) {
6482 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6483 if (A->getValue() == StringRef("Accelerate")) {
6484 CmdArgs.push_back("-framework");
6485 CmdArgs.push_back("Accelerate");
6486 }
6487 }
6488 }
6489
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006490 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006491 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006492 std::unique_ptr<Command> Cmd =
6493 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
6494 Cmd->setInputFileList(std::move(InputFileList));
6495 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006496}
6497
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006498void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006499 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006500 const InputInfoList &Inputs,
6501 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006502 const char *LinkingOutput) const {
6503 ArgStringList CmdArgs;
6504
6505 CmdArgs.push_back("-create");
6506 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006507
6508 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006509 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006510
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006511 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006512 assert(II.isFilename() && "Unexpected lipo input.");
6513 CmdArgs.push_back(II.getFilename());
6514 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006515
6516 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00006517 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006518}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006519
Daniel Dunbar88299622010-06-04 18:28:36 +00006520void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006521 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00006522 const InputInfoList &Inputs,
6523 const ArgList &Args,
6524 const char *LinkingOutput) const {
6525 ArgStringList CmdArgs;
6526
Daniel Dunbareb86b042011-05-09 17:23:16 +00006527 CmdArgs.push_back("-o");
6528 CmdArgs.push_back(Output.getFilename());
6529
Daniel Dunbar88299622010-06-04 18:28:36 +00006530 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6531 const InputInfo &Input = Inputs[0];
6532 assert(Input.isFilename() && "Unexpected dsymutil input.");
6533 CmdArgs.push_back(Input.getFilename());
6534
Daniel Dunbar88299622010-06-04 18:28:36 +00006535 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006536 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00006537 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006538}
6539
Eric Christopher551ef452011-08-23 17:56:55 +00006540void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006541 const InputInfo &Output,
6542 const InputInfoList &Inputs,
6543 const ArgList &Args,
6544 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006545 ArgStringList CmdArgs;
6546 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006547 CmdArgs.push_back("--debug-info");
6548 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006549 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006550
6551 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6552 const InputInfo &Input = Inputs[0];
6553 assert(Input.isFilename() && "Unexpected verify input");
6554
6555 // Grabbing the output of the earlier dsymutil run.
6556 CmdArgs.push_back(Input.getFilename());
6557
6558 const char *Exec =
6559 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00006560 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006561}
6562
David Chisnallf571cde2012-02-15 13:39:01 +00006563void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6564 const InputInfo &Output,
6565 const InputInfoList &Inputs,
6566 const ArgList &Args,
6567 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006568 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006569 ArgStringList CmdArgs;
6570
6571 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6572 options::OPT_Xassembler);
6573
6574 CmdArgs.push_back("-o");
6575 CmdArgs.push_back(Output.getFilename());
6576
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006577 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006578 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006579
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006580 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006581 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006582}
6583
David Chisnallf571cde2012-02-15 13:39:01 +00006584void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6585 const InputInfo &Output,
6586 const InputInfoList &Inputs,
6587 const ArgList &Args,
6588 const char *LinkingOutput) const {
6589 // FIXME: Find a real GCC, don't hard-code versions here
6590 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6591 const llvm::Triple &T = getToolChain().getTriple();
6592 std::string LibPath = "/usr/lib/";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006593 const llvm::Triple::ArchType Arch = T.getArch();
David Chisnallf571cde2012-02-15 13:39:01 +00006594 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006595 case llvm::Triple::x86:
6596 GCCLibPath +=
6597 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6598 break;
6599 case llvm::Triple::x86_64:
6600 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6601 GCCLibPath += "/4.5.2/amd64/";
6602 LibPath += "amd64/";
6603 break;
6604 default:
6605 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006606 }
6607
6608 ArgStringList CmdArgs;
6609
David Chisnall272a0712012-02-29 15:06:12 +00006610 // Demangle C++ names in errors
6611 CmdArgs.push_back("-C");
6612
David Chisnallf571cde2012-02-15 13:39:01 +00006613 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6614 (!Args.hasArg(options::OPT_shared))) {
6615 CmdArgs.push_back("-e");
6616 CmdArgs.push_back("_start");
6617 }
6618
6619 if (Args.hasArg(options::OPT_static)) {
6620 CmdArgs.push_back("-Bstatic");
6621 CmdArgs.push_back("-dn");
6622 } else {
6623 CmdArgs.push_back("-Bdynamic");
6624 if (Args.hasArg(options::OPT_shared)) {
6625 CmdArgs.push_back("-shared");
6626 } else {
6627 CmdArgs.push_back("--dynamic-linker");
6628 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6629 }
6630 }
6631
6632 if (Output.isFilename()) {
6633 CmdArgs.push_back("-o");
6634 CmdArgs.push_back(Output.getFilename());
6635 } else {
6636 assert(Output.isNothing() && "Invalid output.");
6637 }
6638
6639 if (!Args.hasArg(options::OPT_nostdlib) &&
6640 !Args.hasArg(options::OPT_nostartfiles)) {
6641 if (!Args.hasArg(options::OPT_shared)) {
6642 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6643 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006644 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006645 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6646 } else {
6647 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006648 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6649 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006650 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006651 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006652 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006653 }
6654
6655 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6656
6657 Args.AddAllArgs(CmdArgs, options::OPT_L);
6658 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6659 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006660 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006661
6662 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6663
6664 if (!Args.hasArg(options::OPT_nostdlib) &&
6665 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006666 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006667 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006668 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006669 if (!Args.hasArg(options::OPT_shared)) {
6670 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006671 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006672 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006673 }
David Chisnallf571cde2012-02-15 13:39:01 +00006674 }
6675
6676 if (!Args.hasArg(options::OPT_nostdlib) &&
6677 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006678 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006679 }
David Chisnall96de9932012-02-16 16:00:47 +00006680 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006681
Alexey Samsonov7811d192014-02-20 13:57:37 +00006682 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006683
6684 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006685 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006686 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006687}
6688
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006689void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006690 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006691 const InputInfoList &Inputs,
6692 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006693 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006694 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006695 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006696 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006697
Rafael Espindolacc126272014-02-28 01:55:21 +00006698 switch (getToolChain().getArch()) {
6699 case llvm::Triple::x86:
6700 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6701 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006702 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006703 break;
6704
6705 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006706 CmdArgs.push_back("-mppc");
6707 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006708 break;
6709
6710 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006711 case llvm::Triple::sparcel:
Rafael Espindolacc126272014-02-28 01:55:21 +00006712 CmdArgs.push_back("-32");
6713 NeedsKPIC = true;
6714 break;
6715
6716 case llvm::Triple::sparcv9:
6717 CmdArgs.push_back("-64");
6718 CmdArgs.push_back("-Av9a");
6719 NeedsKPIC = true;
6720 break;
6721
6722 case llvm::Triple::mips64:
6723 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006724 StringRef CPUName;
6725 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006726 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006727
6728 CmdArgs.push_back("-mabi");
6729 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6730
6731 if (getToolChain().getArch() == llvm::Triple::mips64)
6732 CmdArgs.push_back("-EB");
6733 else
6734 CmdArgs.push_back("-EL");
6735
Rafael Espindolacc126272014-02-28 01:55:21 +00006736 NeedsKPIC = true;
6737 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006738 }
6739
Rafael Espindolacc126272014-02-28 01:55:21 +00006740 default:
6741 break;
6742 }
6743
6744 if (NeedsKPIC)
6745 addAssemblerKPIC(Args, CmdArgs);
6746
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006747 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6748 options::OPT_Xassembler);
6749
6750 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006751 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006752
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006753 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006754 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006755
6756 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006757 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006758 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006759}
6760
6761void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006762 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006763 const InputInfoList &Inputs,
6764 const ArgList &Args,
6765 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006766 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006767 ArgStringList CmdArgs;
6768
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006769 // Silence warning for "clang -g foo.o -o foo"
6770 Args.ClaimAllArgs(options::OPT_g_Group);
6771 // and "clang -emit-llvm foo.o -o foo"
6772 Args.ClaimAllArgs(options::OPT_emit_llvm);
6773 // and for "clang -w foo.o -o foo". Other warning options are already
6774 // handled somewhere else.
6775 Args.ClaimAllArgs(options::OPT_w);
6776
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006777 if (getToolChain().getArch() == llvm::Triple::mips64)
6778 CmdArgs.push_back("-EB");
6779 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6780 CmdArgs.push_back("-EL");
6781
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006782 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006783 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006784 CmdArgs.push_back("-e");
6785 CmdArgs.push_back("__start");
6786 }
6787
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006788 if (Args.hasArg(options::OPT_static)) {
6789 CmdArgs.push_back("-Bstatic");
6790 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006791 if (Args.hasArg(options::OPT_rdynamic))
6792 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006793 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006794 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006795 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006796 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006797 } else {
6798 CmdArgs.push_back("-dynamic-linker");
6799 CmdArgs.push_back("/usr/libexec/ld.so");
6800 }
6801 }
6802
Rafael Espindola044f7832013-06-05 04:28:55 +00006803 if (Args.hasArg(options::OPT_nopie))
6804 CmdArgs.push_back("-nopie");
6805
Daniel Dunbarb440f562010-08-02 02:38:21 +00006806 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006807 CmdArgs.push_back("-o");
6808 CmdArgs.push_back(Output.getFilename());
6809 } else {
6810 assert(Output.isNothing() && "Invalid output.");
6811 }
6812
6813 if (!Args.hasArg(options::OPT_nostdlib) &&
6814 !Args.hasArg(options::OPT_nostartfiles)) {
6815 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006816 if (Args.hasArg(options::OPT_pg))
6817 CmdArgs.push_back(Args.MakeArgString(
6818 getToolChain().GetFilePath("gcrt0.o")));
6819 else
6820 CmdArgs.push_back(Args.MakeArgString(
6821 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006822 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006823 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006824 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006825 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006826 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006827 }
6828 }
6829
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006830 std::string Triple = getToolChain().getTripleString();
6831 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006832 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006833 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006834 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006835
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006836 Args.AddAllArgs(CmdArgs, options::OPT_L);
6837 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6838 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006839 Args.AddAllArgs(CmdArgs, options::OPT_s);
6840 Args.AddAllArgs(CmdArgs, options::OPT_t);
6841 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6842 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006843
Daniel Dunbar54423b22010-09-17 00:24:54 +00006844 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006845
6846 if (!Args.hasArg(options::OPT_nostdlib) &&
6847 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006848 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006849 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006850 if (Args.hasArg(options::OPT_pg))
6851 CmdArgs.push_back("-lm_p");
6852 else
6853 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006854 }
6855
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006856 // FIXME: For some reason GCC passes -lgcc before adding
6857 // the default system libraries. Just mimic this for now.
6858 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006859
Eric Christopher17674ec2012-09-13 06:32:34 +00006860 if (Args.hasArg(options::OPT_pthread)) {
6861 if (!Args.hasArg(options::OPT_shared) &&
6862 Args.hasArg(options::OPT_pg))
6863 CmdArgs.push_back("-lpthread_p");
6864 else
6865 CmdArgs.push_back("-lpthread");
6866 }
6867
Chandler Carruth45661652011-12-17 22:32:42 +00006868 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006869 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006870 CmdArgs.push_back("-lc_p");
6871 else
6872 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006873 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006874
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006875 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006876 }
6877
6878 if (!Args.hasArg(options::OPT_nostdlib) &&
6879 !Args.hasArg(options::OPT_nostartfiles)) {
6880 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006881 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006882 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006883 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006884 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006885 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006886 }
6887
6888 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006889 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006890 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006891}
Ed Schoutene33194b2009-04-02 19:13:12 +00006892
Eli Friedman9fa28852012-08-08 23:57:20 +00006893void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6894 const InputInfo &Output,
6895 const InputInfoList &Inputs,
6896 const ArgList &Args,
6897 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006898 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00006899 ArgStringList CmdArgs;
6900
6901 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6902 options::OPT_Xassembler);
6903
6904 CmdArgs.push_back("-o");
6905 CmdArgs.push_back(Output.getFilename());
6906
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006907 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006908 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006909
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006910 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006911 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006912}
6913
6914void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6915 const InputInfo &Output,
6916 const InputInfoList &Inputs,
6917 const ArgList &Args,
6918 const char *LinkingOutput) const {
6919 const Driver &D = getToolChain().getDriver();
6920 ArgStringList CmdArgs;
6921
6922 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6923 (!Args.hasArg(options::OPT_shared))) {
6924 CmdArgs.push_back("-e");
6925 CmdArgs.push_back("__start");
6926 }
6927
6928 if (Args.hasArg(options::OPT_static)) {
6929 CmdArgs.push_back("-Bstatic");
6930 } else {
6931 if (Args.hasArg(options::OPT_rdynamic))
6932 CmdArgs.push_back("-export-dynamic");
6933 CmdArgs.push_back("--eh-frame-hdr");
6934 CmdArgs.push_back("-Bdynamic");
6935 if (Args.hasArg(options::OPT_shared)) {
6936 CmdArgs.push_back("-shared");
6937 } else {
6938 CmdArgs.push_back("-dynamic-linker");
6939 CmdArgs.push_back("/usr/libexec/ld.so");
6940 }
6941 }
6942
6943 if (Output.isFilename()) {
6944 CmdArgs.push_back("-o");
6945 CmdArgs.push_back(Output.getFilename());
6946 } else {
6947 assert(Output.isNothing() && "Invalid output.");
6948 }
6949
6950 if (!Args.hasArg(options::OPT_nostdlib) &&
6951 !Args.hasArg(options::OPT_nostartfiles)) {
6952 if (!Args.hasArg(options::OPT_shared)) {
6953 if (Args.hasArg(options::OPT_pg))
6954 CmdArgs.push_back(Args.MakeArgString(
6955 getToolChain().GetFilePath("gcrt0.o")));
6956 else
6957 CmdArgs.push_back(Args.MakeArgString(
6958 getToolChain().GetFilePath("crt0.o")));
6959 CmdArgs.push_back(Args.MakeArgString(
6960 getToolChain().GetFilePath("crtbegin.o")));
6961 } else {
6962 CmdArgs.push_back(Args.MakeArgString(
6963 getToolChain().GetFilePath("crtbeginS.o")));
6964 }
6965 }
6966
6967 Args.AddAllArgs(CmdArgs, options::OPT_L);
6968 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6969 Args.AddAllArgs(CmdArgs, options::OPT_e);
6970
6971 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6972
6973 if (!Args.hasArg(options::OPT_nostdlib) &&
6974 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006975 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006976 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6977 if (Args.hasArg(options::OPT_pg))
6978 CmdArgs.push_back("-lm_p");
6979 else
6980 CmdArgs.push_back("-lm");
6981 }
6982
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006983 if (Args.hasArg(options::OPT_pthread)) {
6984 if (!Args.hasArg(options::OPT_shared) &&
6985 Args.hasArg(options::OPT_pg))
6986 CmdArgs.push_back("-lpthread_p");
6987 else
6988 CmdArgs.push_back("-lpthread");
6989 }
6990
Eli Friedman9fa28852012-08-08 23:57:20 +00006991 if (!Args.hasArg(options::OPT_shared)) {
6992 if (Args.hasArg(options::OPT_pg))
6993 CmdArgs.push_back("-lc_p");
6994 else
6995 CmdArgs.push_back("-lc");
6996 }
6997
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006998 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006999 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00007000 case llvm::Triple::arm:
7001 MyArch = "arm";
7002 break;
7003 case llvm::Triple::x86:
7004 MyArch = "i386";
7005 break;
7006 case llvm::Triple::x86_64:
7007 MyArch = "amd64";
7008 break;
7009 default:
7010 llvm_unreachable("Unsupported architecture");
7011 }
7012 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00007013 }
7014
7015 if (!Args.hasArg(options::OPT_nostdlib) &&
7016 !Args.hasArg(options::OPT_nostartfiles)) {
7017 if (!Args.hasArg(options::OPT_shared))
7018 CmdArgs.push_back(Args.MakeArgString(
7019 getToolChain().GetFilePath("crtend.o")));
7020 else
7021 CmdArgs.push_back(Args.MakeArgString(
7022 getToolChain().GetFilePath("crtendS.o")));
7023 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00007024
7025 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007026 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007027 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007028}
7029
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007030void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007031 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007032 const InputInfoList &Inputs,
7033 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00007034 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007035 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007036 ArgStringList CmdArgs;
7037
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007038 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7039 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007040 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007041 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007042 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00007043 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007044 else if (getToolChain().getArch() == llvm::Triple::mips ||
7045 getToolChain().getArch() == llvm::Triple::mipsel ||
7046 getToolChain().getArch() == llvm::Triple::mips64 ||
7047 getToolChain().getArch() == llvm::Triple::mips64el) {
7048 StringRef CPUName;
7049 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007050 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007051
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007052 CmdArgs.push_back("-march");
7053 CmdArgs.push_back(CPUName.data());
7054
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007055 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00007056 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007057
7058 if (getToolChain().getArch() == llvm::Triple::mips ||
7059 getToolChain().getArch() == llvm::Triple::mips64)
7060 CmdArgs.push_back("-EB");
7061 else
7062 CmdArgs.push_back("-EL");
7063
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007064 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007065 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007066 getToolChain().getArch() == llvm::Triple::armeb ||
7067 getToolChain().getArch() == llvm::Triple::thumb ||
7068 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00007069 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007070 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00007071 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
7072
7073 if (FloatABI == "hard") {
7074 CmdArgs.push_back("-mfpu=vfp");
7075 } else {
7076 CmdArgs.push_back("-mfpu=softvfp");
7077 }
7078
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007079 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00007080 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007081 case llvm::Triple::GNUEABI:
7082 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00007083 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007084 break;
7085
7086 default:
7087 CmdArgs.push_back("-matpcs");
7088 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00007089 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007090 getToolChain().getArch() == llvm::Triple::sparcel ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00007091 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00007092 if (getToolChain().getArch() == llvm::Triple::sparc)
7093 CmdArgs.push_back("-Av8plusa");
7094 else
7095 CmdArgs.push_back("-Av9a");
7096
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007097 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007098 }
Eric Christopher0b26a612010-03-02 02:41:08 +00007099
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007100 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7101 options::OPT_Xassembler);
7102
7103 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007104 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007105
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007106 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007107 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007108
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007109 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007110 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007111}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007112
7113void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007114 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007115 const InputInfoList &Inputs,
7116 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00007117 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007118 const toolchains::FreeBSD &ToolChain =
7119 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00007120 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007121 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007122 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007123 !Args.hasArg(options::OPT_shared) &&
7124 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007125 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00007126
7127 // Silence warning for "clang -g foo.o -o foo"
7128 Args.ClaimAllArgs(options::OPT_g_Group);
7129 // and "clang -emit-llvm foo.o -o foo"
7130 Args.ClaimAllArgs(options::OPT_emit_llvm);
7131 // and for "clang -w foo.o -o foo". Other warning options are already
7132 // handled somewhere else.
7133 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007134
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007135 if (!D.SysRoot.empty())
7136 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7137
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007138 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007139 CmdArgs.push_back("-pie");
7140
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007141 if (Args.hasArg(options::OPT_static)) {
7142 CmdArgs.push_back("-Bstatic");
7143 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007144 if (Args.hasArg(options::OPT_rdynamic))
7145 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007146 CmdArgs.push_back("--eh-frame-hdr");
7147 if (Args.hasArg(options::OPT_shared)) {
7148 CmdArgs.push_back("-Bshareable");
7149 } else {
7150 CmdArgs.push_back("-dynamic-linker");
7151 CmdArgs.push_back("/libexec/ld-elf.so.1");
7152 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007153 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00007154 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7155 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7156 CmdArgs.push_back("--hash-style=both");
7157 }
7158 }
7159 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007160 }
7161
7162 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7163 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007164 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007165 CmdArgs.push_back("-m");
7166 CmdArgs.push_back("elf_i386_fbsd");
7167 }
7168
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007169 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00007170 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00007171 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00007172 }
7173
Daniel Dunbarb440f562010-08-02 02:38:21 +00007174 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007175 CmdArgs.push_back("-o");
7176 CmdArgs.push_back(Output.getFilename());
7177 } else {
7178 assert(Output.isNothing() && "Invalid output.");
7179 }
7180
7181 if (!Args.hasArg(options::OPT_nostdlib) &&
7182 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007183 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007184 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007185 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00007186 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007187 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007188 crt1 = "Scrt1.o";
7189 else
7190 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007191 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007192 if (crt1)
7193 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7194
7195 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7196
Craig Topper92fc2df2014-05-17 16:56:41 +00007197 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00007198 if (Args.hasArg(options::OPT_static))
7199 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007200 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007201 crtbegin = "crtbeginS.o";
7202 else
7203 crtbegin = "crtbegin.o";
7204
7205 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007206 }
7207
7208 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007209 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007210 for (const auto &Path : Paths)
7211 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007212 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7213 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00007214 Args.AddAllArgs(CmdArgs, options::OPT_s);
7215 Args.AddAllArgs(CmdArgs, options::OPT_t);
7216 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7217 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007218
Peter Collingbournea4ccff32015-02-20 20:30:56 +00007219 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007220 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00007221
Alexey Samsonov52550342014-09-15 19:58:40 +00007222 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00007223 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007224
7225 if (!Args.hasArg(options::OPT_nostdlib) &&
7226 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007227 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00007228 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00007229 if (Args.hasArg(options::OPT_pg))
7230 CmdArgs.push_back("-lm_p");
7231 else
7232 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007233 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007234 if (NeedsSanitizerDeps)
7235 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007236 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7237 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007238 if (Args.hasArg(options::OPT_pg))
7239 CmdArgs.push_back("-lgcc_p");
7240 else
7241 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007242 if (Args.hasArg(options::OPT_static)) {
7243 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007244 } else if (Args.hasArg(options::OPT_pg)) {
7245 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007246 } else {
7247 CmdArgs.push_back("--as-needed");
7248 CmdArgs.push_back("-lgcc_s");
7249 CmdArgs.push_back("--no-as-needed");
7250 }
7251
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007252 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007253 if (Args.hasArg(options::OPT_pg))
7254 CmdArgs.push_back("-lpthread_p");
7255 else
7256 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007257 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007258
Roman Divacky66f22762011-02-10 16:59:40 +00007259 if (Args.hasArg(options::OPT_pg)) {
7260 if (Args.hasArg(options::OPT_shared))
7261 CmdArgs.push_back("-lc");
7262 else
7263 CmdArgs.push_back("-lc_p");
7264 CmdArgs.push_back("-lgcc_p");
7265 } else {
7266 CmdArgs.push_back("-lc");
7267 CmdArgs.push_back("-lgcc");
7268 }
7269
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007270 if (Args.hasArg(options::OPT_static)) {
7271 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007272 } else if (Args.hasArg(options::OPT_pg)) {
7273 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007274 } else {
7275 CmdArgs.push_back("--as-needed");
7276 CmdArgs.push_back("-lgcc_s");
7277 CmdArgs.push_back("--no-as-needed");
7278 }
7279 }
7280
7281 if (!Args.hasArg(options::OPT_nostdlib) &&
7282 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007283 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007284 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007285 else
7286 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007287 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007288 }
7289
Alexey Samsonov7811d192014-02-20 13:57:37 +00007290 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007291
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007292 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007293 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007294 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007295}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007296
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007297void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7298 const InputInfo &Output,
7299 const InputInfoList &Inputs,
7300 const ArgList &Args,
7301 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007302 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007303 ArgStringList CmdArgs;
7304
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007305 // GNU as needs different flags for creating the correct output format
7306 // on architectures with different ABIs or optional feature sets.
7307 switch (getToolChain().getArch()) {
7308 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007309 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007310 break;
7311 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007312 case llvm::Triple::armeb:
7313 case llvm::Triple::thumb:
7314 case llvm::Triple::thumbeb: {
Gabor Ballabas208826c2015-06-04 17:56:32 +00007315 std::string MArch = arm::getARMTargetCPU(Args, getToolChain().getTriple());
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007316 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007317 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007318 }
7319
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007320 case llvm::Triple::mips:
7321 case llvm::Triple::mipsel:
7322 case llvm::Triple::mips64:
7323 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007324 StringRef CPUName;
7325 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007326 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007327
7328 CmdArgs.push_back("-march");
7329 CmdArgs.push_back(CPUName.data());
7330
7331 CmdArgs.push_back("-mabi");
7332 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7333
7334 if (getToolChain().getArch() == llvm::Triple::mips ||
7335 getToolChain().getArch() == llvm::Triple::mips64)
7336 CmdArgs.push_back("-EB");
7337 else
7338 CmdArgs.push_back("-EL");
7339
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007340 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007341 break;
7342 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007343
7344 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007345 case llvm::Triple::sparcel:
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007346 CmdArgs.push_back("-32");
7347 addAssemblerKPIC(Args, CmdArgs);
7348 break;
7349
7350 case llvm::Triple::sparcv9:
7351 CmdArgs.push_back("-64");
7352 CmdArgs.push_back("-Av9");
7353 addAssemblerKPIC(Args, CmdArgs);
7354 break;
7355
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007356 default:
7357 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007358 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007359
7360 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7361 options::OPT_Xassembler);
7362
7363 CmdArgs.push_back("-o");
7364 CmdArgs.push_back(Output.getFilename());
7365
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007366 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007367 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007368
David Chisnallddbd68f2011-09-27 22:03:18 +00007369 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00007370 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007371}
7372
7373void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
7374 const InputInfo &Output,
7375 const InputInfoList &Inputs,
7376 const ArgList &Args,
7377 const char *LinkingOutput) const {
7378 const Driver &D = getToolChain().getDriver();
7379 ArgStringList CmdArgs;
7380
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007381 if (!D.SysRoot.empty())
7382 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7383
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007384 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007385 if (Args.hasArg(options::OPT_static)) {
7386 CmdArgs.push_back("-Bstatic");
7387 } else {
7388 if (Args.hasArg(options::OPT_rdynamic))
7389 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007390 if (Args.hasArg(options::OPT_shared)) {
7391 CmdArgs.push_back("-Bshareable");
7392 } else {
7393 CmdArgs.push_back("-dynamic-linker");
7394 CmdArgs.push_back("/libexec/ld.elf_so");
7395 }
7396 }
7397
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007398 // Many NetBSD architectures support more than one ABI.
7399 // Determine the correct emulation for ld.
7400 switch (getToolChain().getArch()) {
7401 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007402 CmdArgs.push_back("-m");
7403 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007404 break;
7405 case llvm::Triple::arm:
7406 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007407 CmdArgs.push_back("-m");
7408 switch (getToolChain().getTriple().getEnvironment()) {
7409 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007410 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007411 CmdArgs.push_back("armelf_nbsd_eabi");
7412 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007413 case llvm::Triple::EABIHF:
7414 case llvm::Triple::GNUEABIHF:
7415 CmdArgs.push_back("armelf_nbsd_eabihf");
7416 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007417 default:
7418 CmdArgs.push_back("armelf_nbsd");
7419 break;
7420 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007421 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007422 case llvm::Triple::armeb:
7423 case llvm::Triple::thumbeb:
John Brawn94fd9632015-05-21 12:19:49 +00007424 arm::appendEBLinkFlags(Args, CmdArgs,
7425 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007426 CmdArgs.push_back("-m");
7427 switch (getToolChain().getTriple().getEnvironment()) {
7428 case llvm::Triple::EABI:
7429 case llvm::Triple::GNUEABI:
7430 CmdArgs.push_back("armelfb_nbsd_eabi");
7431 break;
7432 case llvm::Triple::EABIHF:
7433 case llvm::Triple::GNUEABIHF:
7434 CmdArgs.push_back("armelfb_nbsd_eabihf");
7435 break;
7436 default:
7437 CmdArgs.push_back("armelfb_nbsd");
7438 break;
7439 }
7440 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007441 case llvm::Triple::mips64:
7442 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007443 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007444 CmdArgs.push_back("-m");
7445 if (getToolChain().getArch() == llvm::Triple::mips64)
7446 CmdArgs.push_back("elf32btsmip");
7447 else
7448 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007449 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007450 CmdArgs.push_back("-m");
7451 if (getToolChain().getArch() == llvm::Triple::mips64)
7452 CmdArgs.push_back("elf64btsmip");
7453 else
7454 CmdArgs.push_back("elf64ltsmip");
7455 }
7456 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007457 case llvm::Triple::ppc:
7458 CmdArgs.push_back("-m");
7459 CmdArgs.push_back("elf32ppc_nbsd");
7460 break;
7461
7462 case llvm::Triple::ppc64:
7463 case llvm::Triple::ppc64le:
7464 CmdArgs.push_back("-m");
7465 CmdArgs.push_back("elf64ppc");
7466 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007467
7468 case llvm::Triple::sparc:
7469 CmdArgs.push_back("-m");
7470 CmdArgs.push_back("elf32_sparc");
7471 break;
7472
7473 case llvm::Triple::sparcv9:
7474 CmdArgs.push_back("-m");
7475 CmdArgs.push_back("elf64_sparc");
7476 break;
7477
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007478 default:
7479 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007480 }
7481
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007482 if (Output.isFilename()) {
7483 CmdArgs.push_back("-o");
7484 CmdArgs.push_back(Output.getFilename());
7485 } else {
7486 assert(Output.isNothing() && "Invalid output.");
7487 }
7488
7489 if (!Args.hasArg(options::OPT_nostdlib) &&
7490 !Args.hasArg(options::OPT_nostartfiles)) {
7491 if (!Args.hasArg(options::OPT_shared)) {
7492 CmdArgs.push_back(Args.MakeArgString(
7493 getToolChain().GetFilePath("crt0.o")));
7494 CmdArgs.push_back(Args.MakeArgString(
7495 getToolChain().GetFilePath("crti.o")));
7496 CmdArgs.push_back(Args.MakeArgString(
7497 getToolChain().GetFilePath("crtbegin.o")));
7498 } else {
7499 CmdArgs.push_back(Args.MakeArgString(
7500 getToolChain().GetFilePath("crti.o")));
7501 CmdArgs.push_back(Args.MakeArgString(
7502 getToolChain().GetFilePath("crtbeginS.o")));
7503 }
7504 }
7505
7506 Args.AddAllArgs(CmdArgs, options::OPT_L);
7507 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7508 Args.AddAllArgs(CmdArgs, options::OPT_e);
7509 Args.AddAllArgs(CmdArgs, options::OPT_s);
7510 Args.AddAllArgs(CmdArgs, options::OPT_t);
7511 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7512 Args.AddAllArgs(CmdArgs, options::OPT_r);
7513
7514 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7515
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007516 unsigned Major, Minor, Micro;
7517 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7518 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007519 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007520 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007521 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00007522 case llvm::Triple::arm:
7523 case llvm::Triple::armeb:
7524 case llvm::Triple::thumb:
7525 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007526 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007527 case llvm::Triple::ppc64:
7528 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007529 case llvm::Triple::x86:
7530 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007531 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007532 break;
7533 default:
7534 break;
7535 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007536 }
7537
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007538 if (!Args.hasArg(options::OPT_nostdlib) &&
7539 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007540 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007541 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7542 CmdArgs.push_back("-lm");
7543 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007544 if (Args.hasArg(options::OPT_pthread))
7545 CmdArgs.push_back("-lpthread");
7546 CmdArgs.push_back("-lc");
7547
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007548 if (useLibgcc) {
7549 if (Args.hasArg(options::OPT_static)) {
7550 // libgcc_eh depends on libc, so resolve as much as possible,
7551 // pull in any new requirements from libc and then get the rest
7552 // of libgcc.
7553 CmdArgs.push_back("-lgcc_eh");
7554 CmdArgs.push_back("-lc");
7555 CmdArgs.push_back("-lgcc");
7556 } else {
7557 CmdArgs.push_back("-lgcc");
7558 CmdArgs.push_back("--as-needed");
7559 CmdArgs.push_back("-lgcc_s");
7560 CmdArgs.push_back("--no-as-needed");
7561 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007562 }
7563 }
7564
7565 if (!Args.hasArg(options::OPT_nostdlib) &&
7566 !Args.hasArg(options::OPT_nostartfiles)) {
7567 if (!Args.hasArg(options::OPT_shared))
7568 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7569 "crtend.o")));
7570 else
7571 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7572 "crtendS.o")));
7573 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7574 "crtn.o")));
7575 }
7576
Alexey Samsonov7811d192014-02-20 13:57:37 +00007577 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007578
Logan Chieneb9162f2014-06-26 14:23:45 +00007579 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007580 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007581}
7582
Thomas Schwinge4e555262013-03-28 19:04:25 +00007583void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7584 const InputInfo &Output,
7585 const InputInfoList &Inputs,
7586 const ArgList &Args,
7587 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007588 claimNoWarnArgs(Args);
7589
Rafael Espindola92b00932010-08-10 00:25:48 +00007590 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007591 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007592
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007593 switch (getToolChain().getArch()) {
7594 default:
7595 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00007596 // Add --32/--64 to make sure we get the format we want.
7597 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007598 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00007599 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007600 break;
7601 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00007602 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7603 CmdArgs.push_back("--x32");
7604 else
7605 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007606 break;
7607 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007608 CmdArgs.push_back("-a32");
7609 CmdArgs.push_back("-mppc");
7610 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007611 break;
7612 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007613 CmdArgs.push_back("-a64");
7614 CmdArgs.push_back("-mppc64");
7615 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007616 break;
7617 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00007618 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007619 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007620 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007621 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007622 break;
7623 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007624 case llvm::Triple::sparcel:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007625 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007626 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007627 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007628 break;
7629 case llvm::Triple::sparcv9:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007630 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007631 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007632 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007633 break;
7634 case llvm::Triple::arm:
7635 case llvm::Triple::armeb:
7636 case llvm::Triple::thumb:
7637 case llvm::Triple::thumbeb: {
Scott Douglass3205f522015-03-23 10:54:24 +00007638 const llvm::Triple &Triple = getToolChain().getTriple();
7639 switch (Triple.getSubArch()) {
7640 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00007641 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00007642 break;
7643 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00007644 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00007645 break;
7646 default:
7647 break;
7648 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007649
Tim Northover9c7e0352013-12-12 11:55:52 +00007650 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
Derek Schuffa419e1c2015-04-10 23:07:19 +00007651 getToolChain().getDriver(), Args,
7652 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007653 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007654
7655 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007656
7657 // FIXME: remove krait check when GNU tools support krait cpu
7658 // for now replace it with -march=armv7-a to avoid a lower
7659 // march from being picked in the absence of a cpu flag.
7660 Arg *A;
7661 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Gabor Ballabas208826c2015-06-04 17:56:32 +00007662 StringRef(A->getValue()).lower() == "krait")
Ana Pazosdd6068d2013-12-06 22:43:17 +00007663 CmdArgs.push_back("-march=armv7-a");
7664 else
7665 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007666 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007667 break;
7668 }
7669 case llvm::Triple::mips:
7670 case llvm::Triple::mipsel:
7671 case llvm::Triple::mips64:
7672 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007673 StringRef CPUName;
7674 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007675 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007676 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007677
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007678 CmdArgs.push_back("-march");
7679 CmdArgs.push_back(CPUName.data());
7680
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007681 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007682 CmdArgs.push_back(ABIName.data());
7683
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007684 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7685 // or -mshared (not implemented) is in effect.
7686 bool IsPicOrPie = false;
7687 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7688 options::OPT_fpic, options::OPT_fno_pic,
7689 options::OPT_fPIE, options::OPT_fno_PIE,
7690 options::OPT_fpie, options::OPT_fno_pie)) {
7691 if (A->getOption().matches(options::OPT_fPIC) ||
7692 A->getOption().matches(options::OPT_fpic) ||
7693 A->getOption().matches(options::OPT_fPIE) ||
7694 A->getOption().matches(options::OPT_fpie))
7695 IsPicOrPie = true;
7696 }
7697 if (!IsPicOrPie)
7698 CmdArgs.push_back("-mno-shared");
7699
Daniel Sanders379d44b2014-07-16 11:52:23 +00007700 // LLVM doesn't support -mplt yet and acts as if it is always given.
7701 // However, -mplt has no effect with the N64 ABI.
7702 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007703
7704 if (getToolChain().getArch() == llvm::Triple::mips ||
7705 getToolChain().getArch() == llvm::Triple::mips64)
7706 CmdArgs.push_back("-EB");
7707 else
7708 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007709
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007710 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7711 if (StringRef(A->getValue()) == "2008")
7712 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7713 }
7714
Daniel Sanders379d44b2014-07-16 11:52:23 +00007715 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7716 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7717 options::OPT_mfp64)) {
7718 A->claim();
7719 A->render(Args, CmdArgs);
7720 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7721 ABIName))
7722 CmdArgs.push_back("-mfpxx");
7723
7724 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7725 // -mno-mips16 is actually -no-mips16.
7726 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7727 options::OPT_mno_mips16)) {
7728 if (A->getOption().matches(options::OPT_mips16)) {
7729 A->claim();
7730 A->render(Args, CmdArgs);
7731 } else {
7732 A->claim();
7733 CmdArgs.push_back("-no-mips16");
7734 }
7735 }
7736
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007737 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7738 options::OPT_mno_micromips);
7739 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7740 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7741
Simon Atanasyanbd986632013-11-26 11:58:04 +00007742 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7743 // Do not use AddLastArg because not all versions of MIPS assembler
7744 // support -mmsa / -mno-msa options.
7745 if (A->getOption().matches(options::OPT_mmsa))
7746 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7747 }
7748
Daniel Sanders379d44b2014-07-16 11:52:23 +00007749 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7750 options::OPT_msoft_float);
7751
Toma Tabacub36d6102015-06-11 12:13:18 +00007752 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
7753 options::OPT_msingle_float);
7754
Daniel Sanders379d44b2014-07-16 11:52:23 +00007755 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7756 options::OPT_mno_odd_spreg);
7757
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007758 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007759 break;
7760 }
7761 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007762 // Always pass an -march option, since our default of z10 is later
7763 // than the GNU assembler's default.
7764 StringRef CPUName = getSystemZTargetCPU(Args);
7765 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007766 break;
7767 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007768 }
7769
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007770 if (NeedsKPIC)
7771 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007772
7773 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7774 options::OPT_Xassembler);
7775
7776 CmdArgs.push_back("-o");
7777 CmdArgs.push_back(Output.getFilename());
7778
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007779 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007780 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007781
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007782 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007783 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007784
7785 // Handle the debug info splitting at object creation time if we're
7786 // creating an object.
7787 // TODO: Currently only works on linux with newer objcopy.
7788 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007789 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007790 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00007791 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00007792}
7793
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007794static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007795 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007796 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007797 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7798 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007799 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007800 CmdArgs.push_back("-lgcc");
7801
Logan Chien3d3373c2012-11-19 12:04:11 +00007802 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007803 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007804 CmdArgs.push_back("-lgcc");
7805 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007806 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007807 CmdArgs.push_back("--as-needed");
7808 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007809 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007810 CmdArgs.push_back("--no-as-needed");
7811 }
7812
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007813 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007814 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007815 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007816 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007817
7818 // According to Android ABI, we have to link with libdl if we are
7819 // linking with non-static libgcc.
7820 //
7821 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7822 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7823 if (isAndroid && !StaticLibgcc)
7824 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007825}
7826
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007827static std::string getLinuxDynamicLinker(const ArgList &Args,
7828 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007829 const llvm::Triple::ArchType Arch = ToolChain.getArch();
7830
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007831 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7832 if (ToolChain.getTriple().isArch64Bit())
7833 return "/system/bin/linker64";
7834 else
7835 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007836 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
7837 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007838 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007839 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007840 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007841 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007842 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007843 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007844 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7845 return "/lib/ld-linux-armhf.so.3";
7846 else
7847 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007848 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
7849 // TODO: check which dynamic linker name.
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007850 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007851 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007852 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007853 return "/lib/ld-linux.so.3";
7854 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
7855 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007856 StringRef CPUName;
7857 StringRef ABIName;
7858 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7859 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7860
7861 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7862 .Case("o32", "/lib")
7863 .Case("n32", "/lib32")
7864 .Case("n64", "/lib64")
7865 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007866 StringRef LibName;
7867 if (mips::isUCLibc(Args))
7868 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7869 else
7870 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007871
7872 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007873 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007874 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007875 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007876 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7877 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007878 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007879 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007880 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7881 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007882 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007883 } else if (Arch == llvm::Triple::systemz)
Ulrich Weigand8afad612014-07-28 13:17:52 +00007884 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007885 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007886 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007887 else if (Arch == llvm::Triple::x86_64 &&
Zinovy Nis1db95732014-07-10 15:27:19 +00007888 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7889 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007890 else
7891 return "/lib64/ld-linux-x86-64.so.2";
7892}
7893
Renato Golinc4b49242014-02-13 10:01:16 +00007894static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007895 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007896 // Make use of compiler-rt if --rtlib option is used
7897 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7898
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007899 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007900 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007901 switch (TC.getTriple().getOS()) {
7902 default: llvm_unreachable("unsupported OS");
7903 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007904 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007905 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007906 break;
7907 }
Renato Golinc4b49242014-02-13 10:01:16 +00007908 break;
7909 case ToolChain::RLT_Libgcc:
7910 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7911 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007912 }
7913}
7914
Rafael Espindola1e085772014-08-15 17:14:35 +00007915static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7916 switch (T.getArch()) {
7917 case llvm::Triple::x86:
7918 return "elf_i386";
7919 case llvm::Triple::aarch64:
7920 return "aarch64linux";
7921 case llvm::Triple::aarch64_be:
7922 return "aarch64_be_linux";
7923 case llvm::Triple::arm:
7924 case llvm::Triple::thumb:
7925 return "armelf_linux_eabi";
7926 case llvm::Triple::armeb:
7927 case llvm::Triple::thumbeb:
7928 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7929 case llvm::Triple::ppc:
7930 return "elf32ppclinux";
7931 case llvm::Triple::ppc64:
7932 return "elf64ppc";
7933 case llvm::Triple::ppc64le:
7934 return "elf64lppc";
7935 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007936 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00007937 return "elf32_sparc";
7938 case llvm::Triple::sparcv9:
7939 return "elf64_sparc";
7940 case llvm::Triple::mips:
7941 return "elf32btsmip";
7942 case llvm::Triple::mipsel:
7943 return "elf32ltsmip";
7944 case llvm::Triple::mips64:
7945 if (mips::hasMipsAbiArg(Args, "n32"))
7946 return "elf32btsmipn32";
7947 return "elf64btsmip";
7948 case llvm::Triple::mips64el:
7949 if (mips::hasMipsAbiArg(Args, "n32"))
7950 return "elf32ltsmipn32";
7951 return "elf64ltsmip";
7952 case llvm::Triple::systemz:
7953 return "elf64_s390";
7954 case llvm::Triple::x86_64:
7955 if (T.getEnvironment() == llvm::Triple::GNUX32)
7956 return "elf32_x86_64";
7957 return "elf_x86_64";
7958 default:
7959 llvm_unreachable("Unexpected arch");
7960 }
7961}
7962
Thomas Schwinge4e555262013-03-28 19:04:25 +00007963void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7964 const InputInfo &Output,
7965 const InputInfoList &Inputs,
7966 const ArgList &Args,
7967 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007968 const toolchains::Linux &ToolChain =
7969 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007970 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007971 const llvm::Triple::ArchType Arch = ToolChain.getArch();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007972 const bool isAndroid =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007973 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007974 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007975 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
7976 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007977
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007978 ArgStringList CmdArgs;
7979
Rafael Espindolad1002f62010-11-15 18:28:16 +00007980 // Silence warning for "clang -g foo.o -o foo"
7981 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007982 // and "clang -emit-llvm foo.o -o foo"
7983 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007984 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007985 // handled somewhere else.
7986 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007987
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007988 if (!D.SysRoot.empty())
7989 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007990
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007991 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007992 CmdArgs.push_back("-pie");
7993
Rafael Espindola1c76c592010-11-07 22:57:16 +00007994 if (Args.hasArg(options::OPT_rdynamic))
7995 CmdArgs.push_back("-export-dynamic");
7996
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007997 if (Args.hasArg(options::OPT_s))
7998 CmdArgs.push_back("-s");
7999
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008000 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
8001 arm::appendEBLinkFlags(
8002 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00008003 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00008004
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008005 for (const auto &Opt : ToolChain.ExtraOpts)
8006 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008007
8008 if (!Args.hasArg(options::OPT_static)) {
8009 CmdArgs.push_back("--eh-frame-hdr");
8010 }
8011
8012 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00008013 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008014
8015 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008016 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8017 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008018 CmdArgs.push_back("-Bstatic");
8019 else
8020 CmdArgs.push_back("-static");
8021 } else if (Args.hasArg(options::OPT_shared)) {
8022 CmdArgs.push_back("-shared");
8023 }
8024
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008025 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8026 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008027 (!Args.hasArg(options::OPT_static) &&
8028 !Args.hasArg(options::OPT_shared))) {
8029 CmdArgs.push_back("-dynamic-linker");
8030 CmdArgs.push_back(Args.MakeArgString(
8031 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
8032 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008033
8034 CmdArgs.push_back("-o");
8035 CmdArgs.push_back(Output.getFilename());
8036
Rafael Espindola81937ec2010-12-01 01:52:43 +00008037 if (!Args.hasArg(options::OPT_nostdlib) &&
8038 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008039 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008040 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008041 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00008042 if (Args.hasArg(options::OPT_pg))
8043 crt1 = "gcrt1.o";
8044 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008045 crt1 = "Scrt1.o";
8046 else
8047 crt1 = "crt1.o";
8048 }
8049 if (crt1)
8050 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008051
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008052 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8053 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008054
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008055 const char *crtbegin;
8056 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008057 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008058 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008059 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008060 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008061 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008062 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008063 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008064 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00008065
8066 // Add crtfastmath.o if available and fast math is enabled.
8067 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008068 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008069
8070 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00008071 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008072
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00008073 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008074
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008075 for (const auto &Path : Paths)
8076 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008077
Peter Collingbournea4ccff32015-02-20 20:30:56 +00008078 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00008079 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00008080
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00008081 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8082 CmdArgs.push_back("--no-demangle");
8083
Alexey Samsonov52550342014-09-15 19:58:40 +00008084 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008085 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008086 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00008087 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008088
Hans Wennborg70850d82013-07-18 20:29:38 +00008089 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00008090 !Args.hasArg(options::OPT_nostdlib) &&
8091 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00008092 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8093 !Args.hasArg(options::OPT_static);
8094 if (OnlyLibstdcxxStatic)
8095 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008096 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008097 if (OnlyLibstdcxxStatic)
8098 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008099 CmdArgs.push_back("-lm");
8100 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00008101 // Silence warnings when linking C code with a C++ '-stdlib' argument.
8102 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008103
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008104 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00008105 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8106 if (Args.hasArg(options::OPT_static))
8107 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00008108
Alexey Samsonov52550342014-09-15 19:58:40 +00008109 if (NeedsSanitizerDeps)
8110 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
8111
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008112 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8113 Args.hasArg(options::OPT_pthreads);
8114
8115 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8116 options::OPT_fno_openmp, false)) {
8117 // OpenMP runtimes implies pthreads when using the GNU toolchain.
8118 // FIXME: Does this really make sense for all GNU toolchains?
8119 WantPthread = true;
8120
8121 // Also link the particular OpenMP runtimes.
8122 switch (getOpenMPRuntime(ToolChain, Args)) {
8123 case OMPRT_OMP:
8124 CmdArgs.push_back("-lomp");
8125 break;
8126 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00008127 CmdArgs.push_back("-lgomp");
8128
8129 // FIXME: Exclude this for platforms with libgomp that don't require
8130 // librt. Most modern Linux platforms require it, but some may not.
8131 CmdArgs.push_back("-lrt");
8132 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008133 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00008134 CmdArgs.push_back("-liomp5");
8135 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008136 case OMPRT_Unknown:
8137 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00008138 break;
8139 }
Chandler Carruth01538002013-01-17 13:19:29 +00008140 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008141
Renato Golinc4b49242014-02-13 10:01:16 +00008142 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008143
Richard Smith31d1de22015-05-20 22:48:44 +00008144 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00008145 CmdArgs.push_back("-lpthread");
8146
8147 CmdArgs.push_back("-lc");
8148
8149 if (Args.hasArg(options::OPT_static))
8150 CmdArgs.push_back("--end-group");
8151 else
Renato Golinc4b49242014-02-13 10:01:16 +00008152 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00008153 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00008154
Rafael Espindola81937ec2010-12-01 01:52:43 +00008155 if (!Args.hasArg(options::OPT_nostartfiles)) {
8156 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008157 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008158 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008159 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008160 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00008161 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008162 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008163
Rafael Espindola81937ec2010-12-01 01:52:43 +00008164 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008165 if (!isAndroid)
8166 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00008167 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008168 }
8169
David Blaikiec11bf802014-09-04 16:04:28 +00008170 C.addCommand(
8171 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00008172}
8173
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008174
8175// NaCl ARM assembly (inline or standalone) can be written with a set of macros
8176// for the various SFI requirements like register masking. The assembly tool
8177// inserts the file containing the macros as an input into all the assembly
8178// jobs.
8179void nacltools::AssembleARM::ConstructJob(Compilation &C, const JobAction &JA,
8180 const InputInfo &Output,
8181 const InputInfoList &Inputs,
8182 const ArgList &Args,
8183 const char *LinkingOutput) const {
8184 const toolchains::NaCl_TC& ToolChain =
8185 static_cast<const toolchains::NaCl_TC&>(getToolChain());
8186 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8187 "nacl-arm-macros.s");
8188 InputInfoList NewInputs;
8189 NewInputs.push_back(NaClMacros);
8190 NewInputs.append(Inputs.begin(), Inputs.end());
8191 gnutools::Assemble::ConstructJob(C, JA, Output, NewInputs, Args,
8192 LinkingOutput);
8193}
8194
8195
8196// This is quite similar to gnutools::link::ConstructJob with changes that
8197// we use static by default, do not yet support sanitizers or LTO, and a few
8198// others. Eventually we can support more of that and hopefully migrate back
8199// to gnutools::link.
8200void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008201 const InputInfo &Output,
8202 const InputInfoList &Inputs,
8203 const ArgList &Args,
8204 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008205
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008206 const toolchains::NaCl_TC &ToolChain =
8207 static_cast<const toolchains::NaCl_TC &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008208 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008209 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008210 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008211 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008212
8213 ArgStringList CmdArgs;
8214
8215 // Silence warning for "clang -g foo.o -o foo"
8216 Args.ClaimAllArgs(options::OPT_g_Group);
8217 // and "clang -emit-llvm foo.o -o foo"
8218 Args.ClaimAllArgs(options::OPT_emit_llvm);
8219 // and for "clang -w foo.o -o foo". Other warning options are already
8220 // handled somewhere else.
8221 Args.ClaimAllArgs(options::OPT_w);
8222
8223 if (!D.SysRoot.empty())
8224 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8225
8226 if (Args.hasArg(options::OPT_rdynamic))
8227 CmdArgs.push_back("-export-dynamic");
8228
8229 if (Args.hasArg(options::OPT_s))
8230 CmdArgs.push_back("-s");
8231
8232 // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from
8233 // there is --build-id, which we do want.
8234 CmdArgs.push_back("--build-id");
8235
8236 if (!IsStatic)
8237 CmdArgs.push_back("--eh-frame-hdr");
8238
8239 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008240 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008241 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008242 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008243 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008244 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008245 CmdArgs.push_back("elf_x86_64_nacl");
8246 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008247 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8248 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008249
8250 if (IsStatic)
8251 CmdArgs.push_back("-static");
8252 else if (Args.hasArg(options::OPT_shared))
8253 CmdArgs.push_back("-shared");
8254
8255 CmdArgs.push_back("-o");
8256 CmdArgs.push_back(Output.getFilename());
8257 if (!Args.hasArg(options::OPT_nostdlib) &&
8258 !Args.hasArg(options::OPT_nostartfiles)) {
8259 if (!Args.hasArg(options::OPT_shared))
8260 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8261 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8262
8263 const char *crtbegin;
8264 if (IsStatic)
8265 crtbegin = "crtbeginT.o";
8266 else if (Args.hasArg(options::OPT_shared))
8267 crtbegin = "crtbeginS.o";
8268 else
8269 crtbegin = "crtbegin.o";
8270 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8271 }
8272
8273 Args.AddAllArgs(CmdArgs, options::OPT_L);
8274 Args.AddAllArgs(CmdArgs, options::OPT_u);
8275
8276 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8277
8278 for (const auto &Path : Paths)
8279 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8280
8281 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8282 CmdArgs.push_back("--no-demangle");
8283
8284 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8285
8286 if (D.CCCIsCXX() &&
8287 !Args.hasArg(options::OPT_nostdlib) &&
8288 !Args.hasArg(options::OPT_nodefaultlibs)) {
8289 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8290 !IsStatic;
8291 if (OnlyLibstdcxxStatic)
8292 CmdArgs.push_back("-Bstatic");
8293 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8294 if (OnlyLibstdcxxStatic)
8295 CmdArgs.push_back("-Bdynamic");
8296 CmdArgs.push_back("-lm");
8297 }
8298
8299 if (!Args.hasArg(options::OPT_nostdlib)) {
8300 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8301 // Always use groups, since it has no effect on dynamic libraries.
8302 CmdArgs.push_back("--start-group");
8303 CmdArgs.push_back("-lc");
8304 // NaCl's libc++ currently requires libpthread, so just always include it
8305 // in the group for C++.
8306 if (Args.hasArg(options::OPT_pthread) ||
8307 Args.hasArg(options::OPT_pthreads) ||
8308 D.CCCIsCXX()) {
8309 CmdArgs.push_back("-lpthread");
8310 }
8311
8312 CmdArgs.push_back("-lgcc");
8313 CmdArgs.push_back("--as-needed");
8314 if (IsStatic)
8315 CmdArgs.push_back("-lgcc_eh");
8316 else
8317 CmdArgs.push_back("-lgcc_s");
8318 CmdArgs.push_back("--no-as-needed");
8319 CmdArgs.push_back("--end-group");
8320 }
8321
8322 if (!Args.hasArg(options::OPT_nostartfiles)) {
8323 const char *crtend;
8324 if (Args.hasArg(options::OPT_shared))
8325 crtend = "crtendS.o";
8326 else
8327 crtend = "crtend.o";
8328
8329 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8330 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8331 }
8332 }
8333
8334 C.addCommand(llvm::make_unique<Command>(JA, *this,
8335 ToolChain.Linker.c_str(), CmdArgs));
8336}
8337
8338
Chris Lattner3e2ee142010-07-07 16:01:42 +00008339void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008340 const InputInfo &Output,
8341 const InputInfoList &Inputs,
8342 const ArgList &Args,
8343 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008344 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008345 ArgStringList CmdArgs;
8346
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008347 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008348
8349 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008350 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008351
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008352 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008353 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008354
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008355 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008356 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008357}
8358
8359void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008360 const InputInfo &Output,
8361 const InputInfoList &Inputs,
8362 const ArgList &Args,
8363 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008364 const Driver &D = getToolChain().getDriver();
8365 ArgStringList CmdArgs;
8366
Daniel Dunbarb440f562010-08-02 02:38:21 +00008367 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008368 CmdArgs.push_back("-o");
8369 CmdArgs.push_back(Output.getFilename());
8370 } else {
8371 assert(Output.isNothing() && "Invalid output.");
8372 }
8373
8374 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008375 !Args.hasArg(options::OPT_nostartfiles)) {
8376 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8377 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8378 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8379 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8380 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008381
8382 Args.AddAllArgs(CmdArgs, options::OPT_L);
8383 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8384 Args.AddAllArgs(CmdArgs, options::OPT_e);
8385
Daniel Dunbar54423b22010-09-17 00:24:54 +00008386 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008387
Alexey Samsonov7811d192014-02-20 13:57:37 +00008388 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008389
Chris Lattner3e2ee142010-07-07 16:01:42 +00008390 if (!Args.hasArg(options::OPT_nostdlib) &&
8391 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008392 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008393 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008394 CmdArgs.push_back("-lm");
8395 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008396 }
8397
8398 if (!Args.hasArg(options::OPT_nostdlib) &&
8399 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008400 if (Args.hasArg(options::OPT_pthread))
8401 CmdArgs.push_back("-lpthread");
8402 CmdArgs.push_back("-lc");
8403 CmdArgs.push_back("-lCompilerRT-Generic");
8404 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8405 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00008406 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008407 }
8408
Logan Chieneb9162f2014-06-26 14:23:45 +00008409 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008410 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008411}
8412
Daniel Dunbarcc912342009-05-02 18:28:39 +00008413/// DragonFly Tools
8414
8415// For now, DragonFly Assemble does just about the same as for
8416// FreeBSD, but this may change soon.
8417void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008418 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00008419 const InputInfoList &Inputs,
8420 const ArgList &Args,
8421 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008422 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008423 ArgStringList CmdArgs;
8424
8425 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8426 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008427 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008428 CmdArgs.push_back("--32");
8429
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008430 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008431
8432 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008433 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008434
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008435 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008436 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008437
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008438 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008439 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008440}
8441
8442void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008443 const InputInfo &Output,
8444 const InputInfoList &Inputs,
8445 const ArgList &Args,
8446 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008447 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008448 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008449 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008450
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008451 if (!D.SysRoot.empty())
8452 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8453
John McCall65b8da02013-04-11 22:55:55 +00008454 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008455 if (Args.hasArg(options::OPT_static)) {
8456 CmdArgs.push_back("-Bstatic");
8457 } else {
John McCall65b8da02013-04-11 22:55:55 +00008458 if (Args.hasArg(options::OPT_rdynamic))
8459 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008460 if (Args.hasArg(options::OPT_shared))
8461 CmdArgs.push_back("-Bshareable");
8462 else {
8463 CmdArgs.push_back("-dynamic-linker");
8464 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8465 }
John McCall65b8da02013-04-11 22:55:55 +00008466 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008467 }
8468
8469 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8470 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008471 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008472 CmdArgs.push_back("-m");
8473 CmdArgs.push_back("elf_i386");
8474 }
8475
Daniel Dunbarb440f562010-08-02 02:38:21 +00008476 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008477 CmdArgs.push_back("-o");
8478 CmdArgs.push_back(Output.getFilename());
8479 } else {
8480 assert(Output.isNothing() && "Invalid output.");
8481 }
8482
8483 if (!Args.hasArg(options::OPT_nostdlib) &&
8484 !Args.hasArg(options::OPT_nostartfiles)) {
8485 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008486 if (Args.hasArg(options::OPT_pg))
8487 CmdArgs.push_back(Args.MakeArgString(
8488 getToolChain().GetFilePath("gcrt1.o")));
8489 else {
8490 if (Args.hasArg(options::OPT_pie))
8491 CmdArgs.push_back(Args.MakeArgString(
8492 getToolChain().GetFilePath("Scrt1.o")));
8493 else
8494 CmdArgs.push_back(Args.MakeArgString(
8495 getToolChain().GetFilePath("crt1.o")));
8496 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008497 }
John McCall65b8da02013-04-11 22:55:55 +00008498 CmdArgs.push_back(Args.MakeArgString(
8499 getToolChain().GetFilePath("crti.o")));
8500 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8501 CmdArgs.push_back(Args.MakeArgString(
8502 getToolChain().GetFilePath("crtbeginS.o")));
8503 else
8504 CmdArgs.push_back(Args.MakeArgString(
8505 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008506 }
8507
8508 Args.AddAllArgs(CmdArgs, options::OPT_L);
8509 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8510 Args.AddAllArgs(CmdArgs, options::OPT_e);
8511
Daniel Dunbar54423b22010-09-17 00:24:54 +00008512 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008513
8514 if (!Args.hasArg(options::OPT_nostdlib) &&
8515 !Args.hasArg(options::OPT_nodefaultlibs)) {
8516 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8517 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00008518 if (UseGCC47)
8519 CmdArgs.push_back("-L/usr/lib/gcc47");
8520 else
8521 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008522
8523 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00008524 if (UseGCC47) {
8525 CmdArgs.push_back("-rpath");
8526 CmdArgs.push_back("/usr/lib/gcc47");
8527 } else {
8528 CmdArgs.push_back("-rpath");
8529 CmdArgs.push_back("/usr/lib/gcc44");
8530 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008531 }
8532
Hans Wennborg70850d82013-07-18 20:29:38 +00008533 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008534 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00008535 CmdArgs.push_back("-lm");
8536 }
8537
Daniel Dunbarcc912342009-05-02 18:28:39 +00008538 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00008539 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008540
8541 if (!Args.hasArg(options::OPT_nolibc)) {
8542 CmdArgs.push_back("-lc");
8543 }
8544
John McCall65b8da02013-04-11 22:55:55 +00008545 if (UseGCC47) {
8546 if (Args.hasArg(options::OPT_static) ||
8547 Args.hasArg(options::OPT_static_libgcc)) {
8548 CmdArgs.push_back("-lgcc");
8549 CmdArgs.push_back("-lgcc_eh");
8550 } else {
8551 if (Args.hasArg(options::OPT_shared_libgcc)) {
8552 CmdArgs.push_back("-lgcc_pic");
8553 if (!Args.hasArg(options::OPT_shared))
8554 CmdArgs.push_back("-lgcc");
8555 } else {
8556 CmdArgs.push_back("-lgcc");
8557 CmdArgs.push_back("--as-needed");
8558 CmdArgs.push_back("-lgcc_pic");
8559 CmdArgs.push_back("--no-as-needed");
8560 }
8561 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008562 } else {
John McCall65b8da02013-04-11 22:55:55 +00008563 if (Args.hasArg(options::OPT_shared)) {
8564 CmdArgs.push_back("-lgcc_pic");
8565 } else {
8566 CmdArgs.push_back("-lgcc");
8567 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008568 }
8569 }
8570
8571 if (!Args.hasArg(options::OPT_nostdlib) &&
8572 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00008573 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00008574 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00008575 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008576 else
8577 CmdArgs.push_back(Args.MakeArgString(
8578 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008579 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00008580 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008581 }
8582
Alexey Samsonov7811d192014-02-20 13:57:37 +00008583 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008584
Logan Chieneb9162f2014-06-26 14:23:45 +00008585 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008586 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008587}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008588
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008589// Try to find Exe from a Visual Studio distribution. This first tries to find
8590// an installed copy of Visual Studio and, failing that, looks in the PATH,
8591// making sure that whatever executable that's found is not a same-named exe
8592// from clang itself to prevent clang from falling back to itself.
8593static std::string FindVisualStudioExecutable(const ToolChain &TC,
8594 const char *Exe,
8595 const char *ClangProgramPath) {
8596 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8597 std::string visualStudioBinDir;
8598 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8599 visualStudioBinDir)) {
8600 SmallString<128> FilePath(visualStudioBinDir);
8601 llvm::sys::path::append(FilePath, Exe);
8602 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8603 return FilePath.str();
8604 }
8605
8606 return Exe;
8607}
8608
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008609void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
8610 const InputInfo &Output,
8611 const InputInfoList &Inputs,
8612 const ArgList &Args,
8613 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008614 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008615 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008616
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008617 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8618 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00008619 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
8620 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008621
8622 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008623 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008624 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008625
Zachary Turner10d75b22014-10-22 20:40:43 +00008626 if (!llvm::sys::Process::GetEnv("LIB")) {
8627 // If the VC environment hasn't been configured (perhaps because the user
8628 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00008629 // the environment variable is set however, assume the user knows what
8630 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00008631 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008632 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00008633 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8634 SmallString<128> LibDir(VisualStudioDir);
8635 llvm::sys::path::append(LibDir, "VC", "lib");
8636 switch (MSVC.getArch()) {
8637 case llvm::Triple::x86:
8638 // x86 just puts the libraries directly in lib
8639 break;
8640 case llvm::Triple::x86_64:
8641 llvm::sys::path::append(LibDir, "amd64");
8642 break;
8643 case llvm::Triple::arm:
8644 llvm::sys::path::append(LibDir, "arm");
8645 break;
8646 default:
8647 break;
8648 }
8649 CmdArgs.push_back(
8650 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8651 }
8652
8653 std::string WindowsSdkLibPath;
8654 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8655 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8656 WindowsSdkLibPath.c_str()));
8657 }
8658
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008659 CmdArgs.push_back("-nologo");
8660
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008661 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008662 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008663
Hans Wennborge4c47f22015-03-04 23:16:21 +00008664 bool DLL = Args.hasArg(options::OPT__SLASH_LD,
8665 options::OPT__SLASH_LDd,
8666 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00008667 if (DLL) {
8668 CmdArgs.push_back(Args.MakeArgString("-dll"));
8669
8670 SmallString<128> ImplibName(Output.getFilename());
8671 llvm::sys::path::replace_extension(ImplibName, "lib");
8672 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
Yaron Keren92e1b622015-03-18 10:17:07 +00008673 ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00008674 }
8675
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008676 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00008677 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00008678 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008679 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008680 static const char *CompilerRTComponents[] = {
8681 "asan_dynamic",
8682 "asan_dynamic_runtime_thunk",
8683 };
8684 for (const auto &Component : CompilerRTComponents)
8685 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00008686 // Make sure the dynamic runtime thunk is not optimized out at link time
8687 // to ensure proper SEH handling.
8688 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008689 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008690 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008691 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008692 static const char *CompilerRTComponents[] = {
8693 "asan",
8694 "asan_cxx",
8695 };
8696 for (const auto &Component : CompilerRTComponents)
8697 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008698 }
Hans Wennborg65f17522013-08-27 18:10:21 +00008699 }
8700
Hans Wennborg2e274592013-08-13 23:38:57 +00008701 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00008702
Reid Kleckner337188f2014-09-16 19:22:00 +00008703 // Add filenames, libraries, and other linker inputs.
8704 for (const auto &Input : Inputs) {
8705 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008706 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00008707 continue;
8708 }
8709
8710 const Arg &A = Input.getInputArg();
8711
8712 // Render -l options differently for the MSVC linker.
8713 if (A.getOption().matches(options::OPT_l)) {
8714 StringRef Lib = A.getValue();
8715 const char *LinkLibArg;
8716 if (Lib.endswith(".lib"))
8717 LinkLibArg = Args.MakeArgString(Lib);
8718 else
8719 LinkLibArg = Args.MakeArgString(Lib + ".lib");
8720 CmdArgs.push_back(LinkLibArg);
8721 continue;
8722 }
8723
8724 // Otherwise, this is some other kind of linker input option like -Wl, -z,
8725 // or -L. Render it, even if MSVC doesn't understand it.
8726 A.renderAsInput(Args, CmdArgs);
8727 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008728
Zachary Turner719f58c2014-12-01 23:06:47 +00008729 // We need to special case some linker paths. In the case of lld, we need to
8730 // translate 'lld' into 'lld-link', and in the case of the regular msvc
8731 // linker, we need to use a special search algorithm.
8732 llvm::SmallString<128> linkPath;
8733 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8734 if (Linker.equals_lower("lld"))
8735 Linker = "lld-link";
8736
8737 if (Linker.equals_lower("link")) {
8738 // If we're using the MSVC linker, it's not sufficient to just use link
8739 // from the program PATH, because other environments like GnuWin32 install
8740 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008741 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008742 C.getDriver().getClangProgramPath());
8743 } else {
8744 linkPath = Linker;
8745 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008746 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008747 }
8748
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008749 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00008750 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008751}
Hans Wennborg87cfa712013-09-19 20:32:16 +00008752
8753void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
8754 const InputInfo &Output,
8755 const InputInfoList &Inputs,
8756 const ArgList &Args,
8757 const char *LinkingOutput) const {
8758 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8759}
8760
David Blaikiec11bf802014-09-04 16:04:28 +00008761std::unique_ptr<Command> visualstudio::Compile::GetCommand(
8762 Compilation &C, const JobAction &JA, const InputInfo &Output,
8763 const InputInfoList &Inputs, const ArgList &Args,
8764 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00008765 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00008766 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008767 CmdArgs.push_back("/c"); // Compile only.
8768 CmdArgs.push_back("/W0"); // No warnings.
8769
8770 // The goal is to be able to invoke this tool correctly based on
8771 // any flag accepted by clang-cl.
8772
8773 // These are spelled the same way in clang and cl.exe,.
8774 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8775 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008776
8777 // Optimization level.
8778 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8779 if (A->getOption().getID() == options::OPT_O0) {
8780 CmdArgs.push_back("/Od");
8781 } else {
8782 StringRef OptLevel = A->getValue();
8783 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8784 A->render(Args, CmdArgs);
8785 else if (OptLevel == "3")
8786 CmdArgs.push_back("/Ox");
8787 }
8788 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008789
Nico Weber3f8dafb2015-03-12 19:37:10 +00008790 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00008791 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8792
David Majnemerf6072342014-07-01 22:24:56 +00008793 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8794 /*default=*/false))
8795 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008796 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8797 options::OPT_fno_function_sections))
8798 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8799 ? "/Gy"
8800 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008801 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8802 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008803 CmdArgs.push_back(
8804 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008805 if (Args.hasArg(options::OPT_fsyntax_only))
8806 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008807 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8808 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008809
Nico Weber3f8dafb2015-03-12 19:37:10 +00008810 std::vector<std::string> Includes =
8811 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008812 for (const auto &Include : Includes)
8813 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008814
Hans Wennborg87cfa712013-09-19 20:32:16 +00008815 // Flags that can simply be passed through.
8816 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8817 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008818 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008819
8820 // The order of these flags is relevant, so pick the last one.
8821 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8822 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8823 A->render(Args, CmdArgs);
8824
8825
8826 // Input filename.
8827 assert(Inputs.size() == 1);
8828 const InputInfo &II = Inputs[0];
8829 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8830 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8831 if (II.isFilename())
8832 CmdArgs.push_back(II.getFilename());
8833 else
8834 II.getInputArg().renderAsInput(Args, CmdArgs);
8835
8836 // Output filename.
8837 assert(Output.getType() == types::TY_Object);
8838 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8839 Output.getFilename());
8840 CmdArgs.push_back(Fo);
8841
Hans Wennborg188382e2013-09-20 18:16:35 +00008842 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008843 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8844 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008845 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8846 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008847}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008848
8849
8850/// XCore Tools
8851// We pass assemble and link construction to the xcc tool.
8852
8853void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8854 const InputInfo &Output,
8855 const InputInfoList &Inputs,
8856 const ArgList &Args,
8857 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008858 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008859 ArgStringList CmdArgs;
8860
8861 CmdArgs.push_back("-o");
8862 CmdArgs.push_back(Output.getFilename());
8863
8864 CmdArgs.push_back("-c");
8865
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008866 if (Args.hasArg(options::OPT_v))
8867 CmdArgs.push_back("-v");
8868
Robert Lytton894d25c2014-05-02 09:33:25 +00008869 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8870 if (!A->getOption().matches(options::OPT_g0))
8871 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008872
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008873 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8874 false))
8875 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008876
8877 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8878 options::OPT_Xassembler);
8879
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008880 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008881 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008882
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008883 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008884 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008885}
8886
8887void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8888 const InputInfo &Output,
8889 const InputInfoList &Inputs,
8890 const ArgList &Args,
8891 const char *LinkingOutput) const {
8892 ArgStringList CmdArgs;
8893
8894 if (Output.isFilename()) {
8895 CmdArgs.push_back("-o");
8896 CmdArgs.push_back(Output.getFilename());
8897 } else {
8898 assert(Output.isNothing() && "Invalid output.");
8899 }
8900
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008901 if (Args.hasArg(options::OPT_v))
8902 CmdArgs.push_back("-v");
8903
David Majnemer8de68642014-12-05 08:11:58 +00008904 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008905 CmdArgs.push_back("-fexceptions");
8906
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008907 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8908
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008909 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008910 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008911}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008912
8913void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8914 const InputInfo &Output,
8915 const InputInfoList &Inputs,
8916 const ArgList &Args,
8917 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008918 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008919 const auto &TC =
8920 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8921 ArgStringList CmdArgs;
8922 const char *Exec;
8923
8924 switch (TC.getArch()) {
8925 default: llvm_unreachable("unsupported architecture");
8926 case llvm::Triple::arm:
8927 case llvm::Triple::thumb:
8928 break;
8929 case llvm::Triple::x86:
8930 CmdArgs.push_back("--32");
8931 break;
8932 case llvm::Triple::x86_64:
8933 CmdArgs.push_back("--64");
8934 break;
8935 }
8936
8937 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8938
8939 CmdArgs.push_back("-o");
8940 CmdArgs.push_back(Output.getFilename());
8941
8942 for (const auto &Input : Inputs)
8943 CmdArgs.push_back(Input.getFilename());
8944
8945 const std::string Assembler = TC.GetProgramPath("as");
8946 Exec = Args.MakeArgString(Assembler);
8947
8948 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8949}
8950
8951void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8952 const InputInfo &Output,
8953 const InputInfoList &Inputs,
8954 const ArgList &Args,
8955 const char *LinkingOutput) const {
8956 const auto &TC =
8957 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8958 const llvm::Triple &T = TC.getTriple();
8959 const Driver &D = TC.getDriver();
8960 SmallString<128> EntryPoint;
8961 ArgStringList CmdArgs;
8962 const char *Exec;
8963
8964 // Silence warning for "clang -g foo.o -o foo"
8965 Args.ClaimAllArgs(options::OPT_g_Group);
8966 // and "clang -emit-llvm foo.o -o foo"
8967 Args.ClaimAllArgs(options::OPT_emit_llvm);
8968 // and for "clang -w foo.o -o foo"
8969 Args.ClaimAllArgs(options::OPT_w);
8970 // Other warning options are already handled somewhere else.
8971
8972 if (!D.SysRoot.empty())
8973 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8974
8975 if (Args.hasArg(options::OPT_pie))
8976 CmdArgs.push_back("-pie");
8977 if (Args.hasArg(options::OPT_rdynamic))
8978 CmdArgs.push_back("-export-dynamic");
8979 if (Args.hasArg(options::OPT_s))
8980 CmdArgs.push_back("--strip-all");
8981
8982 CmdArgs.push_back("-m");
8983 switch (TC.getArch()) {
8984 default: llvm_unreachable("unsupported architecture");
8985 case llvm::Triple::arm:
8986 case llvm::Triple::thumb:
8987 // FIXME: this is incorrect for WinCE
8988 CmdArgs.push_back("thumb2pe");
8989 break;
8990 case llvm::Triple::x86:
8991 CmdArgs.push_back("i386pe");
8992 EntryPoint.append("_");
8993 break;
8994 case llvm::Triple::x86_64:
8995 CmdArgs.push_back("i386pep");
8996 break;
8997 }
8998
8999 if (Args.hasArg(options::OPT_shared)) {
9000 switch (T.getArch()) {
9001 default: llvm_unreachable("unsupported architecture");
9002 case llvm::Triple::arm:
9003 case llvm::Triple::thumb:
9004 case llvm::Triple::x86_64:
9005 EntryPoint.append("_DllMainCRTStartup");
9006 break;
9007 case llvm::Triple::x86:
9008 EntryPoint.append("_DllMainCRTStartup@12");
9009 break;
9010 }
9011
9012 CmdArgs.push_back("-shared");
9013 CmdArgs.push_back("-Bdynamic");
9014
9015 CmdArgs.push_back("--enable-auto-image-base");
9016
9017 CmdArgs.push_back("--entry");
9018 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9019 } else {
9020 EntryPoint.append("mainCRTStartup");
9021
9022 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
9023 : "-Bdynamic");
9024
9025 if (!Args.hasArg(options::OPT_nostdlib) &&
9026 !Args.hasArg(options::OPT_nostartfiles)) {
9027 CmdArgs.push_back("--entry");
9028 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9029 }
9030
9031 // FIXME: handle subsystem
9032 }
9033
9034 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00009035 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009036
9037 CmdArgs.push_back("-o");
9038 CmdArgs.push_back(Output.getFilename());
9039
9040 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9041 SmallString<261> ImpLib(Output.getFilename());
9042 llvm::sys::path::replace_extension(ImpLib, ".lib");
9043
9044 CmdArgs.push_back("--out-implib");
9045 CmdArgs.push_back(Args.MakeArgString(ImpLib));
9046 }
9047
9048 if (!Args.hasArg(options::OPT_nostdlib) &&
9049 !Args.hasArg(options::OPT_nostartfiles)) {
9050 const std::string CRTPath(D.SysRoot + "/usr/lib/");
9051 const char *CRTBegin;
9052
9053 CRTBegin =
9054 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
9055 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9056 }
9057
9058 Args.AddAllArgs(CmdArgs, options::OPT_L);
9059
9060 const auto &Paths = TC.getFilePaths();
9061 for (const auto &Path : Paths)
9062 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9063
9064 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9065
9066 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9067 !Args.hasArg(options::OPT_nodefaultlibs)) {
9068 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9069 !Args.hasArg(options::OPT_static);
9070 if (StaticCXX)
9071 CmdArgs.push_back("-Bstatic");
9072 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9073 if (StaticCXX)
9074 CmdArgs.push_back("-Bdynamic");
9075 }
9076
9077 if (!Args.hasArg(options::OPT_nostdlib)) {
9078 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9079 // TODO handle /MT[d] /MD[d]
9080 CmdArgs.push_back("-lmsvcrt");
9081 AddRunTimeLibs(TC, D, CmdArgs, Args);
9082 }
9083 }
9084
9085 const std::string Linker = TC.GetProgramPath("ld");
9086 Exec = Args.MakeArgString(Linker);
9087
9088 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9089}