blob: 800053cc9316a8dedbf729dc01619afeefdf2d15 [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
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001337void Clang::AddSparcTargetArgs(const ArgList &Args,
1338 ArgStringList &CmdArgs) const {
1339 const Driver &D = getToolChain().getDriver();
James Y Knightb2406522015-06-15 20:51:24 +00001340 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001341
James Y Knightb2406522015-06-15 20:51:24 +00001342 bool SoftFloatABI = false;
1343 if (Arg *A =
1344 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001345 if (A->getOption().matches(options::OPT_msoft_float))
James Y Knightb2406522015-06-15 20:51:24 +00001346 SoftFloatABI = true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001347 }
1348
James Y Knightb2406522015-06-15 20:51:24 +00001349 // Only the hard-float ABI on Sparc is standardized, and it is the
1350 // default. GCC also supports a nonstandard soft-float ABI mode, and
1351 // perhaps LLVM should implement that, too. However, since llvm
1352 // currently does not support Sparc soft-float, at all, display an
1353 // error if it's requested.
1354 if (SoftFloatABI) {
1355 D.Diag(diag::err_drv_unsupported_opt_for_target)
1356 << "-msoft-float" << Triple;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001357 }
1358}
1359
Richard Sandiford4652d892013-07-19 16:51:51 +00001360static const char *getSystemZTargetCPU(const ArgList &Args) {
1361 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1362 return A->getValue();
1363 return "z10";
1364}
1365
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001366static void getSystemZTargetFeatures(const ArgList &Args,
1367 std::vector<const char *> &Features) {
1368 // -m(no-)htm overrides use of the transactional-execution facility.
1369 if (Arg *A = Args.getLastArg(options::OPT_mhtm,
1370 options::OPT_mno_htm)) {
1371 if (A->getOption().matches(options::OPT_mhtm))
1372 Features.push_back("+transactional-execution");
1373 else
1374 Features.push_back("-transactional-execution");
1375 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001376 // -m(no-)vx overrides use of the vector facility.
1377 if (Arg *A = Args.getLastArg(options::OPT_mvx,
1378 options::OPT_mno_vx)) {
1379 if (A->getOption().matches(options::OPT_mvx))
1380 Features.push_back("+vector");
1381 else
1382 Features.push_back("-vector");
1383 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001384}
1385
Chandler Carruth953fb082013-01-13 11:46:33 +00001386static const char *getX86TargetCPU(const ArgList &Args,
1387 const llvm::Triple &Triple) {
1388 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001389 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001390 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001391 return "core-avx2";
1392
Chandler Carruth953fb082013-01-13 11:46:33 +00001393 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001394 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001395
1396 // FIXME: Reject attempts to use -march=native unless the target matches
1397 // the host.
1398 //
1399 // FIXME: We should also incorporate the detected target features for use
1400 // with -native.
1401 std::string CPU = llvm::sys::getHostCPUName();
1402 if (!CPU.empty() && CPU != "generic")
1403 return Args.MakeArgString(CPU);
1404 }
1405
1406 // Select the default CPU if none was given (or detection failed).
1407
1408 if (Triple.getArch() != llvm::Triple::x86_64 &&
1409 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001410 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001411
1412 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1413
1414 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001415 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001416 if (Triple.getArchName() == "x86_64h")
1417 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001418 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001419 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001420
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001421 // Set up default CPU name for PS4 compilers.
1422 if (Triple.isPS4CPU())
1423 return "btver2";
1424
Alexey Bataev286d1b92014-01-31 04:07:13 +00001425 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001426 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001427 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001428
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001429 // Everything else goes to x86-64 in 64-bit mode.
1430 if (Is64Bit)
1431 return "x86-64";
1432
1433 switch (Triple.getOS()) {
1434 case llvm::Triple::FreeBSD:
1435 case llvm::Triple::NetBSD:
1436 case llvm::Triple::OpenBSD:
1437 return "i486";
1438 case llvm::Triple::Haiku:
1439 return "i586";
1440 case llvm::Triple::Bitrig:
1441 return "i686";
1442 default:
1443 // Fallback to p4.
1444 return "pentium4";
1445 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001446}
1447
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001448static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1449 switch(T.getArch()) {
1450 default:
1451 return "";
1452
Amara Emerson703da2e2013-10-31 09:32:33 +00001453 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001454 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001455 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001456
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001457 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001458 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001459 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001460 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001461 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001462
1463 case llvm::Triple::mips:
1464 case llvm::Triple::mipsel:
1465 case llvm::Triple::mips64:
1466 case llvm::Triple::mips64el: {
1467 StringRef CPUName;
1468 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001469 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001470 return CPUName;
1471 }
1472
1473 case llvm::Triple::ppc:
1474 case llvm::Triple::ppc64:
1475 case llvm::Triple::ppc64le: {
1476 std::string TargetCPUName = getPPCTargetCPU(Args);
1477 // LLVM may default to generating code for the native CPU,
1478 // but, like gcc, we default to a more generic option for
1479 // each architecture. (except on Darwin)
1480 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1481 if (T.getArch() == llvm::Triple::ppc64)
1482 TargetCPUName = "ppc64";
1483 else if (T.getArch() == llvm::Triple::ppc64le)
1484 TargetCPUName = "ppc64le";
1485 else
1486 TargetCPUName = "ppc";
1487 }
1488 return TargetCPUName;
1489 }
1490
1491 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001492 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001493 case llvm::Triple::sparcv9:
1494 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001495 return A->getValue();
1496 return "";
1497
1498 case llvm::Triple::x86:
1499 case llvm::Triple::x86_64:
1500 return getX86TargetCPU(Args, T);
1501
1502 case llvm::Triple::hexagon:
1503 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1504
1505 case llvm::Triple::systemz:
1506 return getSystemZTargetCPU(Args);
1507
1508 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001509 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001510 return getR600TargetGPU(Args);
1511 }
1512}
1513
Alp Tokerce365ca2013-12-02 12:43:03 +00001514static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1515 ArgStringList &CmdArgs) {
1516 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1517 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1518 // forward.
1519 CmdArgs.push_back("-plugin");
Rafael Espindola3e34e652015-02-03 16:33:53 +00001520 std::string Plugin = ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001521 CmdArgs.push_back(Args.MakeArgString(Plugin));
1522
1523 // Try to pass driver level flags relevant to LTO code generation down to
1524 // the plugin.
1525
1526 // Handle flags for selecting CPU variants.
1527 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1528 if (!CPU.empty())
1529 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1530}
1531
Sanjay Patel2987c292015-06-11 14:53:41 +00001532/// This is a helper function for validating the optional refinement step
1533/// parameter in reciprocal argument strings. Return false if there is an error
1534/// parsing the refinement step. Otherwise, return true and set the Position
1535/// of the refinement step in the input string.
1536static bool getRefinementStep(const StringRef &In, const Driver &D,
1537 const Arg &A, size_t &Position) {
1538 const char RefinementStepToken = ':';
1539 Position = In.find(RefinementStepToken);
1540 if (Position != StringRef::npos) {
1541 StringRef Option = A.getOption().getName();
1542 StringRef RefStep = In.substr(Position + 1);
1543 // Allow exactly one numeric character for the additional refinement
1544 // step parameter. This is reasonable for all currently-supported
1545 // operations and architectures because we would expect that a larger value
1546 // of refinement steps would cause the estimate "optimization" to
1547 // under-perform the native operation. Also, if the estimate does not
1548 // converge quickly, it probably will not ever converge, so further
1549 // refinement steps will not produce a better answer.
1550 if (RefStep.size() != 1) {
1551 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1552 return false;
1553 }
1554 char RefStepChar = RefStep[0];
1555 if (RefStepChar < '0' || RefStepChar > '9') {
1556 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1557 return false;
1558 }
1559 }
1560 return true;
1561}
1562
1563/// The -mrecip flag requires processing of many optional parameters.
1564static void ParseMRecip(const Driver &D, const ArgList &Args,
1565 ArgStringList &OutStrings) {
1566 StringRef DisabledPrefixIn = "!";
1567 StringRef DisabledPrefixOut = "!";
1568 StringRef EnabledPrefixOut = "";
1569 StringRef Out = "-mrecip=";
1570
1571 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1572 if (!A)
1573 return;
1574
1575 unsigned NumOptions = A->getNumValues();
1576 if (NumOptions == 0) {
1577 // No option is the same as "all".
1578 OutStrings.push_back(Args.MakeArgString(Out + "all"));
1579 return;
1580 }
1581
1582 // Pass through "all", "none", or "default" with an optional refinement step.
1583 if (NumOptions == 1) {
1584 StringRef Val = A->getValue(0);
1585 size_t RefStepLoc;
1586 if (!getRefinementStep(Val, D, *A, RefStepLoc))
1587 return;
1588 StringRef ValBase = Val.slice(0, RefStepLoc);
1589 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1590 OutStrings.push_back(Args.MakeArgString(Out + Val));
1591 return;
1592 }
1593 }
1594
1595 // Each reciprocal type may be enabled or disabled individually.
1596 // Check each input value for validity, concatenate them all back together,
1597 // and pass through.
1598
1599 llvm::StringMap<bool> OptionStrings;
1600 OptionStrings.insert(std::make_pair("divd", false));
1601 OptionStrings.insert(std::make_pair("divf", false));
1602 OptionStrings.insert(std::make_pair("vec-divd", false));
1603 OptionStrings.insert(std::make_pair("vec-divf", false));
1604 OptionStrings.insert(std::make_pair("sqrtd", false));
1605 OptionStrings.insert(std::make_pair("sqrtf", false));
1606 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
1607 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
1608
1609 for (unsigned i = 0; i != NumOptions; ++i) {
1610 StringRef Val = A->getValue(i);
1611
1612 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1613 // Ignore the disablement token for string matching.
1614 if (IsDisabled)
1615 Val = Val.substr(1);
1616
1617 size_t RefStep;
1618 if (!getRefinementStep(Val, D, *A, RefStep))
1619 return;
1620
1621 StringRef ValBase = Val.slice(0, RefStep);
1622 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1623 if (OptionIter == OptionStrings.end()) {
1624 // Try again specifying float suffix.
1625 OptionIter = OptionStrings.find(ValBase.str() + 'f');
1626 if (OptionIter == OptionStrings.end()) {
1627 // The input name did not match any known option string.
1628 D.Diag(diag::err_drv_unknown_argument) << Val;
1629 return;
1630 }
1631 // The option was specified without a float or double suffix.
1632 // Make sure that the double entry was not already specified.
1633 // The float entry will be checked below.
1634 if (OptionStrings[ValBase.str() + 'd']) {
1635 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1636 return;
1637 }
1638 }
1639
1640 if (OptionIter->second == true) {
1641 // Duplicate option specified.
1642 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1643 return;
1644 }
1645
1646 // Mark the matched option as found. Do not allow duplicate specifiers.
1647 OptionIter->second = true;
1648
1649 // If the precision was not specified, also mark the double entry as found.
1650 if (ValBase.back() != 'f' && ValBase.back() != 'd')
1651 OptionStrings[ValBase.str() + 'd'] = true;
1652
1653 // Build the output string.
1654 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1655 Out = Args.MakeArgString(Out + Prefix + Val);
1656 if (i != NumOptions - 1)
1657 Out = Args.MakeArgString(Out + ",");
1658 }
1659
1660 OutStrings.push_back(Args.MakeArgString(Out));
1661}
1662
Eric Christopherc54920a2015-03-23 19:26:05 +00001663static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001664 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001665 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001666 // If -march=native, autodetect the feature list.
1667 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1668 if (StringRef(A->getValue()) == "native") {
1669 llvm::StringMap<bool> HostFeatures;
1670 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1671 for (auto &F : HostFeatures)
1672 Features.push_back(Args.MakeArgString((F.second ? "+" : "-") +
1673 F.first()));
1674 }
1675 }
1676
Jim Grosbach82eee262013-11-16 00:53:35 +00001677 if (Triple.getArchName() == "x86_64h") {
1678 // x86_64h implies quite a few of the more modern subtarget features
1679 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1680 Features.push_back("-rdrnd");
1681 Features.push_back("-aes");
1682 Features.push_back("-pclmul");
1683 Features.push_back("-rtm");
1684 Features.push_back("-hle");
1685 Features.push_back("-fsgsbase");
1686 }
1687
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001688 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00001689 // Add features to be compatible with gcc for Android.
Alexey Bataev286d1b92014-01-31 04:07:13 +00001690 if (Triple.getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001691 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001692 Features.push_back("+sse4.2");
1693 Features.push_back("+popcnt");
1694 } else
1695 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001696 }
1697
Eric Christopherc54920a2015-03-23 19:26:05 +00001698 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001699 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1700 StringRef Arch = A->getValue();
1701 bool ArchUsed = false;
1702 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001703 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001704 if (Arch == "AVX" || Arch == "AVX2") {
1705 ArchUsed = true;
1706 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1707 }
1708 }
1709 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001710 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001711 if (Arch == "IA32") {
1712 ArchUsed = true;
1713 } else if (Arch == "SSE" || Arch == "SSE2") {
1714 ArchUsed = true;
1715 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1716 }
1717 }
1718 if (!ArchUsed)
1719 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1720 }
1721
Jim Grosbach82eee262013-11-16 00:53:35 +00001722 // Now add any that the user explicitly requested on the command line,
1723 // which may override the defaults.
Sean Silva14facf32015-06-09 01:57:17 +00001724 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1725 StringRef Name = A->getOption().getName();
1726 A->claim();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001727
1728 // Skip over "-m".
1729 assert(Name.startswith("m") && "Invalid feature name.");
1730 Name = Name.substr(1);
1731
1732 bool IsNegative = Name.startswith("no-");
1733 if (IsNegative)
1734 Name = Name.substr(3);
1735
1736 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1737 }
1738}
1739
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001740void Clang::AddX86TargetArgs(const ArgList &Args,
1741 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001742 if (!Args.hasFlag(options::OPT_mred_zone,
1743 options::OPT_mno_red_zone,
1744 true) ||
1745 Args.hasArg(options::OPT_mkernel) ||
1746 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001747 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001748
Bob Wilson2616e2e2013-02-10 16:01:41 +00001749 // Default to avoid implicit floating-point for kernel/kext code, but allow
1750 // that to be overridden with -mno-soft-float.
1751 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1752 Args.hasArg(options::OPT_fapple_kext));
1753 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1754 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001755 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001756 options::OPT_mno_implicit_float)) {
1757 const Option &O = A->getOption();
1758 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1759 O.matches(options::OPT_msoft_float));
1760 }
1761 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001762 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001763
1764 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1765 StringRef Value = A->getValue();
1766 if (Value == "intel" || Value == "att") {
1767 CmdArgs.push_back("-mllvm");
1768 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1769 } else {
1770 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1771 << A->getOption().getName() << Value;
1772 }
1773 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001774}
1775
Tony Linthicum76329bf2011-12-12 21:14:55 +00001776void Clang::AddHexagonTargetArgs(const ArgList &Args,
1777 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00001778 CmdArgs.push_back("-mqdsp6-compat");
1779 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001780
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001781 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
1782 std::string SmallDataThreshold="-hexagon-small-data-threshold=";
1783 SmallDataThreshold += v;
Tony Linthicum76329bf2011-12-12 21:14:55 +00001784 CmdArgs.push_back ("-mllvm");
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001785 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001786 }
1787
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001788 if (!Args.hasArg(options::OPT_fno_short_enums))
1789 CmdArgs.push_back("-fshort-enums");
1790 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1791 CmdArgs.push_back ("-mllvm");
1792 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1793 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001794 CmdArgs.push_back ("-mllvm");
1795 CmdArgs.push_back ("-machine-sink-split=0");
1796}
1797
Kevin Qin110db6f2014-07-18 07:03:22 +00001798// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001799static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001800 std::vector<const char *> &Features) {
1801 SmallVector<StringRef, 8> Split;
1802 text.split(Split, StringRef("+"), -1, false);
1803
1804 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1805 const char *result = llvm::StringSwitch<const char *>(Split[I])
1806 .Case("fp", "+fp-armv8")
1807 .Case("simd", "+neon")
1808 .Case("crc", "+crc")
1809 .Case("crypto", "+crypto")
1810 .Case("nofp", "-fp-armv8")
1811 .Case("nosimd", "-neon")
1812 .Case("nocrc", "-crc")
1813 .Case("nocrypto", "-crypto")
1814 .Default(nullptr);
1815 if (result)
1816 Features.push_back(result);
1817 else if (Split[I] == "neon" || Split[I] == "noneon")
1818 D.Diag(diag::err_drv_no_neon_modifier);
1819 else
1820 return false;
1821 }
1822 return true;
1823}
1824
1825// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1826// decode CPU and feature.
1827static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1828 std::vector<const char *> &Features) {
1829 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1830 CPU = Split.first;
Renato Golin84545d72015-02-04 13:31:56 +00001831 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001832 Features.push_back("+neon");
1833 Features.push_back("+crc");
1834 Features.push_back("+crypto");
1835 } else if (CPU == "generic") {
1836 Features.push_back("+neon");
1837 } else {
1838 return false;
1839 }
1840
1841 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1842 return false;
1843
1844 return true;
1845}
1846
1847static bool
1848getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1849 const ArgList &Args,
1850 std::vector<const char *> &Features) {
1851 std::pair<StringRef, StringRef> Split = March.split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001852
1853 if (Split.first == "armv8-a" ||
1854 Split.first == "armv8a") {
1855 // ok, no additional features.
1856 } else if (
1857 Split.first == "armv8.1-a" ||
1858 Split.first == "armv8.1a" ) {
1859 Features.push_back("+v8.1a");
1860 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00001861 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001862 }
Kevin Qin110db6f2014-07-18 07:03:22 +00001863
1864 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1865 return false;
1866
1867 return true;
1868}
1869
1870static bool
1871getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1872 const ArgList &Args,
1873 std::vector<const char *> &Features) {
1874 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001875 std::string McpuLowerCase = Mcpu.lower();
1876 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00001877 return false;
1878
1879 return true;
1880}
1881
1882static bool
1883getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1884 const ArgList &Args,
1885 std::vector<const char *> &Features) {
1886 // Handle CPU name is 'native'.
1887 if (Mtune == "native")
1888 Mtune = llvm::sys::getHostCPUName();
1889 if (Mtune == "cyclone") {
1890 Features.push_back("+zcm");
1891 Features.push_back("+zcz");
1892 }
1893 return true;
1894}
1895
1896static bool
1897getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1898 const ArgList &Args,
1899 std::vector<const char *> &Features) {
1900 StringRef CPU;
1901 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001902 std::string McpuLowerCase = Mcpu.lower();
1903 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00001904 return false;
1905
1906 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1907}
1908
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001909static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1910 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001911 Arg *A;
1912 bool success = true;
1913 // Enable NEON by default.
1914 Features.push_back("+neon");
1915 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1916 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1917 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1918 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001919 else if (Args.hasArg(options::OPT_arch))
1920 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1921 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001922
1923 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1924 success =
1925 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1926 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1927 success =
1928 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001929 else if (Args.hasArg(options::OPT_arch))
1930 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1931 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001932
1933 if (!success)
1934 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001935
1936 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1937 Features.push_back("-fp-armv8");
1938 Features.push_back("-crypto");
1939 Features.push_back("-neon");
1940 }
Bradley Smith418c5932014-05-02 15:17:51 +00001941
1942 // En/disable crc
1943 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1944 options::OPT_mnocrc)) {
1945 if (A->getOption().matches(options::OPT_mcrc))
1946 Features.push_back("+crc");
1947 else
1948 Features.push_back("-crc");
1949 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001950}
1951
1952static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001953 const ArgList &Args, ArgStringList &CmdArgs,
1954 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001955 std::vector<const char *> Features;
1956 switch (Triple.getArch()) {
1957 default:
1958 break;
1959 case llvm::Triple::mips:
1960 case llvm::Triple::mipsel:
1961 case llvm::Triple::mips64:
1962 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001963 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001964 break;
1965
1966 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001967 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001968 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001969 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001970 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001971 break;
1972
1973 case llvm::Triple::ppc:
1974 case llvm::Triple::ppc64:
1975 case llvm::Triple::ppc64le:
1976 getPPCTargetFeatures(Args, Features);
1977 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001978 case llvm::Triple::systemz:
1979 getSystemZTargetFeatures(Args, Features);
1980 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001981 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001982 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001983 getAArch64TargetFeatures(D, Args, Features);
1984 break;
1985 case llvm::Triple::x86:
1986 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001987 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001988 break;
1989 }
Rafael Espindola43964802013-08-21 17:34:32 +00001990
1991 // Find the last of each feature.
1992 llvm::StringMap<unsigned> LastOpt;
1993 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1994 const char *Name = Features[I];
1995 assert(Name[0] == '-' || Name[0] == '+');
1996 LastOpt[Name + 1] = I;
1997 }
1998
1999 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2000 // If this feature was overridden, ignore it.
2001 const char *Name = Features[I];
2002 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2003 assert(LastI != LastOpt.end());
2004 unsigned Last = LastI->second;
2005 if (Last != I)
2006 continue;
2007
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002008 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002009 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002010 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002011}
2012
David Majnemerae394812014-12-09 00:12:30 +00002013static bool
2014shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2015 const llvm::Triple &Triple) {
2016 // We use the zero-cost exception tables for Objective-C if the non-fragile
2017 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2018 // later.
2019 if (runtime.isNonFragile())
2020 return true;
2021
2022 if (!Triple.isMacOSX())
2023 return false;
2024
2025 return (!Triple.isMacOSXVersionLT(10,5) &&
2026 (Triple.getArch() == llvm::Triple::x86_64 ||
2027 Triple.getArch() == llvm::Triple::arm));
2028}
2029
Nico Webere8e53112014-05-11 01:04:02 +00002030// exceptionSettings() exists to share the logic between -cc1 and linker
2031// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00002032static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002033 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00002034 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002035 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00002036 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002037
David Majnemer8de68642014-12-05 08:11:58 +00002038 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00002039}
2040
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002041/// Adds exception related arguments to the driver command arguments. There's a
2042/// master flag, -fexceptions and also language specific flags to enable/disable
2043/// C++ and Objective-C exceptions. This makes it possible to for example
2044/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002045static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002046 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002047 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002048 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002049 const Driver &D = TC.getDriver();
2050 const llvm::Triple &Triple = TC.getTriple();
2051
Chad Rosier4fab82c2012-03-26 22:04:46 +00002052 if (KernelOrKext) {
2053 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2054 // arguments now to avoid warnings about unused arguments.
2055 Args.ClaimAllArgs(options::OPT_fexceptions);
2056 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2057 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2058 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2059 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2060 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002061 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002062 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002063
David Majnemer8de68642014-12-05 08:11:58 +00002064 // Gather the exception settings from the command line arguments.
2065 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002066
David Majnemerae394812014-12-09 00:12:30 +00002067 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2068 // is not necessarily sensible, but follows GCC.
2069 if (types::isObjC(InputType) &&
2070 Args.hasFlag(options::OPT_fobjc_exceptions,
2071 options::OPT_fno_objc_exceptions,
2072 true)) {
2073 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002074
David Majnemerae394812014-12-09 00:12:30 +00002075 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002076 }
2077
2078 if (types::isCXX(InputType)) {
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00002079 bool CXXExceptionsEnabled =
2080 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002081 Arg *ExceptionArg = Args.getLastArg(
2082 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2083 options::OPT_fexceptions, options::OPT_fno_exceptions);
2084 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002085 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002086 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2087 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002088
2089 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002090 if (Triple.isPS4CPU()) {
2091 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2092 assert(ExceptionArg &&
2093 "On the PS4 exceptions should only be enabled if passing "
2094 "an argument");
2095 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2096 const Arg *RTTIArg = TC.getRTTIArg();
2097 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2098 D.Diag(diag::err_drv_argument_not_allowed_with)
2099 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2100 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2101 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2102 } else
2103 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2104
Anders Carlssone96ab552011-02-28 02:27:16 +00002105 CmdArgs.push_back("-fcxx-exceptions");
2106
David Majnemer8de68642014-12-05 08:11:58 +00002107 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002108 }
2109 }
2110
David Majnemer8de68642014-12-05 08:11:58 +00002111 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002112 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002113}
2114
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002115static bool ShouldDisableAutolink(const ArgList &Args,
2116 const ToolChain &TC) {
2117 bool Default = true;
2118 if (TC.getTriple().isOSDarwin()) {
2119 // The native darwin assembler doesn't support the linker_option directives,
2120 // so we disable them if we think the .s file will be passed to it.
2121 Default = TC.useIntegratedAs();
2122 }
2123 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2124 Default);
2125}
2126
Ted Kremenek62093662013-03-12 17:02:12 +00002127static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2128 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002129 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
2130 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002131 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002132 return !UseDwarfDirectory;
2133}
2134
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002135/// \brief Check whether the given input tree contains any compilation actions.
2136static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002137 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002138 return true;
2139
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002140 for (const auto &Act : *A)
2141 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002142 return true;
2143
2144 return false;
2145}
2146
2147/// \brief Check if -relax-all should be passed to the internal assembler.
2148/// This is done by default when compiling non-assembler source with -O0.
2149static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2150 bool RelaxDefault = true;
2151
2152 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2153 RelaxDefault = A->getOption().matches(options::OPT_O0);
2154
2155 if (RelaxDefault) {
2156 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002157 for (const auto &Act : C.getActions()) {
2158 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002159 RelaxDefault = true;
2160 break;
2161 }
2162 }
2163 }
2164
2165 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2166 RelaxDefault);
2167}
2168
David Blaikie9260ed62013-07-25 21:19:01 +00002169static void CollectArgsForIntegratedAssembler(Compilation &C,
2170 const ArgList &Args,
2171 ArgStringList &CmdArgs,
2172 const Driver &D) {
2173 if (UseRelaxAll(C, Args))
2174 CmdArgs.push_back("-mrelax-all");
2175
David Peixottodfb66142013-11-14 22:52:58 +00002176 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002177 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002178 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2179 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2180 // arg after parsing the '-I' arg.
2181 bool TakeNextArg = false;
2182
David Blaikie9260ed62013-07-25 21:19:01 +00002183 // When using an integrated assembler, translate -Wa, and -Xassembler
2184 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002185 bool CompressDebugSections = false;
Sean Silva14facf32015-06-09 01:57:17 +00002186 for (const Arg *A :
2187 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
David Blaikie9260ed62013-07-25 21:19:01 +00002188 A->claim();
2189
2190 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2191 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002192 if (TakeNextArg) {
2193 CmdArgs.push_back(Value.data());
2194 TakeNextArg = false;
2195 continue;
2196 }
David Blaikie9260ed62013-07-25 21:19:01 +00002197
2198 if (Value == "-force_cpusubtype_ALL") {
2199 // Do nothing, this is the default and we don't support anything else.
2200 } else if (Value == "-L") {
2201 CmdArgs.push_back("-msave-temp-labels");
2202 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002203 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002204 } else if (Value == "--noexecstack") {
2205 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002206 } else if (Value == "-compress-debug-sections" ||
2207 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002208 CompressDebugSections = true;
2209 } else if (Value == "-nocompress-debug-sections" ||
2210 Value == "--nocompress-debug-sections") {
2211 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002212 } else if (Value.startswith("-I")) {
2213 CmdArgs.push_back(Value.data());
2214 // We need to consume the next argument if the current arg is a plain
2215 // -I. The next arg will be the include directory.
2216 if (Value == "-I")
2217 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002218 } else if (Value.startswith("-gdwarf-")) {
2219 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002220 } else {
2221 D.Diag(diag::err_drv_unsupported_option_argument)
2222 << A->getOption().getName() << Value;
2223 }
2224 }
2225 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002226 if (CompressDebugSections) {
2227 if (llvm::zlib::isAvailable())
2228 CmdArgs.push_back("-compress-debug-sections");
2229 else
2230 D.Diag(diag::warn_debug_compression_unavailable);
2231 }
David Blaikie9260ed62013-07-25 21:19:01 +00002232}
2233
Renato Goline807c122014-01-31 11:47:28 +00002234// Until ARM libraries are build separately, we have them all in one library
2235static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool61770ab2015-01-02 21:47:33 +00002236 // FIXME: handle 64-bit
2237 if (TC.getTriple().isOSWindows() &&
2238 !TC.getTriple().isWindowsItaniumEnvironment())
2239 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002240 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002241 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002242 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002243}
2244
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002245static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2246 // The runtimes are located in the OS-specific resource directory.
2247 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002248 const llvm::Triple &Triple = TC.getTriple();
2249 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002250 StringRef OSLibName =
2251 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002252 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002253 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002254}
2255
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002256static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
Dan Albert6f2875d2015-01-28 23:23:36 +00002257 bool Shared = false) {
2258 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2259 ? "-android"
2260 : "";
2261
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002262 bool IsOSWindows = TC.getTriple().isOSWindows();
2263 StringRef Arch = getArchNameForCompilerRTLib(TC);
2264 const char *Prefix = IsOSWindows ? "" : "lib";
2265 const char *Suffix =
2266 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2267
2268 SmallString<128> Path = getCompilerRTLibDir(TC);
2269 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2270 Arch + Env + Suffix);
2271
2272 return Path;
2273}
2274
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002275// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002276// FIXME: Make sure we can also emit shared objects if they're requested
2277// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002278static void addClangRT(const ToolChain &TC, const ArgList &Args,
2279 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002280 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002281
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002282 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002283 // FIXME: why do we link against gcc when we are using compiler-rt?
2284 CmdArgs.push_back("-lgcc_s");
2285 if (TC.getDriver().CCCIsCXX())
2286 CmdArgs.push_back("-lgcc_eh");
2287 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002288}
2289
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002290static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2291 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002292 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2293 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002294 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002295 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Justin Bognera71e6812015-04-30 23:49:42 +00002296 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002297 Args.hasArg(options::OPT_fcreate_profile) ||
2298 Args.hasArg(options::OPT_coverage)))
2299 return;
2300
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002301 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002302}
2303
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002304namespace {
2305enum OpenMPRuntimeKind {
2306 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2307 /// without knowing what runtime to target.
2308 OMPRT_Unknown,
2309
2310 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2311 /// the default for Clang.
2312 OMPRT_OMP,
2313
2314 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2315 /// this runtime but can swallow the pragmas, and find and link against the
2316 /// runtime library itself.
2317 OMPRT_GOMP,
2318
Chandler Carruthc6625c62015-05-28 21:10:31 +00002319 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002320 /// OpenMP runtime. We support this mode for users with existing dependencies
2321 /// on this runtime library name.
2322 OMPRT_IOMP5
2323};
2324}
2325
2326/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002327static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2328 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002329 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2330
2331 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2332 if (A)
2333 RuntimeName = A->getValue();
2334
2335 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2336 .Case("libomp", OMPRT_OMP)
2337 .Case("libgomp", OMPRT_GOMP)
2338 .Case("libiomp5", OMPRT_IOMP5)
2339 .Default(OMPRT_Unknown);
2340
2341 if (RT == OMPRT_Unknown) {
2342 if (A)
2343 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
2344 << A->getOption().getName() << A->getValue();
2345 else
2346 // FIXME: We could use a nicer diagnostic here.
2347 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2348 }
2349
2350 return RT;
2351}
2352
Alexey Samsonov52550342014-09-15 19:58:40 +00002353static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2354 ArgStringList &CmdArgs, StringRef Sanitizer,
2355 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002356 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002357 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002358 if (!IsShared)
2359 CmdArgs.push_back("-whole-archive");
Dan Albert6f2875d2015-01-28 23:23:36 +00002360 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002361 if (!IsShared)
2362 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002363}
2364
Alexey Samsonov52550342014-09-15 19:58:40 +00002365// Tries to use a file with the list of dynamic symbols that need to be exported
2366// from the runtime library. Returns true if the file was found.
2367static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2368 ArgStringList &CmdArgs,
2369 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002370 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2371 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2372 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002373 return true;
2374 }
2375 return false;
2376}
2377
2378static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2379 ArgStringList &CmdArgs) {
2380 // Force linking against the system libraries sanitizers depends on
2381 // (see PR15823 why this is necessary).
2382 CmdArgs.push_back("--no-as-needed");
2383 CmdArgs.push_back("-lpthread");
2384 CmdArgs.push_back("-lrt");
2385 CmdArgs.push_back("-lm");
2386 // There's no libdl on FreeBSD.
2387 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2388 CmdArgs.push_back("-ldl");
2389}
2390
2391static void
2392collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2393 SmallVectorImpl<StringRef> &SharedRuntimes,
2394 SmallVectorImpl<StringRef> &StaticRuntimes,
2395 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2396 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2397 // Collect shared runtimes.
2398 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2399 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002400 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002401
Alexey Samsonov52550342014-09-15 19:58:40 +00002402 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002403 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002404 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2405 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002406 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002407 }
2408 if (SanArgs.needsAsanRt()) {
2409 if (SanArgs.needsSharedAsanRt()) {
2410 HelperStaticRuntimes.push_back("asan-preinit");
2411 } else {
2412 StaticRuntimes.push_back("asan");
2413 if (SanArgs.linkCXXRuntimes())
2414 StaticRuntimes.push_back("asan_cxx");
2415 }
2416 }
2417 if (SanArgs.needsDfsanRt())
2418 StaticRuntimes.push_back("dfsan");
2419 if (SanArgs.needsLsanRt())
2420 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002421 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002422 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002423 if (SanArgs.linkCXXRuntimes())
2424 StaticRuntimes.push_back("msan_cxx");
2425 }
2426 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002427 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002428 if (SanArgs.linkCXXRuntimes())
2429 StaticRuntimes.push_back("tsan_cxx");
2430 }
Alexey Samsonov52550342014-09-15 19:58:40 +00002431 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002432 StaticRuntimes.push_back("ubsan_standalone");
2433 if (SanArgs.linkCXXRuntimes())
2434 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002435 }
Peter Collingbournec4122c12015-06-15 21:08:13 +00002436 if (SanArgs.needsSafeStackRt())
2437 StaticRuntimes.push_back("safestack");
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002438}
2439
Alexey Samsonov52550342014-09-15 19:58:40 +00002440// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2441// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2442static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002443 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002444 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2445 HelperStaticRuntimes;
2446 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2447 HelperStaticRuntimes);
2448 for (auto RT : SharedRuntimes)
2449 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2450 for (auto RT : HelperStaticRuntimes)
2451 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2452 bool AddExportDynamic = false;
2453 for (auto RT : StaticRuntimes) {
2454 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2455 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2456 }
2457 // If there is a static runtime with no dynamic list, force all the symbols
2458 // to be dynamic to be sure we export sanitizer interface functions.
2459 if (AddExportDynamic)
2460 CmdArgs.push_back("-export-dynamic");
2461 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002462}
2463
Reid Kleckner86ea7702015-02-04 23:45:07 +00002464static bool areOptimizationsEnabled(const ArgList &Args) {
2465 // Find the last -O arg and see if it is non-zero.
2466 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2467 return !A->getOption().matches(options::OPT_O0);
2468 // Defaults to -O0.
2469 return false;
2470}
2471
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002472static bool shouldUseFramePointerForTarget(const ArgList &Args,
2473 const llvm::Triple &Triple) {
Reid Kleckner86ea7702015-02-04 23:45:07 +00002474 // XCore never wants frame pointers, regardless of OS.
2475 if (Triple.getArch() == llvm::Triple::xcore) {
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002476 return false;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002477 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002478
2479 if (Triple.isOSLinux()) {
2480 switch (Triple.getArch()) {
2481 // Don't use a frame pointer on linux if optimizing for certain targets.
2482 case llvm::Triple::mips64:
2483 case llvm::Triple::mips64el:
2484 case llvm::Triple::mips:
2485 case llvm::Triple::mipsel:
2486 case llvm::Triple::systemz:
2487 case llvm::Triple::x86:
2488 case llvm::Triple::x86_64:
2489 return !areOptimizationsEnabled(Args);
2490 default:
2491 return true;
2492 }
2493 }
2494
2495 if (Triple.isOSWindows()) {
2496 switch (Triple.getArch()) {
2497 case llvm::Triple::x86:
2498 return !areOptimizationsEnabled(Args);
2499 default:
2500 // All other supported Windows ISAs use xdata unwind information, so frame
2501 // pointers are not generally useful.
2502 return false;
2503 }
2504 }
2505
2506 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002507}
2508
Rafael Espindola224dd632011-12-14 21:02:23 +00002509static bool shouldUseFramePointer(const ArgList &Args,
2510 const llvm::Triple &Triple) {
2511 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2512 options::OPT_fomit_frame_pointer))
2513 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2514
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002515 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002516}
2517
Eric Christopherb7d97e92013-04-03 01:58:53 +00002518static bool shouldUseLeafFramePointer(const ArgList &Args,
2519 const llvm::Triple &Triple) {
2520 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2521 options::OPT_momit_leaf_frame_pointer))
2522 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2523
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002524 if (Triple.isPS4CPU())
2525 return false;
2526
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002527 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002528}
2529
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002530/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002531static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002532 SmallString<128> cwd;
2533 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002534 CmdArgs.push_back("-fdebug-compilation-dir");
2535 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002536 }
2537}
2538
Eric Christopherd3804002013-02-22 20:12:52 +00002539static const char *SplitDebugName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00002540 const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00002541 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2542 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2543 SmallString<128> T(FinalOutput->getValue());
2544 llvm::sys::path::replace_extension(T, "dwo");
2545 return Args.MakeArgString(T);
2546 } else {
2547 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002548 SmallString<128> T(
2549 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00002550 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00002551 llvm::sys::path::replace_extension(F, "dwo");
2552 T += F;
2553 return Args.MakeArgString(F);
2554 }
2555}
2556
2557static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2558 const Tool &T, const JobAction &JA,
2559 const ArgList &Args, const InputInfo &Output,
2560 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002561 ArgStringList ExtractArgs;
2562 ExtractArgs.push_back("--extract-dwo");
2563
2564 ArgStringList StripArgs;
2565 StripArgs.push_back("--strip-dwo");
2566
2567 // Grabbing the output of the earlier compile step.
2568 StripArgs.push_back(Output.getFilename());
2569 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002570 ExtractArgs.push_back(OutFile);
2571
2572 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002573 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002574
2575 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002576 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002577
2578 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002579 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002580}
2581
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002582/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002583/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2584static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002585 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002586 if (A->getOption().matches(options::OPT_O4) ||
2587 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002588 return true;
2589
2590 if (A->getOption().matches(options::OPT_O0))
2591 return false;
2592
2593 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2594
Rafael Espindola91780de2013-08-26 14:05:41 +00002595 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002596 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002597 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002598 return true;
2599
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002600 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002601 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002602 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002603
2604 unsigned OptLevel = 0;
2605 if (S.getAsInteger(10, OptLevel))
2606 return false;
2607
2608 return OptLevel > 1;
2609 }
2610
2611 return false;
2612}
2613
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002614/// Add -x lang to \p CmdArgs for \p Input.
2615static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2616 ArgStringList &CmdArgs) {
2617 // When using -verify-pch, we don't want to provide the type
2618 // 'precompiled-header' if it was inferred from the file extension
2619 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2620 return;
2621
2622 CmdArgs.push_back("-x");
2623 if (Args.hasArg(options::OPT_rewrite_objc))
2624 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2625 else
2626 CmdArgs.push_back(types::getTypeName(Input.getType()));
2627}
2628
David Majnemerc371ff02015-03-22 08:39:22 +00002629static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002630 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002631 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002632
2633 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002634 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002635
2636 unsigned Build = 0, Factor = 1;
2637 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2638 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002639 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002640}
2641
Rafael Espindola577637a2015-01-03 00:06:04 +00002642// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002643// options that build systems might add but are unused when assembling or only
2644// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002645static void claimNoWarnArgs(const ArgList &Args) {
2646 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002647 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002648 Args.ClaimAllArgs(options::OPT_flto);
2649 Args.ClaimAllArgs(options::OPT_fno_lto);
2650}
2651
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002652static void appendUserToPath(SmallVectorImpl<char> &Result) {
2653#ifdef LLVM_ON_UNIX
2654 const char *Username = getenv("LOGNAME");
2655#else
2656 const char *Username = getenv("USERNAME");
2657#endif
2658 if (Username) {
2659 // Validate that LoginName can be used in a path, and get its length.
2660 size_t Len = 0;
2661 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002662 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002663 Username = nullptr;
2664 break;
2665 }
2666 }
2667
2668 if (Username && Len > 0) {
2669 Result.append(Username, Username + Len);
2670 return;
2671 }
2672 }
2673
2674 // Fallback to user id.
2675#ifdef LLVM_ON_UNIX
2676 std::string UID = llvm::utostr(getuid());
2677#else
2678 // FIXME: Windows seems to have an 'SID' that might work.
2679 std::string UID = "9999";
2680#endif
2681 Result.append(UID.begin(), UID.end());
2682}
2683
David Majnemere11d3732015-06-08 00:22:46 +00002684VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2685 const llvm::Triple &Triple,
2686 const llvm::opt::ArgList &Args,
2687 bool IsWindowsMSVC) {
2688 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2689 IsWindowsMSVC) ||
2690 Args.hasArg(options::OPT_fmsc_version) ||
2691 Args.hasArg(options::OPT_fms_compatibility_version)) {
2692 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2693 const Arg *MSCompatibilityVersion =
2694 Args.getLastArg(options::OPT_fms_compatibility_version);
2695
2696 if (MSCVersion && MSCompatibilityVersion) {
2697 if (D)
2698 D->Diag(diag::err_drv_argument_not_allowed_with)
2699 << MSCVersion->getAsString(Args)
2700 << MSCompatibilityVersion->getAsString(Args);
2701 return VersionTuple();
2702 }
2703
2704 if (MSCompatibilityVersion) {
2705 VersionTuple MSVT;
2706 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2707 D->Diag(diag::err_drv_invalid_value)
2708 << MSCompatibilityVersion->getAsString(Args)
2709 << MSCompatibilityVersion->getValue();
2710 return MSVT;
2711 }
2712
2713 if (MSCVersion) {
2714 unsigned Version = 0;
2715 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2716 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2717 << MSCVersion->getValue();
2718 return getMSCompatibilityVersion(Version);
2719 }
2720
2721 unsigned Major, Minor, Micro;
2722 Triple.getEnvironmentVersion(Major, Minor, Micro);
2723 if (Major || Minor || Micro)
2724 return VersionTuple(Major, Minor, Micro);
2725
2726 return VersionTuple(18);
2727 }
2728 return VersionTuple();
2729}
2730
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002731void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002732 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002733 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002734 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002735 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002736 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2737 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002738 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002739 ArgStringList CmdArgs;
2740
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002741 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002742 bool IsWindowsCygnus =
2743 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002744 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2745
Daniel Dunbare521a892009-03-31 20:53:55 +00002746 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
Artem Belevichba558952015-05-06 18:20:23 +00002747 const InputInfo &Input = Inputs[0];
Daniel Dunbare521a892009-03-31 20:53:55 +00002748
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002749 // Invoke ourselves in -cc1 mode.
2750 //
2751 // FIXME: Implement custom jobs for internal actions.
2752 CmdArgs.push_back("-cc1");
2753
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002754 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002755 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002756 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002757 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002758
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002759 const llvm::Triple TT(TripleStr);
2760 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2761 TT.getArch() == llvm::Triple::thumb)) {
2762 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2763 unsigned Version;
2764 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2765 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002766 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2767 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002768 }
2769
Tim Northover336f1892014-03-29 13:16:12 +00002770 // Push all default warning arguments that are specific to
2771 // the given target. These come before user provided warning options
2772 // are provided.
2773 getToolChain().addClangWarningOptions(CmdArgs);
2774
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002775 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002776 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002777
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002778 if (isa<AnalyzeJobAction>(JA)) {
2779 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2780 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002781 } else if (isa<MigrateJobAction>(JA)) {
2782 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002783 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002784 if (Output.getType() == types::TY_Dependencies)
2785 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002786 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002787 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002788 if (Args.hasArg(options::OPT_rewrite_objc) &&
2789 !Args.hasArg(options::OPT_g_Group))
2790 CmdArgs.push_back("-P");
2791 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002792 } else if (isa<AssembleJobAction>(JA)) {
2793 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002794
David Blaikie9260ed62013-07-25 21:19:01 +00002795 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002796
2797 // Also ignore explicit -force_cpusubtype_ALL option.
2798 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002799 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002800 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002801 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002802
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002803 if (JA.getType() == types::TY_Nothing)
2804 CmdArgs.push_back("-fsyntax-only");
2805 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002806 CmdArgs.push_back("-emit-pch");
2807 else
2808 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002809 } else if (isa<VerifyPCHJobAction>(JA)) {
2810 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002811 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002812 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2813 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002814
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002815 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002816 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002817 } else if (JA.getType() == types::TY_LLVM_IR ||
2818 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002819 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002820 } else if (JA.getType() == types::TY_LLVM_BC ||
2821 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002822 CmdArgs.push_back("-emit-llvm-bc");
2823 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002824 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002825 } else if (JA.getType() == types::TY_AST) {
2826 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002827 } else if (JA.getType() == types::TY_ModuleFile) {
2828 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002829 } else if (JA.getType() == types::TY_RewrittenObjC) {
2830 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002831 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002832 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2833 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002834 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002835 } else {
2836 assert(JA.getType() == types::TY_PP_Asm &&
2837 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002838 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00002839
2840 // Preserve use-list order by default when emitting bitcode, so that
2841 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
2842 // same result as running passes here. For LTO, we don't need to preserve
2843 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00002844 if (JA.getType() == types::TY_LLVM_BC)
2845 CmdArgs.push_back("-emit-llvm-uselists");
Daniel Dunbara3246a02009-03-18 08:07:30 +00002846 }
2847
Justin Bognera88f0122014-06-20 22:59:50 +00002848 // We normally speed up the clang process a bit by skipping destructors at
2849 // exit, but when we're generating diagnostics we can rely on some of the
2850 // cleanup.
2851 if (!C.isForDiagnostics())
2852 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002853
John McCallbb79b5f2010-02-13 03:50:24 +00002854 // Disable the verification pass in -asserts builds.
2855#ifdef NDEBUG
2856 CmdArgs.push_back("-disable-llvm-verifier");
2857#endif
2858
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002859 // Set the main file name, so that debug info works even with
2860 // -save-temps.
2861 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00002862 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002863
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002864 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002865 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002866 if (Args.hasArg(options::OPT_static))
2867 CmdArgs.push_back("-static-define");
2868
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002869 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002870 // Enable region store model by default.
2871 CmdArgs.push_back("-analyzer-store=region");
2872
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002873 // Treat blocks as analysis entry points.
2874 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2875
Ted Kremenek49c79792011-03-24 00:28:47 +00002876 CmdArgs.push_back("-analyzer-eagerly-assume");
2877
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002878 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002879 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002880 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002881
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002882 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002883 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002884
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002885 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002886 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002887
2888 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002889
Artem Belevichba558952015-05-06 18:20:23 +00002890 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00002891 CmdArgs.push_back("-analyzer-checker=cplusplus");
2892
Nico Webere8e53112014-05-11 01:04:02 +00002893 // Enable the following experimental checkers for testing.
2894 CmdArgs.push_back(
2895 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002896 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2897 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2898 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2899 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2900 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002901 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002902
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002903 // Set the output format. The default is plist, for (lame) historical
2904 // reasons.
2905 CmdArgs.push_back("-analyzer-output");
2906 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002907 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002908 else
2909 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002910
Ted Kremenekfe449a22010-03-22 22:32:05 +00002911 // Disable the presentation of standard compiler warnings when
2912 // using --analyze. We only want to show static analyzer diagnostics
2913 // or frontend errors.
2914 CmdArgs.push_back("-w");
2915
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002916 // Add -Xanalyzer arguments when running as analyzer.
2917 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002918 }
2919
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002920 CheckCodeGenerationOptions(D, Args);
2921
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002922 bool PIE = getToolChain().isPIEDefault();
2923 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002924 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002925
Alexey Bataev40e75222014-01-28 06:30:35 +00002926 // Android-specific defaults for PIC/PIE
2927 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002928 switch (getToolChain().getArch()) {
Alexey Bataev40e75222014-01-28 06:30:35 +00002929 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002930 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002931 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002932 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002933 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002934 case llvm::Triple::mips:
2935 case llvm::Triple::mipsel:
2936 case llvm::Triple::mips64:
2937 case llvm::Triple::mips64el:
2938 PIC = true; // "-fpic"
2939 break;
2940
2941 case llvm::Triple::x86:
2942 case llvm::Triple::x86_64:
2943 PIC = true; // "-fPIC"
2944 IsPICLevelTwo = true;
2945 break;
2946
2947 default:
2948 break;
2949 }
2950 }
2951
Brad Smith5b05db82014-06-24 19:51:29 +00002952 // OpenBSD-specific defaults for PIE
2953 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002954 switch (getToolChain().getArch()) {
Brad Smith5b05db82014-06-24 19:51:29 +00002955 case llvm::Triple::mips64:
2956 case llvm::Triple::mips64el:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00002957 case llvm::Triple::sparcel:
Brad Smith5b05db82014-06-24 19:51:29 +00002958 case llvm::Triple::x86:
2959 case llvm::Triple::x86_64:
2960 IsPICLevelTwo = false; // "-fpie"
2961 break;
2962
2963 case llvm::Triple::ppc:
Brad Smithb58159a2015-06-04 08:45:23 +00002964 case llvm::Triple::sparc:
Brad Smith5b05db82014-06-24 19:51:29 +00002965 case llvm::Triple::sparcv9:
2966 IsPICLevelTwo = true; // "-fPIE"
2967 break;
2968
2969 default:
2970 break;
2971 }
2972 }
2973
Alexey Samsonov090301e2013-04-09 12:28:19 +00002974 // For the PIC and PIE flag options, this logic is different from the
2975 // legacy logic in very old versions of GCC, as that logic was just
2976 // a bug no one had ever fixed. This logic is both more rational and
2977 // consistent with GCC's new logic now that the bugs are fixed. The last
2978 // argument relating to either PIC or PIE wins, and no other argument is
2979 // used. If the last argument is any flavor of the '-fno-...' arguments,
2980 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2981 // at the same level.
2982 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2983 options::OPT_fpic, options::OPT_fno_pic,
2984 options::OPT_fPIE, options::OPT_fno_PIE,
2985 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002986 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2987 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002988 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002989 if (LastPICArg) {
2990 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002991 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2992 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2993 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2994 PIC = PIE || O.matches(options::OPT_fPIC) ||
2995 O.matches(options::OPT_fpic);
2996 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2997 O.matches(options::OPT_fPIC);
2998 } else {
2999 PIE = PIC = false;
3000 }
3001 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003002 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00003003
Nick Lewycky609dd662013-10-11 03:33:53 +00003004 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00003005 // specified while enabling PIC enabled level 1 PIC, just force it back to
3006 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
3007 // informal testing).
3008 if (PIC && getToolChain().getTriple().isOSDarwin())
3009 IsPICLevelTwo |= getToolChain().isPICDefault();
3010
Chandler Carruthc0c04552012-04-08 16:40:35 +00003011 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
3012 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00003013 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00003014 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00003015 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00003016 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00003017 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00003018
Chandler Carruth76a943b2012-11-19 03:52:03 +00003019 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3020 // This is a very special mode. It trumps the other modes, almost no one
3021 // uses it, and it isn't even valid on any OS but Darwin.
3022 if (!getToolChain().getTriple().isOSDarwin())
3023 D.Diag(diag::err_drv_unsupported_opt_for_target)
3024 << A->getSpelling() << getToolChain().getTriple().str();
3025
3026 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3027
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003028 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003029 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00003030
Chandler Carruth76a943b2012-11-19 03:52:03 +00003031 // Only a forced PIC mode can cause the actual compile to have PIC defines
3032 // etc., no flags are sufficient. This behavior was selected to closely
3033 // match that of llvm-gcc and Apple GCC before that.
3034 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
3035 CmdArgs.push_back("-pic-level");
3036 CmdArgs.push_back("2");
3037 }
3038 } else {
3039 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
3040 // handled in Clang's IRGen by the -pie-level flag.
3041 CmdArgs.push_back("-mrelocation-model");
3042 CmdArgs.push_back(PIC ? "pic" : "static");
3043
3044 if (PIC) {
3045 CmdArgs.push_back("-pic-level");
3046 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3047 if (PIE) {
3048 CmdArgs.push_back("-pie-level");
3049 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3050 }
3051 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003052 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003053
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003054 CmdArgs.push_back("-mthread-model");
3055 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3056 CmdArgs.push_back(A->getValue());
3057 else
3058 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3059
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003060 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3061
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003062 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3063 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003064 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003065
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003066 // LLVM Code Generator Options.
3067
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003068 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3069 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003070 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3071 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003072 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003073 CmdArgs.push_back(A->getValue());
3074 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003075 }
3076 }
3077
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003078 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3079 StringRef v = A->getValue();
3080 CmdArgs.push_back("-mllvm");
3081 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3082 A->claim();
3083 }
3084
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003085 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3086 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003087 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003088 }
3089
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003090 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3091 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003092 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00003093 D.Diag(diag::err_drv_unsupported_opt_for_target)
3094 << A->getSpelling() << getToolChain().getTriple().str();
3095 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3096 CmdArgs.push_back("-fpcc-struct-return");
3097 } else {
3098 assert(A->getOption().matches(options::OPT_freg_struct_return));
3099 CmdArgs.push_back("-freg-struct-return");
3100 }
3101 }
3102
Roman Divacky65b88cd2011-03-01 17:40:53 +00003103 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
3104 CmdArgs.push_back("-mrtd");
3105
Rafael Espindola224dd632011-12-14 21:02:23 +00003106 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003107 CmdArgs.push_back("-mdisable-fp-elim");
3108 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3109 options::OPT_fno_zero_initialized_in_bss))
3110 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003111
3112 bool OFastEnabled = isOptimizationLevelFast(Args);
3113 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3114 // enabled. This alias option is being used to simplify the hasFlag logic.
3115 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
3116 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003117 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3118 // doesn't do any TBAA.
3119 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003120 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003121 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003122 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003123 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3124 options::OPT_fno_struct_path_tbaa))
3125 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003126 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3127 false))
3128 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00003129 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3130 options::OPT_fno_optimize_sibling_calls))
3131 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003132
Eric Christopher006208c2013-04-04 06:29:47 +00003133 // Handle segmented stacks.
3134 if (Args.hasArg(options::OPT_fsplit_stack))
3135 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003136
3137 // If -Ofast is the optimization level, then -ffast-math should be enabled.
3138 // This alias option is being used to simplify the getLastArg logic.
3139 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
3140 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00003141
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003142 // Handle various floating point optimization flags, mapping them to the
3143 // appropriate LLVM code generation flags. The pattern for all of these is to
3144 // default off the codegen optimizations, and if any flag enables them and no
3145 // flag disables them after the flag enabling them, enable the codegen
3146 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003147 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003148 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003149 options::OPT_ffinite_math_only,
3150 options::OPT_fno_finite_math_only,
3151 options::OPT_fhonor_infinities,
3152 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003153 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3154 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003155 A->getOption().getID() != options::OPT_fhonor_infinities)
3156 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003157 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003158 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003159 options::OPT_ffinite_math_only,
3160 options::OPT_fno_finite_math_only,
3161 options::OPT_fhonor_nans,
3162 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003163 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3164 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003165 A->getOption().getID() != options::OPT_fhonor_nans)
3166 CmdArgs.push_back("-menable-no-nans");
3167
Benjamin Kramerc242ef22012-05-02 14:55:48 +00003168 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3169 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003170 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003171 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003172 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00003173 options::OPT_fno_math_errno)) {
3174 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3175 // However, turning *off* -ffast_math merely restores the toolchain default
3176 // (which may be false).
3177 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3178 A->getOption().getID() == options::OPT_ffast_math ||
3179 A->getOption().getID() == options::OPT_Ofast)
3180 MathErrno = false;
3181 else if (A->getOption().getID() == options::OPT_fmath_errno)
3182 MathErrno = true;
3183 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003184 if (MathErrno)
3185 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003186
3187 // There are several flags which require disabling very specific
3188 // optimizations. Any of these being disabled forces us to turn off the
3189 // entire set of LLVM optimizations, so collect them through all the flag
3190 // madness.
3191 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003192 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003193 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003194 options::OPT_funsafe_math_optimizations,
3195 options::OPT_fno_unsafe_math_optimizations,
3196 options::OPT_fassociative_math,
3197 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003198 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3199 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003200 A->getOption().getID() != options::OPT_fno_associative_math)
3201 AssociativeMath = true;
3202 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003203 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003204 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003205 options::OPT_funsafe_math_optimizations,
3206 options::OPT_fno_unsafe_math_optimizations,
3207 options::OPT_freciprocal_math,
3208 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003209 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3210 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003211 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3212 ReciprocalMath = true;
3213 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003214 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003215 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003216 options::OPT_funsafe_math_optimizations,
3217 options::OPT_fno_unsafe_math_optimizations,
3218 options::OPT_fsigned_zeros,
3219 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003220 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3221 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003222 A->getOption().getID() != options::OPT_fsigned_zeros)
3223 SignedZeros = false;
3224 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003225 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003226 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003227 options::OPT_funsafe_math_optimizations,
3228 options::OPT_fno_unsafe_math_optimizations,
3229 options::OPT_ftrapping_math,
3230 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003231 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3232 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003233 A->getOption().getID() != options::OPT_ftrapping_math)
3234 TrappingMath = false;
3235 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3236 !TrappingMath)
3237 CmdArgs.push_back("-menable-unsafe-fp-math");
3238
Sanjay Patel76c9e092015-01-23 16:40:50 +00003239 if (!SignedZeros)
3240 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003241
Sanjay Patel359b1052015-04-09 15:03:23 +00003242 if (ReciprocalMath)
3243 CmdArgs.push_back("-freciprocal-math");
3244
Lang Hamesaa53b932012-07-06 00:59:19 +00003245 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003246 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003247 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003248 options::OPT_ffp_contract)) {
3249 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003250 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003251 if (Val == "fast" || Val == "on" || Val == "off") {
3252 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3253 } else {
3254 D.Diag(diag::err_drv_unsupported_option_argument)
3255 << A->getOption().getName() << Val;
3256 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003257 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3258 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003259 // If fast-math is set then set the fp-contract mode to fast.
3260 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3261 }
3262 }
Sanjay Patel2987c292015-06-11 14:53:41 +00003263
3264 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00003265
Bob Wilson6a039162012-07-19 03:52:53 +00003266 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3267 // and if we find them, tell the frontend to provide the appropriate
3268 // preprocessor macros. This is distinct from enabling any optimizations as
3269 // these options induce language changes which must survive serialization
3270 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003271 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3272 options::OPT_fno_fast_math))
3273 if (!A->getOption().matches(options::OPT_fno_fast_math))
3274 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003275 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3276 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003277 if (A->getOption().matches(options::OPT_ffinite_math_only))
3278 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003279
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003280 // Decide whether to use verbose asm. Verbose assembly is the default on
3281 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003282 bool IsIntegratedAssemblerDefault =
3283 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003284 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003285 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003286 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003287 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003288
Rafael Espindolab8a12932015-05-22 20:44:03 +00003289 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3290 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003291 CmdArgs.push_back("-no-integrated-as");
3292
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003293 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3294 CmdArgs.push_back("-mdebug-pass");
3295 CmdArgs.push_back("Structure");
3296 }
3297 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3298 CmdArgs.push_back("-mdebug-pass");
3299 CmdArgs.push_back("Arguments");
3300 }
3301
John McCall8517abc2010-02-19 02:45:38 +00003302 // Enable -mconstructor-aliases except on darwin, where we have to
3303 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003304 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003305 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003306
John McCall7ef5cb32011-03-18 02:56:14 +00003307 // Darwin's kernel doesn't support guard variables; just die if we
3308 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003309 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003310 CmdArgs.push_back("-fforbid-guard-variables");
3311
Douglas Gregordbe39272011-02-01 15:15:22 +00003312 if (Args.hasArg(options::OPT_mms_bitfields)) {
3313 CmdArgs.push_back("-mms-bitfields");
3314 }
John McCall8517abc2010-02-19 02:45:38 +00003315
Daniel Dunbar306945d2009-09-16 06:17:29 +00003316 // This is a coarse approximation of what llvm-gcc actually does, both
3317 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3318 // complicated ways.
3319 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003320 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3321 options::OPT_fno_asynchronous_unwind_tables,
3322 (getToolChain().IsUnwindTablesDefault() ||
3323 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3324 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003325 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3326 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003327 CmdArgs.push_back("-munwind-tables");
3328
Chandler Carruth05fb5852012-11-21 23:40:23 +00003329 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003330
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003331 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3332 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003333 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003334 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003335
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003336 // FIXME: Handle -mtune=.
3337 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003338
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003339 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003340 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003341 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003342 }
3343
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003344 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00003345 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003346 if (!CPU.empty()) {
3347 CmdArgs.push_back("-target-cpu");
3348 CmdArgs.push_back(Args.MakeArgString(CPU));
3349 }
3350
Rafael Espindolaeb265472013-08-21 21:59:03 +00003351 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3352 CmdArgs.push_back("-mfpmath");
3353 CmdArgs.push_back(A->getValue());
3354 }
3355
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003356 // Add the target features
John Brawn94fd9632015-05-21 12:19:49 +00003357 getTargetFeatures(D, Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003358
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003359 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003360 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003361 default:
3362 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003363
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003364 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003365 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003366 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003367 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003368 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003369 break;
3370
Tim Northover573cbee2014-05-24 12:52:07 +00003371 case llvm::Triple::aarch64:
3372 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003373 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003374 break;
3375
Eric Christopher0b26a612010-03-02 02:41:08 +00003376 case llvm::Triple::mips:
3377 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003378 case llvm::Triple::mips64:
3379 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003380 AddMIPSTargetArgs(Args, CmdArgs);
3381 break;
3382
Ulrich Weigand8afad612014-07-28 13:17:52 +00003383 case llvm::Triple::ppc:
3384 case llvm::Triple::ppc64:
3385 case llvm::Triple::ppc64le:
3386 AddPPCTargetArgs(Args, CmdArgs);
3387 break;
3388
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003389 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00003390 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00003391 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003392 AddSparcTargetArgs(Args, CmdArgs);
3393 break;
3394
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003395 case llvm::Triple::x86:
3396 case llvm::Triple::x86_64:
3397 AddX86TargetArgs(Args, CmdArgs);
3398 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003399
3400 case llvm::Triple::hexagon:
3401 AddHexagonTargetArgs(Args, CmdArgs);
3402 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003403 }
3404
Hans Wennborg75958c42013-08-08 00:17:41 +00003405 // Add clang-cl arguments.
3406 if (getToolChain().getDriver().IsCLMode())
3407 AddClangCLArgs(Args, CmdArgs);
3408
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003409 // Pass the linker version in use.
3410 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3411 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003412 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003413 }
3414
Eric Christopherb7d97e92013-04-03 01:58:53 +00003415 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003416 CmdArgs.push_back("-momit-leaf-frame-pointer");
3417
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003418 // Explicitly error on some things we know we don't support and can't just
3419 // ignore.
Artem Belevichba558952015-05-06 18:20:23 +00003420 types::ID InputType = Input.getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003421 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3422 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003423 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003424 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003425 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003426 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3427 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003428 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003429 << Unsupported->getOption().getName();
3430 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003431 }
3432
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003433 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003434 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003435 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003436 CmdArgs.push_back("-header-include-file");
3437 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3438 D.CCPrintHeadersFilename : "-");
3439 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003440 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003441 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003442
Chad Rosierbe10f982011-08-02 17:58:04 +00003443 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003444 CmdArgs.push_back("-diagnostic-log-file");
3445 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3446 D.CCLogDiagnosticsFilename : "-");
3447 }
3448
Manman Ren17bdb0f2013-11-20 20:22:14 +00003449 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3450 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003451 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003452 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003453 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3454 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003455 // FIXME: we should support specifying dwarf version with
3456 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003457 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003458 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003459 const llvm::Triple &Triple = getToolChain().getTriple();
3460 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003461 Triple.getOS() == llvm::Triple::FreeBSD ||
3462 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003463 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003464 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003465 CmdArgs.push_back("-gdwarf-2");
3466 else if (A->getOption().matches(options::OPT_gdwarf_3))
3467 CmdArgs.push_back("-gdwarf-3");
3468 else if (A->getOption().matches(options::OPT_gdwarf_4))
3469 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003470 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003471 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003472 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003473 const llvm::Triple &Triple = getToolChain().getTriple();
3474 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003475 Triple.getOS() == llvm::Triple::FreeBSD ||
3476 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003477 CmdArgs.push_back("-gdwarf-2");
3478 else
3479 CmdArgs.push_back("-g");
3480 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003481 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003482
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003483 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3484 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003485 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3486 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003487 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003488
Eric Christopher138c32b2013-09-13 22:37:55 +00003489 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003490 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3491 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003492 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003493 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003494 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003495 CmdArgs.push_back("-g");
3496 CmdArgs.push_back("-backend-option");
3497 CmdArgs.push_back("-split-dwarf=Enable");
3498 }
3499
Eric Christopher138c32b2013-09-13 22:37:55 +00003500 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3501 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3502 CmdArgs.push_back("-backend-option");
3503 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3504 }
Eric Christophereec89c22013-06-18 00:03:50 +00003505
Eric Christopher0d403d22014-02-14 01:27:03 +00003506 // -gdwarf-aranges turns on the emission of the aranges section in the
3507 // backend.
3508 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3509 CmdArgs.push_back("-backend-option");
3510 CmdArgs.push_back("-generate-arange-section");
3511 }
3512
David Blaikief36d9ba2014-01-27 18:52:43 +00003513 if (Args.hasFlag(options::OPT_fdebug_types_section,
3514 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003515 CmdArgs.push_back("-backend-option");
3516 CmdArgs.push_back("-generate-type-units");
3517 }
Eric Christophereec89c22013-06-18 00:03:50 +00003518
Ed Schouten6e576152015-03-26 17:50:28 +00003519 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3520 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3521
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003522 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003523 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003524 CmdArgs.push_back("-ffunction-sections");
3525 }
3526
3527 if (Args.hasFlag(options::OPT_fdata_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003528 options::OPT_fno_data_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003529 CmdArgs.push_back("-fdata-sections");
3530 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003531
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003532 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00003533 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003534 CmdArgs.push_back("-fno-unique-section-names");
3535
Chris Lattner3c77a352010-06-22 00:03:40 +00003536 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3537
Justin Bognera71e6812015-04-30 23:49:42 +00003538 if ((Args.hasArg(options::OPT_fprofile_instr_generate) ||
3539 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)) &&
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003540 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3541 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3542 D.Diag(diag::err_drv_argument_not_allowed_with)
3543 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3544
Justin Bognera71e6812015-04-30 23:49:42 +00003545 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_generate_EQ))
3546 A->render(Args, CmdArgs);
3547 else
3548 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003549
3550 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3551 A->render(Args, CmdArgs);
3552 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3553 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3554
Nick Lewycky207bce32011-04-21 23:44:07 +00003555 if (Args.hasArg(options::OPT_ftest_coverage) ||
3556 Args.hasArg(options::OPT_coverage))
3557 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003558 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3559 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003560 Args.hasArg(options::OPT_coverage))
3561 CmdArgs.push_back("-femit-coverage-data");
3562
Alex Lorenzee024992014-08-04 18:41:51 +00003563 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
Justin Bognera71e6812015-04-30 23:49:42 +00003564 !(Args.hasArg(options::OPT_fprofile_instr_generate) ||
3565 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)))
Alex Lorenzee024992014-08-04 18:41:51 +00003566 D.Diag(diag::err_drv_argument_only_allowed_with)
3567 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3568
3569 if (Args.hasArg(options::OPT_fcoverage_mapping))
3570 CmdArgs.push_back("-fcoverage-mapping");
3571
Nick Lewycky480cb992011-05-04 20:46:58 +00003572 if (C.getArgs().hasArg(options::OPT_c) ||
3573 C.getArgs().hasArg(options::OPT_S)) {
3574 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003575 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003576 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003577 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003578 CoverageFilename = FinalOutput->getValue();
3579 } else {
3580 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3581 }
Yaron Keren92e1b622015-03-18 10:17:07 +00003582 if (llvm::sys::path::is_relative(CoverageFilename)) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003583 SmallString<128> Pwd;
3584 if (!llvm::sys::fs::current_path(Pwd)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00003585 llvm::sys::path::append(Pwd, CoverageFilename);
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003586 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003587 }
3588 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003589 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003590 }
3591 }
3592
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003593 // Pass options for controlling the default header search paths.
3594 if (Args.hasArg(options::OPT_nostdinc)) {
3595 CmdArgs.push_back("-nostdsysteminc");
3596 CmdArgs.push_back("-nobuiltininc");
3597 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003598 if (Args.hasArg(options::OPT_nostdlibinc))
3599 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003600 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3601 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3602 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003603
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003604 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003605 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003606 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003607
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003608 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3609
Ted Kremenekf7639e12012-03-06 20:06:33 +00003610 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003611 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003612 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003613 options::OPT_ccc_arcmt_modify,
3614 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003615 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003616 switch (A->getOption().getID()) {
3617 default:
3618 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003619 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003620 CmdArgs.push_back("-arcmt-check");
3621 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003622 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003623 CmdArgs.push_back("-arcmt-modify");
3624 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003625 case options::OPT_ccc_arcmt_migrate:
3626 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003627 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003628 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003629
3630 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3631 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003632 break;
John McCalld70fb982011-06-15 23:25:17 +00003633 }
3634 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003635 } else {
3636 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3637 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3638 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003639 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003640
Ted Kremenekf7639e12012-03-06 20:06:33 +00003641 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3642 if (ARCMTEnabled) {
3643 D.Diag(diag::err_drv_argument_not_allowed_with)
3644 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3645 }
3646 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003647 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003648
3649 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003650 options::OPT_objcmt_migrate_subscripting,
3651 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003652 // None specified, means enable them all.
3653 CmdArgs.push_back("-objcmt-migrate-literals");
3654 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003655 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003656 } else {
3657 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3658 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003659 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003660 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003661 } else {
3662 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3663 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3664 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3665 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3666 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3667 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00003668 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003669 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3670 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3671 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3672 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3673 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3674 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3675 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003676 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003677 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003678 }
3679
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003680 // Add preprocessing options like -I, -D, etc. if we are using the
3681 // preprocessor.
3682 //
3683 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003684 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003685 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003686
Rafael Espindolaa7431922011-07-21 23:40:37 +00003687 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3688 // that "The compiler can only warn and ignore the option if not recognized".
3689 // When building with ccache, it will pass -D options to clang even on
3690 // preprocessed inputs and configure concludes that -fPIC is not supported.
3691 Args.ClaimAllArgs(options::OPT_D);
3692
Alp Toker7874bdc2013-11-15 20:40:58 +00003693 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003694 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3695 if (A->getOption().matches(options::OPT_O4)) {
3696 CmdArgs.push_back("-O3");
3697 D.Diag(diag::warn_O4_is_O3);
3698 } else {
3699 A->render(Args, CmdArgs);
3700 }
3701 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003702
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003703 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00003704 for (const Arg *A :
3705 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3706 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003707 }
3708
Rafael Espindola577637a2015-01-03 00:06:04 +00003709 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003710
Richard Smith3be1cb22014-08-07 00:24:21 +00003711 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003712 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003713 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3714 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003715 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003716 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003717
3718 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003719 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003720 //
3721 // If a std is supplied, only add -trigraphs if it follows the
3722 // option.
David Majnemer8db91762015-05-18 04:49:30 +00003723 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003724 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3725 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003726 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003727 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003728 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003729 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003730 else
3731 Std->render(Args, CmdArgs);
3732
Nico Weber00721502014-12-23 22:32:37 +00003733 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003734 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003735 options::OPT_ftrigraphs,
3736 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003737 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003738 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003739 } else {
3740 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003741 //
3742 // FIXME: Clang doesn't correctly handle -std= when the input language
3743 // doesn't match. For the time being just ignore this for C++ inputs;
3744 // eventually we want to do all the standard defaulting here instead of
3745 // splitting it between the driver and clang -cc1.
3746 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003747 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3748 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003749 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00003750 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00003751
Nico Weber00721502014-12-23 22:32:37 +00003752 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3753 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003754 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003755
Richard Smith282b4492013-09-04 22:50:31 +00003756 // GCC's behavior for -Wwrite-strings is a bit strange:
3757 // * In C, this "warning flag" changes the types of string literals from
3758 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3759 // for the discarded qualifier.
3760 // * In C++, this is just a normal warning flag.
3761 //
3762 // Implementing this warning correctly in C is hard, so we follow GCC's
3763 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3764 // a non-const char* in C, rather than using this crude hack.
3765 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003766 // FIXME: This should behave just like a warning flag, and thus should also
3767 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3768 Arg *WriteStrings =
3769 Args.getLastArg(options::OPT_Wwrite_strings,
3770 options::OPT_Wno_write_strings, options::OPT_w);
3771 if (WriteStrings &&
3772 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003773 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003774 }
3775
Chandler Carruth61fbf622011-04-23 09:27:53 +00003776 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003777 // during C++ compilation, which it is by default. GCC keeps this define even
3778 // in the presence of '-w', match this behavior bug-for-bug.
3779 if (types::isCXX(InputType) &&
3780 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3781 true)) {
3782 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003783 }
3784
Chandler Carruthe0391482010-05-22 02:21:53 +00003785 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3786 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3787 if (Asm->getOption().matches(options::OPT_fasm))
3788 CmdArgs.push_back("-fgnu-keywords");
3789 else
3790 CmdArgs.push_back("-fno-gnu-keywords");
3791 }
3792
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003793 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3794 CmdArgs.push_back("-fno-dwarf-directory-asm");
3795
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003796 if (ShouldDisableAutolink(Args, getToolChain()))
3797 CmdArgs.push_back("-fno-autolink");
3798
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003799 // Add in -fdebug-compilation-dir if necessary.
3800 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003801
Richard Smith9a568822011-11-21 19:36:32 +00003802 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3803 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003804 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003805 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003806 }
3807
Richard Smith79c927b2013-11-06 19:31:51 +00003808 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3809 CmdArgs.push_back("-foperator-arrow-depth");
3810 CmdArgs.push_back(A->getValue());
3811 }
3812
Richard Smith9a568822011-11-21 19:36:32 +00003813 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3814 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003815 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003816 }
3817
Richard Smitha3d3bd22013-05-08 02:12:03 +00003818 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3819 CmdArgs.push_back("-fconstexpr-steps");
3820 CmdArgs.push_back(A->getValue());
3821 }
3822
Richard Smithb3a14522013-02-22 01:59:51 +00003823 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3824 CmdArgs.push_back("-fbracket-depth");
3825 CmdArgs.push_back(A->getValue());
3826 }
3827
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003828 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3829 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003830 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003831 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003832 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3833 } else
3834 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003835 }
3836
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003837
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003838 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003839 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003840
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003841 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3842 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003843 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003844 }
David Chisnall5778fce2009-08-31 16:41:57 +00003845
Chris Lattnere23003d2010-01-09 21:54:33 +00003846 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3847 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003848 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003849 }
3850
Chris Lattnerb35583d2010-04-07 20:49:23 +00003851 CmdArgs.push_back("-ferror-limit");
3852 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003853 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003854 else
3855 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003856
Chandler Carrutha77a7272010-05-06 04:55:18 +00003857 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3858 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003859 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003860 }
3861
3862 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3863 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003864 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003865 }
3866
Richard Smithf6f003a2011-12-16 19:06:07 +00003867 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3868 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003869 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003870 }
3871
Nick Lewycky24653262014-12-16 21:39:02 +00003872 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3873 CmdArgs.push_back("-fspell-checking-limit");
3874 CmdArgs.push_back(A->getValue());
3875 }
3876
Daniel Dunbar2c978472009-11-04 06:24:47 +00003877 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003878 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003879 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003880 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003881 } else {
3882 // If -fmessage-length=N was not specified, determine whether this is a
3883 // terminal and, if so, implicitly define -fmessage-length appropriately.
3884 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003885 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003886 }
3887
John McCallb4a99d32013-02-19 01:57:35 +00003888 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3889 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3890 options::OPT_fvisibility_ms_compat)) {
3891 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3892 CmdArgs.push_back("-fvisibility");
3893 CmdArgs.push_back(A->getValue());
3894 } else {
3895 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3896 CmdArgs.push_back("-fvisibility");
3897 CmdArgs.push_back("hidden");
3898 CmdArgs.push_back("-ftype-visibility");
3899 CmdArgs.push_back("default");
3900 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003901 }
3902
Douglas Gregor08329632010-06-15 17:05:35 +00003903 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003904
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003905 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3906
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003907 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003908 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3909 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003910 CmdArgs.push_back("-ffreestanding");
3911
Daniel Dunbare357d562009-12-03 18:42:11 +00003912 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003913 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003914 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003915 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3916 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003917 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003918 // AltiVec language extensions aren't relevant for assembling.
3919 if (!isa<PreprocessJobAction>(JA) ||
3920 Output.getType() != types::TY_PP_Asm)
3921 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003922 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3923 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003924
Alexey Bataevdb390212015-05-20 04:24:19 +00003925 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00003926 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3927 options::OPT_fno_openmp, false))
3928 switch (getOpenMPRuntime(getToolChain(), Args)) {
3929 case OMPRT_OMP:
3930 case OMPRT_IOMP5:
3931 // Clang can generate useful OpenMP code for these two runtime libraries.
3932 CmdArgs.push_back("-fopenmp");
3933 break;
3934 default:
3935 // By default, if Clang doesn't know how to generate useful OpenMP code
3936 // for a specific runtime library, we just don't pass the '-fopenmp' flag
3937 // down to the actual compilation.
3938 // FIXME: It would be better to have a mode which *only* omits IR
3939 // generation based on the OpenMP support so that we get consistent
3940 // semantic analysis, etc.
3941 break;
3942 }
Alexey Bataevdb390212015-05-20 04:24:19 +00003943
Peter Collingbourne32701642013-11-01 18:16:25 +00003944 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3945 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003946
Eric Christopher459d2712013-02-19 06:16:53 +00003947 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00003948 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
3949 const llvm::Triple::ArchType Arch = getToolChain().getArch();
3950 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
3951 Arch == llvm::Triple::ppc64le))
3952 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3953 << "ppc/ppc64/ppc64le";
3954 }
Chad Rosier864dfe12012-03-13 23:45:51 +00003955
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003956 if (getToolChain().SupportsProfiling())
3957 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003958
3959 // -flax-vector-conversions is default.
3960 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3961 options::OPT_fno_lax_vector_conversions))
3962 CmdArgs.push_back("-fno-lax-vector-conversions");
3963
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003964 if (Args.getLastArg(options::OPT_fapple_kext))
3965 CmdArgs.push_back("-fapple-kext");
3966
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003967 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003968 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003969 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003970 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3971 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003972
3973 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3974 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003975 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003976 }
3977
Bob Wilson14adb362012-02-03 06:27:22 +00003978 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003979
Chandler Carruth6e501032011-03-27 00:04:55 +00003980 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3981 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3982 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3983 options::OPT_fno_wrapv)) {
3984 if (A->getOption().matches(options::OPT_fwrapv))
3985 CmdArgs.push_back("-fwrapv");
3986 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3987 options::OPT_fno_strict_overflow)) {
3988 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3989 CmdArgs.push_back("-fwrapv");
3990 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003991
3992 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3993 options::OPT_fno_reroll_loops))
3994 if (A->getOption().matches(options::OPT_freroll_loops))
3995 CmdArgs.push_back("-freroll-loops");
3996
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003997 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003998 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3999 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004000
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004001 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4002
Mahesha S6a682be42012-10-27 07:47:56 +00004003
Daniel Dunbar4930e332009-11-17 08:07:36 +00004004 // -stack-protector=0 is default.
4005 unsigned StackProtectorLevel = 0;
Peter Collingbournec4122c12015-06-15 21:08:13 +00004006 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4007 Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4008 Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4009 Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4010 Args.ClaimAllArgs(options::OPT_fstack_protector);
4011 } else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004012 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00004013 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004014 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004015 if (A->getOption().matches(options::OPT_fstack_protector)) {
4016 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
4017 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
4018 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004019 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004020 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004021 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004022 } else {
4023 StackProtectorLevel =
4024 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
4025 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004026 if (StackProtectorLevel) {
4027 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004028 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004029 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004030
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004031 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004032 for (const Arg *A : Args.filtered(options::OPT__param)) {
4033 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004034 if (Str.startswith("ssp-buffer-size=")) {
4035 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004036 CmdArgs.push_back("-stack-protector-buffer-size");
4037 // FIXME: Verify the argument is a valid integer.
4038 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004039 }
Sean Silva14facf32015-06-09 01:57:17 +00004040 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004041 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004042 }
4043
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004044 // Translate -mstackrealign
4045 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4046 false)) {
4047 CmdArgs.push_back("-backend-option");
4048 CmdArgs.push_back("-force-align-stack");
4049 }
4050 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
4051 false)) {
4052 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
4053 }
4054
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004055 if (Args.hasArg(options::OPT_mstack_alignment)) {
4056 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4057 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00004058 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004059
Hans Wennborg77dc2362015-01-20 19:45:50 +00004060 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4061 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4062
4063 if (!Size.empty())
4064 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4065 else
4066 CmdArgs.push_back("-mstack-probe-size=0");
4067 }
4068
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004069 if (getToolChain().getArch() == llvm::Triple::aarch64 ||
4070 getToolChain().getArch() == llvm::Triple::aarch64_be)
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004071 CmdArgs.push_back("-fallow-half-arguments-and-returns");
4072
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004073 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4074 options::OPT_mno_restrict_it)) {
4075 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4076 CmdArgs.push_back("-backend-option");
4077 CmdArgs.push_back("-arm-restrict-it");
4078 } else {
4079 CmdArgs.push_back("-backend-option");
4080 CmdArgs.push_back("-arm-no-restrict-it");
4081 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00004082 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
4083 TT.getArch() == llvm::Triple::thumb)) {
4084 // Windows on ARM expects restricted IT blocks
4085 CmdArgs.push_back("-backend-option");
4086 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004087 }
4088
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00004089 if (TT.getArch() == llvm::Triple::arm ||
4090 TT.getArch() == llvm::Triple::thumb) {
4091 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
4092 options::OPT_mno_long_calls)) {
4093 if (A->getOption().matches(options::OPT_mlong_calls)) {
4094 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00004095 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00004096 }
4097 }
4098 }
4099
Daniel Dunbard18049a2009-04-07 21:16:11 +00004100 // Forward -f options with positive and negative forms; we translate
4101 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00004102 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4103 StringRef fname = A->getValue();
4104 if (!llvm::sys::fs::exists(fname))
4105 D.Diag(diag::err_drv_no_such_file) << fname;
4106 else
4107 A->render(Args, CmdArgs);
4108 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004109
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004110 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00004111 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004112 CmdArgs.push_back("-fapple-kext");
4113 if (!Args.hasArg(options::OPT_fbuiltin))
4114 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00004115 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004116 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004117 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004118 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00004119 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00004120
Nuno Lopes13c88c72009-12-16 16:59:22 +00004121 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4122 options::OPT_fno_assume_sane_operator_new))
4123 CmdArgs.push_back("-fno-assume-sane-operator-new");
4124
Daniel Dunbar4930e332009-11-17 08:07:36 +00004125 // -fblocks=0 is default.
4126 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00004127 getToolChain().IsBlocksDefault()) ||
4128 (Args.hasArg(options::OPT_fgnu_runtime) &&
4129 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4130 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00004131 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00004132
4133 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4134 !getToolChain().hasBlocksRuntime())
4135 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00004136 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004137
Richard Smithffb65082014-09-30 23:10:19 +00004138 // -fmodules enables modules (off by default).
4139 // Users can pass -fno-cxx-modules to turn off modules support for
4140 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00004141 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00004142 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
4143 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4144 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00004145 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00004146 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00004147 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00004148 HaveModules = true;
4149 }
4150 }
4151
Daniel Jasper07e6c402013-08-05 20:26:17 +00004152 // -fmodule-maps enables module map processing (off by default) for header
4153 // checking. It is implied by -fmodules.
4154 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
4155 false)) {
4156 CmdArgs.push_back("-fmodule-maps");
4157 }
4158
Daniel Jasperac42b752013-10-21 06:34:34 +00004159 // -fmodules-decluse checks that modules used are declared so (off by
4160 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004161 if (Args.hasFlag(options::OPT_fmodules_decluse,
4162 options::OPT_fno_modules_decluse,
4163 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00004164 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004165 }
4166
Daniel Jasper962b38e2014-04-11 11:47:45 +00004167 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4168 // all #included headers are part of modules.
4169 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4170 options::OPT_fno_modules_strict_decluse,
4171 false)) {
4172 CmdArgs.push_back("-fmodules-strict-decluse");
4173 }
4174
Manuel Klimekd2e8b042015-02-20 11:44:41 +00004175 // -fno-implicit-modules turns off implicitly compiling modules on demand.
4176 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4177 options::OPT_fno_implicit_modules)) {
4178 CmdArgs.push_back("-fno-implicit-modules");
4179 }
4180
Daniel Jasperac42b752013-10-21 06:34:34 +00004181 // -fmodule-name specifies the module that is currently being built (or
4182 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00004183 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00004184
Richard Smith9887d792014-10-17 01:42:53 +00004185 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00004186 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00004187 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00004188
Richard Smithe842a472014-10-22 02:05:46 +00004189 // -fmodule-file can be used to specify files containing precompiled modules.
4190 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4191
4192 // -fmodule-cache-path specifies where our implicitly-built module files
4193 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00004194 SmallString<128> ModuleCachePath;
4195 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4196 ModuleCachePath = A->getValue();
4197 if (HaveModules) {
4198 if (C.isForDiagnostics()) {
4199 // When generating crash reports, we want to emit the modules along with
4200 // the reproduction sources, so we ignore any provided module path.
4201 ModuleCachePath = Output.getFilename();
4202 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
4203 llvm::sys::path::append(ModuleCachePath, "modules");
4204 } else if (ModuleCachePath.empty()) {
4205 // No module path was provided: use the default.
4206 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
4207 ModuleCachePath);
Ben Langmuir3b7b5402015-02-03 19:28:37 +00004208 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang.");
4209 appendUserToPath(ModuleCachePath);
Justin Bognera88f0122014-06-20 22:59:50 +00004210 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
4211 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004212 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00004213 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
4214 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
4215 }
4216
4217 // When building modules and generating crashdumps, we need to dump a module
4218 // dependency VFS alongside the output.
4219 if (HaveModules && C.isForDiagnostics()) {
4220 SmallString<128> VFSDir(Output.getFilename());
4221 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004222 // Add the cache directory as a temp so the crash diagnostics pick it up.
4223 C.addTempFile(Args.MakeArgString(VFSDir));
4224
Justin Bognera88f0122014-06-20 22:59:50 +00004225 llvm::sys::path::append(VFSDir, "vfs");
4226 CmdArgs.push_back("-module-dependency-dir");
4227 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004228 }
4229
Richard Smith9887d792014-10-17 01:42:53 +00004230 if (HaveModules)
4231 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004232
Douglas Gregor35b04d62013-02-07 19:01:24 +00004233 // Pass through all -fmodules-ignore-macro arguments.
4234 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004235 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4236 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004237
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004238 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4239
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004240 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4241 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4242 D.Diag(diag::err_drv_argument_not_allowed_with)
4243 << A->getAsString(Args) << "-fbuild-session-timestamp";
4244
4245 llvm::sys::fs::file_status Status;
4246 if (llvm::sys::fs::status(A->getValue(), Status))
4247 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004248 CmdArgs.push_back(Args.MakeArgString(
4249 "-fbuild-session-timestamp=" +
4250 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004251 }
4252
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004253 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004254 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4255 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004256 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4257
4258 Args.AddLastArg(CmdArgs,
4259 options::OPT_fmodules_validate_once_per_build_session);
4260 }
4261
Ben Langmuirdcf73862014-03-12 00:06:17 +00004262 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4263
John McCalldfea9982010-04-09 19:12:06 +00004264 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004265 if (Args.hasFlag(options::OPT_fno_access_control,
4266 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00004267 false))
John McCall3155f572010-04-09 19:03:51 +00004268 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004269
Anders Carlssond470fef2010-11-21 00:09:52 +00004270 // -felide-constructors is the default.
4271 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4272 options::OPT_felide_constructors,
4273 false))
4274 CmdArgs.push_back("-fno-elide-constructors");
4275
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004276 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004277
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004278 if (KernelOrKext || (types::isCXX(InputType) &&
4279 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4280 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004281 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004282
Tony Linthicum76329bf2011-12-12 21:14:55 +00004283 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004284 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00004285 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004286 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00004287 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004288 CmdArgs.push_back("-fshort-enums");
4289
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004290 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00004291 if (Arg *A = Args.getLastArg(
4292 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4293 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4294 if (A->getOption().matches(options::OPT_funsigned_char) ||
4295 A->getOption().matches(options::OPT_fno_signed_char)) {
4296 CmdArgs.push_back("-fno-signed-char");
4297 }
4298 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004299 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00004300 }
Eli Friedman327f0b52009-06-05 07:21:14 +00004301
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004302 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004303 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4304 options::OPT_fno_use_cxa_atexit,
4305 !IsWindowsCygnus && !IsWindowsGNU &&
4306 getToolChain().getArch() != llvm::Triple::hexagon &&
4307 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004308 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004309 CmdArgs.push_back("-fno-use-cxa-atexit");
4310
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004311 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004312 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004313 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004314 CmdArgs.push_back("-fms-extensions");
4315
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004316 // -fno-use-line-directives is default.
4317 if (Args.hasFlag(options::OPT_fuse_line_directives,
4318 options::OPT_fno_use_line_directives, false))
4319 CmdArgs.push_back("-fuse-line-directives");
4320
Francois Pichet1b4f1632011-09-17 04:32:15 +00004321 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004322 if (Args.hasFlag(options::OPT_fms_compatibility,
4323 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004324 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
4325 options::OPT_fno_ms_extensions,
4326 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004327 CmdArgs.push_back("-fms-compatibility");
4328
David Majnemerc371ff02015-03-22 08:39:22 +00004329 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00004330 VersionTuple MSVT = visualstudio::getMSVCVersion(
4331 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4332 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00004333 CmdArgs.push_back(
4334 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004335
David Majnemer8db91762015-05-18 04:49:30 +00004336 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4337 if (ImplyVCPPCXXVer) {
4338 if (IsMSVC2015Compatible)
4339 CmdArgs.push_back("-std=c++14");
4340 else
4341 CmdArgs.push_back("-std=c++11");
4342 }
4343
Eric Christopher5ecce122013-02-18 00:38:31 +00004344 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004345 if (Args.hasFlag(options::OPT_fborland_extensions,
4346 options::OPT_fno_borland_extensions, false))
4347 CmdArgs.push_back("-fborland-extensions");
4348
David Majnemerc371ff02015-03-22 08:39:22 +00004349 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4350 // than 19.
4351 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4352 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00004353 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00004354 CmdArgs.push_back("-fno-threadsafe-statics");
4355
Francois Pichet02744872011-09-01 16:38:08 +00004356 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4357 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004358 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004359 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004360 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004361
Chandler Carruthe03aa552010-04-17 20:17:31 +00004362 // -fgnu-keywords default varies depending on language; only pass if
4363 // specified.
4364 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004365 options::OPT_fno_gnu_keywords))
4366 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004367
Rafael Espindola922a6242011-06-02 17:30:53 +00004368 if (Args.hasFlag(options::OPT_fgnu89_inline,
4369 options::OPT_fno_gnu89_inline,
4370 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004371 CmdArgs.push_back("-fgnu89-inline");
4372
Chad Rosier9c76d242012-03-15 22:31:42 +00004373 if (Args.hasArg(options::OPT_fno_inline))
4374 CmdArgs.push_back("-fno-inline");
4375
Chad Rosier64d6be92012-03-06 21:17:19 +00004376 if (Args.hasArg(options::OPT_fno_inline_functions))
4377 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004378
John McCall5fb5df92012-06-20 06:18:46 +00004379 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004380
John McCall5fb5df92012-06-20 06:18:46 +00004381 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004382 // legacy is the default. Except for deployment taget of 10.5,
4383 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4384 // gets ignored silently.
4385 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004386 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4387 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004388 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004389 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004390 if (getToolChain().UseObjCMixedDispatch())
4391 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4392 else
4393 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4394 }
4395 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004396
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004397 // When ObjectiveC legacy runtime is in effect on MacOSX,
4398 // turn on the option to do Array/Dictionary subscripting
4399 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004400 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004401 getToolChain().getTriple().isMacOSX() &&
4402 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4403 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004404 objcRuntime.isNeXTFamily())
4405 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4406
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004407 // -fencode-extended-block-signature=1 is default.
4408 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4409 CmdArgs.push_back("-fencode-extended-block-signature");
4410 }
4411
John McCall24fc0de2011-07-06 00:26:06 +00004412 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4413 // NOTE: This logic is duplicated in ToolChains.cpp.
4414 bool ARC = isObjCAutoRefCount(Args);
4415 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004416 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004417
John McCall24fc0de2011-07-06 00:26:06 +00004418 CmdArgs.push_back("-fobjc-arc");
4419
Chandler Carruth491db322011-11-04 07:34:47 +00004420 // FIXME: It seems like this entire block, and several around it should be
4421 // wrapped in isObjC, but for now we just use it here as this is where it
4422 // was being used previously.
4423 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4424 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4425 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4426 else
4427 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4428 }
4429
John McCall24fc0de2011-07-06 00:26:06 +00004430 // Allow the user to enable full exceptions code emission.
4431 // We define off for Objective-CC, on for Objective-C++.
4432 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4433 options::OPT_fno_objc_arc_exceptions,
4434 /*default*/ types::isCXX(InputType)))
4435 CmdArgs.push_back("-fobjc-arc-exceptions");
4436 }
4437
4438 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4439 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004440 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004441 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004442
John McCall24fc0de2011-07-06 00:26:06 +00004443 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4444 // takes precedence.
4445 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4446 if (!GCArg)
4447 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4448 if (GCArg) {
4449 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004450 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004451 << GCArg->getAsString(Args);
4452 } else if (getToolChain().SupportsObjCGC()) {
4453 GCArg->render(Args, CmdArgs);
4454 } else {
4455 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004456 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004457 << GCArg->getAsString(Args);
4458 }
4459 }
4460
Bob Wilsonb111ec92015-03-02 19:01:14 +00004461 if (Args.hasFlag(options::OPT_fapplication_extension,
4462 options::OPT_fno_application_extension, false))
4463 CmdArgs.push_back("-fapplication-extension");
4464
Reid Klecknerc542d372014-06-27 17:02:02 +00004465 // Handle GCC-style exception args.
4466 if (!C.getDriver().IsCLMode())
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004467 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext,
Reid Klecknerc542d372014-06-27 17:02:02 +00004468 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004469
4470 if (getToolChain().UseSjLjExceptions())
4471 CmdArgs.push_back("-fsjlj-exceptions");
4472
4473 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004474 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4475 options::OPT_fno_assume_sane_operator_new))
4476 CmdArgs.push_back("-fno-assume-sane-operator-new");
4477
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004478 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4479 // most platforms.
4480 if (Args.hasFlag(options::OPT_fsized_deallocation,
4481 options::OPT_fno_sized_deallocation, false))
4482 CmdArgs.push_back("-fsized-deallocation");
4483
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004484 // -fconstant-cfstrings is default, and may be subject to argument translation
4485 // on Darwin.
4486 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4487 options::OPT_fno_constant_cfstrings) ||
4488 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4489 options::OPT_mno_constant_cfstrings))
4490 CmdArgs.push_back("-fno-constant-cfstrings");
4491
John Thompsoned4e2952009-11-05 20:14:16 +00004492 // -fshort-wchar default varies depending on platform; only
4493 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004494 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4495 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004496 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004497
Hans Wennborg28c96312013-07-31 23:39:13 +00004498 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004499 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004500 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004501 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004502 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004503
Daniel Dunbar096ed292011-10-05 21:04:55 +00004504 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4505 // -fno-pack-struct doesn't apply to -fpack-struct=.
4506 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004507 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004508 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004509 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004510 } else if (Args.hasFlag(options::OPT_fpack_struct,
4511 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004512 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004513 }
4514
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004515 // Handle -fmax-type-align=N and -fno-type-align
4516 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4517 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4518 if (!SkipMaxTypeAlign) {
4519 std::string MaxTypeAlignStr = "-fmax-type-align=";
4520 MaxTypeAlignStr += A->getValue();
4521 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4522 }
4523 } else if (getToolChain().getTriple().isOSDarwin()) {
4524 if (!SkipMaxTypeAlign) {
4525 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4526 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4527 }
4528 }
4529
Robert Lytton0e076492013-08-13 09:43:10 +00004530 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004531 if (!Args.hasArg(options::OPT_fcommon))
4532 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004533 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004534 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004535
Daniel Dunbard18049a2009-04-07 21:16:11 +00004536 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004537 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004538 CmdArgs.push_back("-fno-common");
4539
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004540 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004541 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004542 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004543 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004544 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004545 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4546
Daniel Dunbar6358d682010-10-15 22:30:42 +00004547 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4548 if (!Args.hasFlag(options::OPT_ffor_scope,
4549 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004550 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004551 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4552
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004553 // -finput_charset=UTF-8 is default. Reject others
4554 if (Arg *inputCharset = Args.getLastArg(
4555 options::OPT_finput_charset_EQ)) {
4556 StringRef value = inputCharset->getValue();
4557 if (value != "UTF-8")
4558 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4559 }
4560
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004561 // -fexec_charset=UTF-8 is default. Reject others
4562 if (Arg *execCharset = Args.getLastArg(
4563 options::OPT_fexec_charset_EQ)) {
4564 StringRef value = execCharset->getValue();
4565 if (value != "UTF-8")
4566 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4567 }
4568
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004569 // -fcaret-diagnostics is default.
4570 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4571 options::OPT_fno_caret_diagnostics, true))
4572 CmdArgs.push_back("-fno-caret-diagnostics");
4573
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004574 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004575 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004576 options::OPT_fno_diagnostics_fixit_info))
4577 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004578
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004579 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004580 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004581 options::OPT_fno_diagnostics_show_option))
4582 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004583
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004584 if (const Arg *A =
4585 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4586 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004587 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004588 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004589
Douglas Gregor643c9222011-05-21 17:07:29 +00004590 if (const Arg *A =
4591 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4592 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004593 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004594 }
4595
Chandler Carruthb6766f02011-03-27 01:50:55 +00004596 if (Arg *A = Args.getLastArg(
4597 options::OPT_fdiagnostics_show_note_include_stack,
4598 options::OPT_fno_diagnostics_show_note_include_stack)) {
4599 if (A->getOption().matches(
4600 options::OPT_fdiagnostics_show_note_include_stack))
4601 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4602 else
4603 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4604 }
4605
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004606 // Color diagnostics are the default, unless the terminal doesn't support
4607 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004608 // Support both clang's -f[no-]color-diagnostics and gcc's
4609 // -f[no-]diagnostics-colors[=never|always|auto].
4610 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004611 for (const auto &Arg : Args) {
4612 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004613 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4614 !O.matches(options::OPT_fdiagnostics_color) &&
4615 !O.matches(options::OPT_fno_color_diagnostics) &&
4616 !O.matches(options::OPT_fno_diagnostics_color) &&
4617 !O.matches(options::OPT_fdiagnostics_color_EQ))
4618 continue;
4619
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004620 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004621 if (O.matches(options::OPT_fcolor_diagnostics) ||
4622 O.matches(options::OPT_fdiagnostics_color)) {
4623 ShowColors = Colors_On;
4624 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4625 O.matches(options::OPT_fno_diagnostics_color)) {
4626 ShowColors = Colors_Off;
4627 } else {
4628 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004629 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004630 if (value == "always")
4631 ShowColors = Colors_On;
4632 else if (value == "never")
4633 ShowColors = Colors_Off;
4634 else if (value == "auto")
4635 ShowColors = Colors_Auto;
4636 else
4637 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4638 << ("-fdiagnostics-color=" + value).str();
4639 }
4640 }
4641 if (ShowColors == Colors_On ||
4642 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004643 CmdArgs.push_back("-fcolor-diagnostics");
4644
Nico Rieck7857d462013-09-11 00:38:02 +00004645 if (Args.hasArg(options::OPT_fansi_escape_codes))
4646 CmdArgs.push_back("-fansi-escape-codes");
4647
Daniel Dunbardb097022009-06-08 21:13:54 +00004648 if (!Args.hasFlag(options::OPT_fshow_source_location,
4649 options::OPT_fno_show_source_location))
4650 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004651
Douglas Gregor643c9222011-05-21 17:07:29 +00004652 if (!Args.hasFlag(options::OPT_fshow_column,
4653 options::OPT_fno_show_column,
4654 true))
4655 CmdArgs.push_back("-fno-show-column");
4656
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004657 if (!Args.hasFlag(options::OPT_fspell_checking,
4658 options::OPT_fno_spell_checking))
4659 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004660
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004661
Chad Rosierc8e56e82012-12-05 21:08:21 +00004662 // -fno-asm-blocks is default.
4663 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4664 false))
4665 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004666
Steven Wucb0d13f2015-01-16 23:05:28 +00004667 // -fgnu-inline-asm is default.
4668 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4669 options::OPT_fno_gnu_inline_asm, true))
4670 CmdArgs.push_back("-fno-gnu-inline-asm");
4671
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004672 // Enable vectorization per default according to the optimization level
4673 // selected. For optimization levels that want vectorization we use the alias
4674 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004675 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004676 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004677 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004678 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004679 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004680 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004681
Chad Rosier136d67d2014-04-28 19:30:57 +00004682 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004683 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4684 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004685 options::OPT_fslp_vectorize;
4686 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004687 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004688 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004689
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004690 // -fno-slp-vectorize-aggressive is default.
4691 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004692 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004693 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004694
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004695 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4696 A->render(Args, CmdArgs);
4697
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004698 // -fdollars-in-identifiers default varies depending on platform and
4699 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004700 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004701 options::OPT_fno_dollars_in_identifiers)) {
4702 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004703 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004704 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004705 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004706 }
4707
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004708 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4709 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004710 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004711 options::OPT_fno_unit_at_a_time)) {
4712 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004713 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004714 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004715
Eli Friedman055c9702011-11-02 01:53:16 +00004716 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4717 options::OPT_fno_apple_pragma_pack, false))
4718 CmdArgs.push_back("-fapple-pragma-pack");
4719
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004720 // le32-specific flags:
4721 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4722 // by default.
4723 if (getToolChain().getArch() == llvm::Triple::le32) {
4724 CmdArgs.push_back("-fno-math-builtin");
4725 }
4726
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004727 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004728 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004729 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004730#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004731 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004732 (getToolChain().getArch() == llvm::Triple::arm ||
4733 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004734 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4735 CmdArgs.push_back("-fno-builtin-strcat");
4736 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4737 CmdArgs.push_back("-fno-builtin-strcpy");
4738 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004739#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004740
Justin Bognera88f0122014-06-20 22:59:50 +00004741 // Enable rewrite includes if the user's asked for it or if we're generating
4742 // diagnostics.
4743 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4744 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004745 if (Args.hasFlag(options::OPT_frewrite_includes,
4746 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004747 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004748 CmdArgs.push_back("-frewrite-includes");
4749
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004750 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004751 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004752 options::OPT_traditional_cpp)) {
4753 if (isa<PreprocessJobAction>(JA))
4754 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004755 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004756 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004757 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004758
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004759 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004760 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004761
4762 // Handle serialized diagnostics.
4763 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4764 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004765 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004766 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004767
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004768 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4769 CmdArgs.push_back("-fretain-comments-from-system-headers");
4770
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004771 // Forward -fcomment-block-commands to -cc1.
4772 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004773 // Forward -fparse-all-comments to -cc1.
4774 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004775
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004776 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4777 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004778 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004779 bool OptDisabled = false;
Sean Silva14facf32015-06-09 01:57:17 +00004780 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
4781 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004782
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004783 // We translate this by hand to the -cc1 argument, since nightly test uses
4784 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00004785 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004786 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004787 OptDisabled = true;
4788 } else
Sean Silva14facf32015-06-09 01:57:17 +00004789 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004790 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004791
Bob Wilson23a55f12014-12-21 07:00:00 +00004792 // With -save-temps, we want to save the unoptimized bitcode output from the
4793 // CompileJobAction, so disable optimizations if they are not already
4794 // disabled.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00004795 if (C.getDriver().isSaveTempsEnabled() && !OptDisabled &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004796 isa<CompileJobAction>(JA))
4797 CmdArgs.push_back("-disable-llvm-optzns");
4798
Daniel Dunbard67a3222009-03-30 06:36:42 +00004799 if (Output.getType() == types::TY_Dependencies) {
4800 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004801 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004802 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004803 CmdArgs.push_back(Output.getFilename());
4804 } else {
4805 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004806 }
4807
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004808 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004809 addDashXForInput(Args, II, CmdArgs);
4810
Daniel Dunbarb440f562010-08-02 02:38:21 +00004811 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004812 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004813 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004814 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004815 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004816
Chris Lattnere9d7d782009-11-03 19:50:27 +00004817 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4818
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004819 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004820
4821 // Optionally embed the -cc1 level arguments into the debug info, for build
4822 // analysis.
4823 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004824 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004825 for (const auto &Arg : Args)
4826 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004827
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004828 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004829 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004830 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004831 SmallString<128> EscapedArg;
4832 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004833 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004834 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004835 }
4836 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00004837 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004838 }
4839
Eric Christopherd3804002013-02-22 20:12:52 +00004840 // Add the split debug info name to the command lines here so we
4841 // can propagate it to the backend.
4842 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004843 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004844 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4845 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004846 const char *SplitDwarfOut;
4847 if (SplitDwarf) {
4848 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00004849 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00004850 CmdArgs.push_back(SplitDwarfOut);
4851 }
4852
4853 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004854 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004855 Output.getType() == types::TY_Object &&
4856 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004857 auto CLCommand =
4858 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4859 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4860 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004861 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004862 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004863 }
4864
Daniel Dunbar17731772009-03-23 19:03:36 +00004865
Eric Christopherf1545832013-02-22 23:50:16 +00004866 // Handle the debug info splitting at object creation time if we're
4867 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004868 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004869 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004870 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004871
Roman Divacky178e01602011-02-10 16:52:03 +00004872 if (Arg *A = Args.getLastArg(options::OPT_pg))
4873 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004874 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004875 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004876
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004877 // Claim some arguments which clang supports automatically.
4878
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004879 // -fpch-preprocess is used with gcc to add a special marker in the output to
4880 // include the PCH file. Clang's PTH solution is completely transparent, so we
4881 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004882 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004883
Daniel Dunbar17731772009-03-23 19:03:36 +00004884 // Claim some arguments which clang doesn't support, but we don't
4885 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004886 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4887 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004888
Rafael Espindolab0092d72013-09-04 19:37:35 +00004889 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004890 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004891}
4892
John McCall5fb5df92012-06-20 06:18:46 +00004893/// Add options related to the Objective-C runtime/ABI.
4894///
4895/// Returns true if the runtime is non-fragile.
4896ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4897 ArgStringList &cmdArgs,
4898 RewriteKind rewriteKind) const {
4899 // Look for the controlling runtime option.
4900 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4901 options::OPT_fgnu_runtime,
4902 options::OPT_fobjc_runtime_EQ);
4903
4904 // Just forward -fobjc-runtime= to the frontend. This supercedes
4905 // options about fragility.
4906 if (runtimeArg &&
4907 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4908 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004909 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004910 if (runtime.tryParse(value)) {
4911 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4912 << value;
4913 }
4914
4915 runtimeArg->render(args, cmdArgs);
4916 return runtime;
4917 }
4918
4919 // Otherwise, we'll need the ABI "version". Version numbers are
4920 // slightly confusing for historical reasons:
4921 // 1 - Traditional "fragile" ABI
4922 // 2 - Non-fragile ABI, version 1
4923 // 3 - Non-fragile ABI, version 2
4924 unsigned objcABIVersion = 1;
4925 // If -fobjc-abi-version= is present, use that to set the version.
4926 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004927 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004928 if (value == "1")
4929 objcABIVersion = 1;
4930 else if (value == "2")
4931 objcABIVersion = 2;
4932 else if (value == "3")
4933 objcABIVersion = 3;
4934 else
4935 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4936 << value;
4937 } else {
4938 // Otherwise, determine if we are using the non-fragile ABI.
4939 bool nonFragileABIIsDefault =
4940 (rewriteKind == RK_NonFragile ||
4941 (rewriteKind == RK_None &&
4942 getToolChain().IsObjCNonFragileABIDefault()));
4943 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4944 options::OPT_fno_objc_nonfragile_abi,
4945 nonFragileABIIsDefault)) {
4946 // Determine the non-fragile ABI version to use.
4947#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4948 unsigned nonFragileABIVersion = 1;
4949#else
4950 unsigned nonFragileABIVersion = 2;
4951#endif
4952
4953 if (Arg *abiArg = args.getLastArg(
4954 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004955 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004956 if (value == "1")
4957 nonFragileABIVersion = 1;
4958 else if (value == "2")
4959 nonFragileABIVersion = 2;
4960 else
4961 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4962 << value;
4963 }
4964
4965 objcABIVersion = 1 + nonFragileABIVersion;
4966 } else {
4967 objcABIVersion = 1;
4968 }
4969 }
4970
4971 // We don't actually care about the ABI version other than whether
4972 // it's non-fragile.
4973 bool isNonFragile = objcABIVersion != 1;
4974
4975 // If we have no runtime argument, ask the toolchain for its default runtime.
4976 // However, the rewriter only really supports the Mac runtime, so assume that.
4977 ObjCRuntime runtime;
4978 if (!runtimeArg) {
4979 switch (rewriteKind) {
4980 case RK_None:
4981 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4982 break;
4983 case RK_Fragile:
4984 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4985 break;
4986 case RK_NonFragile:
4987 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4988 break;
4989 }
4990
4991 // -fnext-runtime
4992 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4993 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004994 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004995 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4996
4997 // Otherwise, build for a generic macosx port.
4998 } else {
4999 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5000 }
5001
5002 // -fgnu-runtime
5003 } else {
5004 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00005005 // Legacy behaviour is to target the gnustep runtime if we are i
5006 // non-fragile mode or the GCC runtime in fragile mode.
5007 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00005008 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00005009 else
5010 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00005011 }
5012
5013 cmdArgs.push_back(args.MakeArgString(
5014 "-fobjc-runtime=" + runtime.getAsString()));
5015 return runtime;
5016}
5017
Reid Klecknerc542d372014-06-27 17:02:02 +00005018static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5019 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5020 I += HaveDash;
5021 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00005022}
Reid Klecknerc542d372014-06-27 17:02:02 +00005023
5024struct EHFlags {
5025 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
5026 bool Synch;
5027 bool Asynch;
5028 bool NoExceptC;
5029};
5030
5031/// /EH controls whether to run destructor cleanups when exceptions are
5032/// thrown. There are three modifiers:
5033/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5034/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5035/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
5036/// - c: Assume that extern "C" functions are implicitly noexcept. This
5037/// modifier is an optimization, so we ignore it for now.
5038/// The default is /EHs-c-, meaning cleanups are disabled.
5039static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5040 EHFlags EH;
5041 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
5042 for (auto EHVal : EHArgs) {
5043 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
5044 switch (EHVal[I]) {
5045 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
5046 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
5047 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
5048 default: break;
5049 }
5050 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
5051 break;
5052 }
5053 }
5054 return EH;
5055}
5056
Hans Wennborg75958c42013-08-08 00:17:41 +00005057void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
5058 unsigned RTOptionID = options::OPT__SLASH_MT;
5059
Hans Wennborgf1a74252013-09-10 20:18:04 +00005060 if (Args.hasArg(options::OPT__SLASH_LDd))
5061 // The /LDd option implies /MTd. The dependent lib part can be overridden,
5062 // but defining _DEBUG is sticky.
5063 RTOptionID = options::OPT__SLASH_MTd;
5064
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00005065 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00005066 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00005067
Hans Wennborg75958c42013-08-08 00:17:41 +00005068 switch(RTOptionID) {
5069 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00005070 if (Args.hasArg(options::OPT__SLASH_LDd))
5071 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00005072 CmdArgs.push_back("-D_MT");
5073 CmdArgs.push_back("-D_DLL");
5074 CmdArgs.push_back("--dependent-lib=msvcrt");
5075 break;
5076 case options::OPT__SLASH_MDd:
5077 CmdArgs.push_back("-D_DEBUG");
5078 CmdArgs.push_back("-D_MT");
5079 CmdArgs.push_back("-D_DLL");
5080 CmdArgs.push_back("--dependent-lib=msvcrtd");
5081 break;
5082 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00005083 if (Args.hasArg(options::OPT__SLASH_LDd))
5084 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00005085 CmdArgs.push_back("-D_MT");
5086 CmdArgs.push_back("--dependent-lib=libcmt");
5087 break;
5088 case options::OPT__SLASH_MTd:
5089 CmdArgs.push_back("-D_DEBUG");
5090 CmdArgs.push_back("-D_MT");
5091 CmdArgs.push_back("--dependent-lib=libcmtd");
5092 break;
5093 default:
5094 llvm_unreachable("Unexpected option ID.");
5095 }
5096
Reid Kleckner6beca0e2013-08-08 19:33:10 +00005097 // This provides POSIX compatibility (maps 'open' to '_open'), which most
5098 // users want. The /Za flag to cl.exe turns this off, but it's not
5099 // implemented in clang.
5100 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00005101
Hans Wennborg8858a032014-07-21 23:42:07 +00005102 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
5103 // would produce interleaved output, so ignore /showIncludes in such cases.
5104 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5105 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5106 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00005107
David Majnemerf6072342014-07-01 22:24:56 +00005108 // This controls whether or not we emit RTTI data for polymorphic types.
5109 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5110 /*default=*/false))
5111 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00005112
Reid Klecknerc542d372014-06-27 17:02:02 +00005113 const Driver &D = getToolChain().getDriver();
5114 EHFlags EH = parseClangCLEHFlags(D, Args);
5115 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005116 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00005117 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005118 CmdArgs.push_back("-fexceptions");
5119 }
Reid Klecknerc542d372014-06-27 17:02:02 +00005120
Hans Wennborge50cec32014-06-13 20:59:54 +00005121 // /EP should expand to -E -P.
5122 if (Args.hasArg(options::OPT__SLASH_EP)) {
5123 CmdArgs.push_back("-E");
5124 CmdArgs.push_back("-P");
5125 }
5126
David Majnemera5b195a2015-02-14 01:35:12 +00005127 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005128 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5129 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00005130 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5131 else
5132 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5133
5134 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5135 VolatileOptionID = A->getOption().getID();
5136
5137 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5138 CmdArgs.push_back("-fms-volatile");
5139
David Majnemer86c318f2014-02-11 21:05:00 +00005140 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5141 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5142 if (MostGeneralArg && BestCaseArg)
5143 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5144 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5145
5146 if (MostGeneralArg) {
5147 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5148 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5149 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5150
5151 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5152 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5153 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5154 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5155 << FirstConflict->getAsString(Args)
5156 << SecondConflict->getAsString(Args);
5157
5158 if (SingleArg)
5159 CmdArgs.push_back("-fms-memptr-rep=single");
5160 else if (MultipleArg)
5161 CmdArgs.push_back("-fms-memptr-rep=multiple");
5162 else
5163 CmdArgs.push_back("-fms-memptr-rep=virtual");
5164 }
5165
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00005166 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5167 A->render(Args, CmdArgs);
5168
Hans Wennborg81f74482013-09-10 01:07:07 +00005169 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5170 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00005171 if (Args.hasArg(options::OPT__SLASH_fallback))
5172 CmdArgs.push_back("msvc-fallback");
5173 else
5174 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00005175 }
Hans Wennborg75958c42013-08-08 00:17:41 +00005176}
5177
Hans Wennborg1da044a2014-06-26 19:59:02 +00005178visualstudio::Compile *Clang::getCLFallback() const {
5179 if (!CLFallback)
5180 CLFallback.reset(new visualstudio::Compile(getToolChain()));
5181 return CLFallback.get();
5182}
5183
Daniel Sanders7f933f42015-01-30 17:35:23 +00005184void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5185 ArgStringList &CmdArgs) const {
5186 StringRef CPUName;
5187 StringRef ABIName;
5188 const llvm::Triple &Triple = getToolChain().getTriple();
5189 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5190
5191 CmdArgs.push_back("-target-abi");
5192 CmdArgs.push_back(ABIName.data());
5193}
5194
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005195void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005196 const InputInfo &Output,
5197 const InputInfoList &Inputs,
5198 const ArgList &Args,
5199 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005200 ArgStringList CmdArgs;
5201
5202 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5203 const InputInfo &Input = Inputs[0];
5204
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005205 // Don't warn about "clang -w -c foo.s"
5206 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005207 // and "clang -emit-llvm -c foo.s"
5208 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005209
Rafael Espindola577637a2015-01-03 00:06:04 +00005210 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005211
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005212 // Invoke ourselves in -cc1as mode.
5213 //
5214 // FIXME: Implement custom jobs for internal actions.
5215 CmdArgs.push_back("-cc1as");
5216
5217 // Add the "effective" target triple.
5218 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00005219 std::string TripleStr =
5220 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005221 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5222
5223 // Set the output mode, we currently only expect to be used as a real
5224 // assembler.
5225 CmdArgs.push_back("-filetype");
5226 CmdArgs.push_back("obj");
5227
Eric Christopher45f2e712012-12-18 00:31:10 +00005228 // Set the main file name, so that debug info works even with
5229 // -save-temps or preprocessed assembly.
5230 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00005231 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00005232
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005233 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00005234 const llvm::Triple Triple(TripleStr);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005235 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005236 if (!CPU.empty()) {
5237 CmdArgs.push_back("-target-cpu");
5238 CmdArgs.push_back(Args.MakeArgString(CPU));
5239 }
5240
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005241 // Add the target features
5242 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00005243 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005244
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005245 // Ignore explicit -force_cpusubtype_ALL option.
5246 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005247
Eric Christopherfc3ee562012-01-10 00:38:01 +00005248 // Determine the original source input.
5249 const Action *SourceAction = &JA;
5250 while (SourceAction->getKind() != Action::InputClass) {
5251 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5252 SourceAction = SourceAction->getInputs()[0];
5253 }
5254
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005255 // Forward -g and handle debug info related flags, assuming we are dealing
5256 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005257 if (SourceAction->getType() == types::TY_Asm ||
5258 SourceAction->getType() == types::TY_PP_Asm) {
5259 Args.ClaimAllArgs(options::OPT_g_Group);
5260 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5261 if (!A->getOption().matches(options::OPT_g0))
5262 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005263
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005264 if (Args.hasArg(options::OPT_gdwarf_2))
5265 CmdArgs.push_back("-gdwarf-2");
5266 if (Args.hasArg(options::OPT_gdwarf_3))
5267 CmdArgs.push_back("-gdwarf-3");
5268 if (Args.hasArg(options::OPT_gdwarf_4))
5269 CmdArgs.push_back("-gdwarf-4");
5270
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005271 // Add the -fdebug-compilation-dir flag if needed.
5272 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005273
5274 // Set the AT_producer to the clang version when using the integrated
5275 // assembler on assembly source files.
5276 CmdArgs.push_back("-dwarf-debug-producer");
5277 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00005278 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005279
5280 // Optionally embed the -cc1as level arguments into the debug info, for build
5281 // analysis.
5282 if (getToolChain().UseDwarfDebugFlags()) {
5283 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005284 for (const auto &Arg : Args)
5285 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005286
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005287 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005288 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5289 Flags += Exec;
5290 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005291 SmallString<128> EscapedArg;
5292 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005293 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005294 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005295 }
5296 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005297 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005298 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005299
5300 // FIXME: Add -static support, once we have it.
5301
Daniel Sanders7f933f42015-01-30 17:35:23 +00005302 // Add target specific flags.
5303 switch(getToolChain().getArch()) {
5304 default:
5305 break;
5306
5307 case llvm::Triple::mips:
5308 case llvm::Triple::mipsel:
5309 case llvm::Triple::mips64:
5310 case llvm::Triple::mips64el:
5311 AddMIPSTargetArgs(Args, CmdArgs);
5312 break;
5313 }
5314
David Blaikie372d9502014-01-17 03:17:40 +00005315 // Consume all the warning flags. Usually this would be handled more
5316 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5317 // doesn't handle that so rather than warning about unused flags that are
5318 // actually used, we'll lie by omission instead.
5319 // FIXME: Stop lying and consume only the appropriate driver flags
Sean Silva14facf32015-06-09 01:57:17 +00005320 for (const Arg *A : Args.filtered(options::OPT_W_Group))
5321 A->claim();
David Blaikie372d9502014-01-17 03:17:40 +00005322
David Blaikie9260ed62013-07-25 21:19:01 +00005323 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5324 getToolChain().getDriver());
5325
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005326 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005327
5328 assert(Output.isFilename() && "Unexpected lipo output.");
5329 CmdArgs.push_back("-o");
5330 CmdArgs.push_back(Output.getFilename());
5331
Daniel Dunbarb440f562010-08-02 02:38:21 +00005332 assert(Input.isFilename() && "Invalid input.");
5333 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005334
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005335 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00005336 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00005337
5338 // Handle the debug info splitting at object creation time if we're
5339 // creating an object.
5340 // TODO: Currently only works on linux with newer objcopy.
5341 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005342 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005343 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00005344 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005345}
5346
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005347void GnuTool::anchor() {}
5348
Daniel Dunbara3246a02009-03-18 08:07:30 +00005349void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005350 const InputInfo &Output,
5351 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005352 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005353 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005354 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005355 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005356
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005357 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005358 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005359 // Don't forward any -g arguments to assembly steps.
5360 if (isa<AssembleJobAction>(JA) &&
5361 A->getOption().matches(options::OPT_g_Group))
5362 continue;
5363
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005364 // Don't forward any -W arguments to assembly and link steps.
5365 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5366 A->getOption().matches(options::OPT_W_Group))
5367 continue;
5368
Daniel Dunbar2da02722009-03-19 07:55:12 +00005369 // It is unfortunate that we have to claim here, as this means
5370 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005371 // platforms using a generic gcc, even if we are just using gcc
5372 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005373 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005374 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005375 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005376 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005377
Daniel Dunbar4e295052010-01-25 22:35:08 +00005378 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005379
5380 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005381 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005382 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005383 CmdArgs.push_back(
5384 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005385 }
5386
Daniel Dunbar5716d872009-05-02 21:41:52 +00005387 // Try to force gcc to match the tool chain we want, if we recognize
5388 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005389 //
5390 // FIXME: The triple class should directly provide the information we want
5391 // here.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005392 const llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005393 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005394 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00005395 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5396 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005397 CmdArgs.push_back("-m64");
5398
Daniel Dunbarb440f562010-08-02 02:38:21 +00005399 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005400 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005401 CmdArgs.push_back(Output.getFilename());
5402 } else {
5403 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005404 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005405 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005406
Tony Linthicum76329bf2011-12-12 21:14:55 +00005407 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5408 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005409
5410 // Only pass -x if gcc will understand it; otherwise hope gcc
5411 // understands the suffix correctly. The main use case this would go
5412 // wrong in is for linker inputs if they happened to have an odd
5413 // suffix; really the only way to get this to happen is a command
5414 // like '-x foobar a.c' which will treat a.c like a linker input.
5415 //
5416 // FIXME: For the linker case specifically, can we safely convert
5417 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005418 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005419 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005420 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5421 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005422 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005423 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005424 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005425 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005426 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005427 else if (II.getType() == types::TY_ModuleFile)
5428 D.Diag(diag::err_drv_no_module_support)
5429 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005430
Daniel Dunbara3246a02009-03-18 08:07:30 +00005431 if (types::canTypeBeUserSpecified(II.getType())) {
5432 CmdArgs.push_back("-x");
5433 CmdArgs.push_back(types::getTypeName(II.getType()));
5434 }
5435
Daniel Dunbarb440f562010-08-02 02:38:21 +00005436 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005437 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005438 else {
5439 const Arg &A = II.getInputArg();
5440
5441 // Reverse translate some rewritten options.
5442 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5443 CmdArgs.push_back("-lstdc++");
5444 continue;
5445 }
5446
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005447 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005448 A.render(Args, CmdArgs);
5449 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005450 }
5451
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005452 const std::string customGCCName = D.getCCCGenericGCCName();
5453 const char *GCCName;
5454 if (!customGCCName.empty())
5455 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005456 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005457 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005458 } else
5459 GCCName = "gcc";
5460
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005461 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005462 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005463 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005464}
5465
Daniel Dunbar4e295052010-01-25 22:35:08 +00005466void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5467 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005468 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005469}
5470
Daniel Dunbar4e295052010-01-25 22:35:08 +00005471void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5472 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005473 const Driver &D = getToolChain().getDriver();
5474
Eric Christophercc7ff502015-01-29 00:56:17 +00005475 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005476 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005477 case types::TY_LLVM_IR:
5478 case types::TY_LTO_IR:
5479 case types::TY_LLVM_BC:
5480 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005481 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005482 break;
5483 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005484 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005485 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005486 case types::TY_Nothing:
5487 CmdArgs.push_back("-fsyntax-only");
5488 break;
5489 default:
5490 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005491 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005492}
5493
Daniel Dunbar4e295052010-01-25 22:35:08 +00005494void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5495 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005496 // The types are (hopefully) good enough.
5497}
5498
Tony Linthicum76329bf2011-12-12 21:14:55 +00005499// Hexagon tools start.
5500void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5501 ArgStringList &CmdArgs) const {
5502
5503}
5504void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5505 const InputInfo &Output,
5506 const InputInfoList &Inputs,
5507 const ArgList &Args,
5508 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005509 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005510
5511 const Driver &D = getToolChain().getDriver();
5512 ArgStringList CmdArgs;
5513
5514 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005515 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005516 CmdArgs.push_back(Args.MakeArgString(MarchString));
5517
5518 RenderExtraToolArgs(JA, CmdArgs);
5519
5520 if (Output.isFilename()) {
5521 CmdArgs.push_back("-o");
5522 CmdArgs.push_back(Output.getFilename());
5523 } else {
5524 assert(Output.isNothing() && "Unexpected output");
5525 CmdArgs.push_back("-fsyntax-only");
5526 }
5527
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005528 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args))
5529 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005530
Matthew Curtise5df3812012-12-07 17:23:04 +00005531 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5532 options::OPT_Xassembler);
5533
Tony Linthicum76329bf2011-12-12 21:14:55 +00005534 // Only pass -x if gcc will understand it; otherwise hope gcc
5535 // understands the suffix correctly. The main use case this would go
5536 // wrong in is for linker inputs if they happened to have an odd
5537 // suffix; really the only way to get this to happen is a command
5538 // like '-x foobar a.c' which will treat a.c like a linker input.
5539 //
5540 // FIXME: For the linker case specifically, can we safely convert
5541 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005542 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005543 // Don't try to pass LLVM or AST inputs to a generic gcc.
5544 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5545 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5546 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5547 << getToolChain().getTripleString();
5548 else if (II.getType() == types::TY_AST)
5549 D.Diag(clang::diag::err_drv_no_ast_support)
5550 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005551 else if (II.getType() == types::TY_ModuleFile)
5552 D.Diag(diag::err_drv_no_module_support)
5553 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005554
5555 if (II.isFilename())
5556 CmdArgs.push_back(II.getFilename());
5557 else
5558 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5559 II.getInputArg().render(Args, CmdArgs);
5560 }
5561
5562 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005563 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005564 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005565}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005566
Tony Linthicum76329bf2011-12-12 21:14:55 +00005567void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5568 ArgStringList &CmdArgs) const {
5569 // The types are (hopefully) good enough.
5570}
5571
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005572static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
5573 const toolchains::Hexagon_TC& ToolChain,
5574 const InputInfo &Output,
5575 const InputInfoList &Inputs,
5576 const ArgList &Args,
5577 ArgStringList &CmdArgs,
5578 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005579
Matthew Curtise689b052012-12-06 15:46:07 +00005580 const Driver &D = ToolChain.getDriver();
5581
Tony Linthicum76329bf2011-12-12 21:14:55 +00005582
Matthew Curtise689b052012-12-06 15:46:07 +00005583 //----------------------------------------------------------------------------
5584 //
5585 //----------------------------------------------------------------------------
5586 bool hasStaticArg = Args.hasArg(options::OPT_static);
5587 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005588 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005589 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5590 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5591 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005592 bool useG0 = false;
Matthew Curtise689b052012-12-06 15:46:07 +00005593 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005594
Matthew Curtise689b052012-12-06 15:46:07 +00005595 //----------------------------------------------------------------------------
5596 // Silence warnings for various options
5597 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005598
Matthew Curtise689b052012-12-06 15:46:07 +00005599 Args.ClaimAllArgs(options::OPT_g_Group);
5600 Args.ClaimAllArgs(options::OPT_emit_llvm);
5601 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5602 // handled somewhere else.
5603 Args.ClaimAllArgs(options::OPT_static_libgcc);
5604
5605 //----------------------------------------------------------------------------
5606 //
5607 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005608 for (const auto &Opt : ToolChain.ExtraOpts)
5609 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005610
Matthew Curtisf10a5952012-12-06 14:16:43 +00005611 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5612 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005613
Matthew Curtise689b052012-12-06 15:46:07 +00005614 if (buildingLib) {
5615 CmdArgs.push_back("-shared");
5616 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5617 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005618 }
5619
Matthew Curtise689b052012-12-06 15:46:07 +00005620 if (hasStaticArg)
5621 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005622
Matthew Curtise8f80a12012-12-06 17:49:03 +00005623 if (buildPIE && !buildingLib)
5624 CmdArgs.push_back("-pie");
5625
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005626 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
5627 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
5628 useG0 = toolchains::Hexagon_TC::UsesG0(v);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005629 }
5630
Matthew Curtise689b052012-12-06 15:46:07 +00005631 //----------------------------------------------------------------------------
5632 //
5633 //----------------------------------------------------------------------------
5634 CmdArgs.push_back("-o");
5635 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005636
Matthew Curtise689b052012-12-06 15:46:07 +00005637 const std::string MarchSuffix = "/" + MarchString;
5638 const std::string G0Suffix = "/G0";
5639 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005640 const std::string RootDir =
5641 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005642 const std::string StartFilesDir = RootDir
5643 + "hexagon/lib"
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005644 + (useG0 ? MarchG0Suffix : MarchSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00005645
5646 //----------------------------------------------------------------------------
5647 // moslib
5648 //----------------------------------------------------------------------------
5649 std::vector<std::string> oslibs;
5650 bool hasStandalone= false;
5651
Sean Silva14facf32015-06-09 01:57:17 +00005652 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5653 A->claim();
5654 oslibs.emplace_back(A->getValue());
Matthew Curtise689b052012-12-06 15:46:07 +00005655 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005656 }
Matthew Curtise689b052012-12-06 15:46:07 +00005657 if (oslibs.empty()) {
5658 oslibs.push_back("standalone");
5659 hasStandalone = true;
5660 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005661
Matthew Curtise689b052012-12-06 15:46:07 +00005662 //----------------------------------------------------------------------------
5663 // Start Files
5664 //----------------------------------------------------------------------------
5665 if (incStdLib && incStartFiles) {
5666
5667 if (!buildingLib) {
5668 if (hasStandalone) {
5669 CmdArgs.push_back(
5670 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5671 }
5672 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5673 }
5674 std::string initObj = useShared ? "/initS.o" : "/init.o";
5675 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5676 }
5677
5678 //----------------------------------------------------------------------------
5679 // Library Search Paths
5680 //----------------------------------------------------------------------------
5681 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005682 for (const auto &LibPath : LibPaths)
5683 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005684
5685 //----------------------------------------------------------------------------
5686 //
5687 //----------------------------------------------------------------------------
5688 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5689 Args.AddAllArgs(CmdArgs, options::OPT_e);
5690 Args.AddAllArgs(CmdArgs, options::OPT_s);
5691 Args.AddAllArgs(CmdArgs, options::OPT_t);
5692 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5693
5694 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5695
5696 //----------------------------------------------------------------------------
5697 // Libraries
5698 //----------------------------------------------------------------------------
5699 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005700 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005701 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5702 CmdArgs.push_back("-lm");
5703 }
5704
5705 CmdArgs.push_back("--start-group");
5706
5707 if (!buildingLib) {
5708 for(std::vector<std::string>::iterator i = oslibs.begin(),
5709 e = oslibs.end(); i != e; ++i)
5710 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5711 CmdArgs.push_back("-lc");
5712 }
5713 CmdArgs.push_back("-lgcc");
5714
5715 CmdArgs.push_back("--end-group");
5716 }
5717
5718 //----------------------------------------------------------------------------
5719 // End files
5720 //----------------------------------------------------------------------------
5721 if (incStdLib && incStartFiles) {
5722 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5723 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5724 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005725}
5726
5727void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5728 const InputInfo &Output,
5729 const InputInfoList &Inputs,
5730 const ArgList &Args,
5731 const char *LinkingOutput) const {
5732
5733 const toolchains::Hexagon_TC& ToolChain =
5734 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5735
5736 ArgStringList CmdArgs;
5737 constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
5738 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00005739
5740 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005741 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5742 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005743}
5744// Hexagon tools end.
5745
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005746const std::string arm::getARMArch(const ArgList &Args,
5747 const llvm::Triple &Triple) {
5748 std::string MArch;
Bernard Ogden31561762013-12-12 13:27:11 +00005749 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5750 // Otherwise, if we have -march= choose the base CPU for that arch.
5751 MArch = A->getValue();
5752 } else {
5753 // Otherwise, use the Arch from the triple.
5754 MArch = Triple.getArchName();
5755 }
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005756 MArch = StringRef(MArch).lower();
John Brawn94fd9632015-05-21 12:19:49 +00005757
5758 // Handle -march=native.
5759 if (MArch == "native") {
5760 std::string CPU = llvm::sys::getHostCPUName();
5761 if (CPU != "generic") {
5762 // Translate the native cpu into the architecture suffix for that CPU.
5763 const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch);
5764 // If there is no valid architecture suffix for this CPU we don't know how
5765 // to handle it, so return no architecture.
5766 if (strcmp(Suffix,"") == 0)
5767 MArch = "";
5768 else
5769 MArch = std::string("arm") + Suffix;
5770 }
5771 }
5772
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005773 return MArch;
5774}
5775/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
5776const char *arm::getARMCPUForMArch(const ArgList &Args,
5777 const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005778 std::string MArch = getARMArch(Args, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00005779 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
5780 // here means an -march=native that we can't handle, so instead return no CPU.
5781 if (MArch.empty())
5782 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005783
John Brawna95c1a82015-05-08 12:52:18 +00005784 // We need to return an empty string here on invalid MArch values as the
5785 // various places that call this function can't cope with a null result.
5786 const char *result = Triple.getARMCPUForArch(MArch);
5787 if (result)
5788 return result;
5789 else
5790 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005791}
5792
5793/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Gabor Ballabas208826c2015-06-04 17:56:32 +00005794std::string arm::getARMTargetCPU(const ArgList &Args,
Rafael Espindola80d333b2013-12-12 15:48:19 +00005795 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005796 // FIXME: Warn on inconsistent use of -mcpu and -march.
5797 // If we have -mcpu=, use that.
5798 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Gabor Ballabas208826c2015-06-04 17:56:32 +00005799 std::string MCPU = StringRef(A->getValue()).lower();
Bernard Ogden31561762013-12-12 13:27:11 +00005800 // Handle -mcpu=native.
5801 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005802 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005803 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005804 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005805 }
5806
5807 return getARMCPUForMArch(Args, Triple);
5808}
5809
5810/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005811/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00005812// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005813const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) {
Artyom Skrobov902ac2d2015-06-04 21:31:41 +00005814 if (CPU == "generic" &&
5815 llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_ARMV8_1A)
5816 return "v8.1a";
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005817
Renato Golin3c007252015-05-28 15:05:53 +00005818 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
5819 if (ArchKind == llvm::ARM::AK_INVALID)
5820 return "";
5821 return llvm::ARMTargetParser::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00005822}
5823
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005824void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
5825 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005826 if (Args.hasArg(options::OPT_r))
5827 return;
5828
John Brawn94fd9632015-05-21 12:19:49 +00005829 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
5830 // to generate BE-8 executables.
5831 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
5832 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005833}
5834
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00005835mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
5836 return (NanEncoding)llvm::StringSwitch<int>(CPU)
5837 .Case("mips1", NanLegacy)
5838 .Case("mips2", NanLegacy)
5839 .Case("mips3", NanLegacy)
5840 .Case("mips4", NanLegacy)
5841 .Case("mips5", NanLegacy)
5842 .Case("mips32", NanLegacy)
5843 .Case("mips32r2", NanLegacy)
5844 .Case("mips32r3", NanLegacy | Nan2008)
5845 .Case("mips32r5", NanLegacy | Nan2008)
5846 .Case("mips32r6", Nan2008)
5847 .Case("mips64", NanLegacy)
5848 .Case("mips64r2", NanLegacy)
5849 .Case("mips64r3", NanLegacy | Nan2008)
5850 .Case("mips64r5", NanLegacy | Nan2008)
5851 .Case("mips64r6", Nan2008)
5852 .Default(NanLegacy);
5853}
5854
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005855bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5856 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5857 return A && (A->getValue() == StringRef(Value));
5858}
5859
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005860bool mips::isUCLibc(const ArgList &Args) {
5861 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005862 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005863}
5864
Daniel Sanders2bf13662014-07-10 14:40:57 +00005865bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005866 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5867 return llvm::StringSwitch<bool>(NaNArg->getValue())
5868 .Case("2008", true)
5869 .Case("legacy", false)
5870 .Default(false);
5871
5872 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005873 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5874 .Cases("mips32r6", "mips64r6", true)
5875 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005876
5877 return false;
5878}
5879
Daniel Sanders379d44b2014-07-16 11:52:23 +00005880bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5881 StringRef ABIName) {
5882 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005883 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005884 return false;
5885
5886 if (ABIName != "32")
5887 return false;
5888
5889 return llvm::StringSwitch<bool>(CPUName)
5890 .Cases("mips2", "mips3", "mips4", "mips5", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005891 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
5892 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005893 .Default(false);
5894}
5895
Tim Northover157d9112014-01-16 08:48:16 +00005896llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005897 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5898 // archs which Darwin doesn't use.
5899
5900 // The matching this routine does is fairly pointless, since it is neither the
5901 // complete architecture list, nor a reasonable subset. The problem is that
5902 // historically the driver driver accepts this and also ties its -march=
5903 // handling to the architecture name, so we need to be careful before removing
5904 // support for it.
5905
5906 // This code must be kept in sync with Clang's Darwin specific argument
5907 // translation.
5908
5909 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5910 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5911 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5912 .Case("ppc64", llvm::Triple::ppc64)
5913 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5914 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5915 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005916 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005917 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005918 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005919 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005920 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005921 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005922 .Case("r600", llvm::Triple::r600)
Tom Stellardd8e38a32015-01-06 20:34:47 +00005923 .Case("amdgcn", llvm::Triple::amdgcn)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005924 .Case("nvptx", llvm::Triple::nvptx)
5925 .Case("nvptx64", llvm::Triple::nvptx64)
5926 .Case("amdil", llvm::Triple::amdil)
5927 .Case("spir", llvm::Triple::spir)
5928 .Default(llvm::Triple::UnknownArch);
5929}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005930
Tim Northover157d9112014-01-16 08:48:16 +00005931void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005932 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00005933 T.setArch(Arch);
5934
5935 if (Str == "x86_64h")
5936 T.setArchName(Str);
5937 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5938 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005939 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005940 }
5941}
5942
Bob Wilsondecc03e2012-11-23 06:14:39 +00005943const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00005944 const InputInfo &Input) {
5945 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005946}
5947
Bob Wilsondecc03e2012-11-23 06:14:39 +00005948const char *Clang::getBaseInputStem(const ArgList &Args,
5949 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00005950 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005951
Chris Lattner906bb902011-01-16 08:14:11 +00005952 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005953 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005954
5955 return Str;
5956}
5957
Bob Wilsondecc03e2012-11-23 06:14:39 +00005958const char *Clang::getDependencyFileName(const ArgList &Args,
5959 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005960 // FIXME: Think about this more.
5961 std::string Res;
5962
5963 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005964 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005965 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005966 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005967 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005968 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005969 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005970}
5971
Ed Schouten3c3e58c2015-03-26 11:13:44 +00005972void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA,
5973 const InputInfo &Output,
5974 const InputInfoList &Inputs,
5975 const ArgList &Args,
5976 const char *LinkingOutput) const {
5977 const ToolChain &ToolChain = getToolChain();
5978 const Driver &D = ToolChain.getDriver();
5979 ArgStringList CmdArgs;
5980
5981 // Silence warning for "clang -g foo.o -o foo"
5982 Args.ClaimAllArgs(options::OPT_g_Group);
5983 // and "clang -emit-llvm foo.o -o foo"
5984 Args.ClaimAllArgs(options::OPT_emit_llvm);
5985 // and for "clang -w foo.o -o foo". Other warning options are already
5986 // handled somewhere else.
5987 Args.ClaimAllArgs(options::OPT_w);
5988
5989 if (!D.SysRoot.empty())
5990 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5991
5992 // CloudABI only supports static linkage.
5993 CmdArgs.push_back("-Bstatic");
5994 CmdArgs.push_back("--eh-frame-hdr");
5995 CmdArgs.push_back("--gc-sections");
5996
5997 if (Output.isFilename()) {
5998 CmdArgs.push_back("-o");
5999 CmdArgs.push_back(Output.getFilename());
6000 } else {
6001 assert(Output.isNothing() && "Invalid output.");
6002 }
6003
6004 if (!Args.hasArg(options::OPT_nostdlib) &&
6005 !Args.hasArg(options::OPT_nostartfiles)) {
6006 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
6007 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
6008 }
6009
6010 Args.AddAllArgs(CmdArgs, options::OPT_L);
6011 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
6012 for (const auto &Path : Paths)
6013 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
6014 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6015 Args.AddAllArgs(CmdArgs, options::OPT_e);
6016 Args.AddAllArgs(CmdArgs, options::OPT_s);
6017 Args.AddAllArgs(CmdArgs, options::OPT_t);
6018 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6019 Args.AddAllArgs(CmdArgs, options::OPT_r);
6020
6021 if (D.IsUsingLTO(ToolChain, Args))
6022 AddGoldPlugin(ToolChain, Args, CmdArgs);
6023
6024 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6025
6026 if (!Args.hasArg(options::OPT_nostdlib) &&
6027 !Args.hasArg(options::OPT_nodefaultlibs)) {
6028 if (D.CCCIsCXX())
6029 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6030 CmdArgs.push_back("-lc");
6031 CmdArgs.push_back("-lcompiler_rt");
6032 }
6033
6034 if (!Args.hasArg(options::OPT_nostdlib) &&
6035 !Args.hasArg(options::OPT_nostartfiles))
6036 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6037
6038 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
6039 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6040}
6041
Daniel Dunbarbe220842009-03-20 16:06:39 +00006042void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006043 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006044 const InputInfoList &Inputs,
6045 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00006046 const char *LinkingOutput) const {
6047 ArgStringList CmdArgs;
6048
6049 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6050 const InputInfo &Input = Inputs[0];
6051
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006052 // Determine the original source input.
6053 const Action *SourceAction = &JA;
6054 while (SourceAction->getKind() != Action::InputClass) {
6055 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6056 SourceAction = SourceAction->getInputs()[0];
6057 }
6058
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006059 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00006060 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00006061 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
6062 // FIXME: at run-time detect assembler capabilities or rely on version
6063 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006064 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00006065 const llvm::Triple &T(getToolChain().getTriple());
6066 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00006067 CmdArgs.push_back("-Q");
6068 }
Kevin Enderby319baa42013-11-18 23:30:29 +00006069
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006070 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00006071 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006072 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006073 if (Args.hasArg(options::OPT_gstabs))
6074 CmdArgs.push_back("--gstabs");
6075 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00006076 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006077 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006078
Daniel Dunbarbe220842009-03-20 16:06:39 +00006079 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00006080 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006081
Daniel Dunbar6d484762010-07-22 01:47:22 +00006082 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006083 if (getToolChain().getArch() == llvm::Triple::x86 ||
6084 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00006085 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6086 CmdArgs.push_back("-force_cpusubtype_ALL");
6087
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006088 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006089 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00006090 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00006091 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006092 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006093 CmdArgs.push_back("-static");
6094
Daniel Dunbarbe220842009-03-20 16:06:39 +00006095 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6096 options::OPT_Xassembler);
6097
6098 assert(Output.isFilename() && "Unexpected lipo output.");
6099 CmdArgs.push_back("-o");
6100 CmdArgs.push_back(Output.getFilename());
6101
Daniel Dunbarb440f562010-08-02 02:38:21 +00006102 assert(Input.isFilename() && "Invalid input.");
6103 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00006104
6105 // asm_final spec is empty.
6106
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006107 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006108 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006109 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00006110}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006111
Tim Northover157d9112014-01-16 08:48:16 +00006112void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00006113
Tim Northover157d9112014-01-16 08:48:16 +00006114void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6115 ArgStringList &CmdArgs) const {
6116 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006117
Daniel Dunbarc1964212009-03-26 16:23:12 +00006118 // Derived from darwin_arch spec.
6119 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006120 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006121
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006122 // FIXME: Is this needed anymore?
6123 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006124 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00006125}
6126
Bill Wendling3b2000f2012-10-02 18:02:50 +00006127bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
6128 // We only need to generate a temp path for LTO if we aren't compiling object
6129 // files. When compiling source files, we run 'dsymutil' after linking. We
6130 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006131 for (const auto &Input : Inputs)
6132 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00006133 return true;
6134
6135 return false;
6136}
6137
Daniel Dunbarccbc4522010-09-09 21:51:05 +00006138void darwin::Link::AddLinkArgs(Compilation &C,
6139 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00006140 ArgStringList &CmdArgs,
6141 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006142 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00006143 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00006144
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006145 unsigned Version[3] = { 0, 0, 0 };
6146 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6147 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00006148 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006149 Version[1], Version[2], HadExtra) ||
6150 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006151 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006152 << A->getAsString(Args);
6153 }
6154
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006155 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006156 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006157 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6158 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006159
Bob Wilson3d27dad2013-08-02 22:25:34 +00006160 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6161 CmdArgs.push_back("-export_dynamic");
6162
Bob Wilsonb111ec92015-03-02 19:01:14 +00006163 // If we are using App Extension restrictions, pass a flag to the linker
6164 // telling it that the compiled code has been audited.
6165 if (Args.hasFlag(options::OPT_fapplication_extension,
6166 options::OPT_fno_application_extension, false))
6167 CmdArgs.push_back("-application_extension");
6168
Bill Wendling313b6bf2012-11-16 23:03:00 +00006169 // If we are using LTO, then automatically create a temporary file path for
6170 // the linker to use, so that it's lifetime will extend past a possible
6171 // dsymutil step.
Peter Collingbournea4ccff32015-02-20 20:30:56 +00006172 if (Version[0] >= 116 && D.IsUsingLTO(getToolChain(), Args) &&
6173 NeedsTempPath(Inputs)) {
Bill Wendling313b6bf2012-11-16 23:03:00 +00006174 const char *TmpPath = C.getArgs().MakeArgString(
6175 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
6176 C.addTempFile(TmpPath);
6177 CmdArgs.push_back("-object_path_lto");
6178 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00006179 }
6180
Daniel Dunbarc1964212009-03-26 16:23:12 +00006181 // Derived from the "link" spec.
6182 Args.AddAllArgs(CmdArgs, options::OPT_static);
6183 if (!Args.hasArg(options::OPT_static))
6184 CmdArgs.push_back("-dynamic");
6185 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6186 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6187 // here. How do we wish to handle such things?
6188 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006189
Daniel Dunbarc1964212009-03-26 16:23:12 +00006190 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00006191 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00006192 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00006193 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006194
6195 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6196 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6197 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6198
6199 Arg *A;
6200 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6201 (A = Args.getLastArg(options::OPT_current__version)) ||
6202 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006203 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006204 << A->getAsString(Args) << "-dynamiclib";
6205
6206 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6207 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6208 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6209 } else {
6210 CmdArgs.push_back("-dylib");
6211
6212 Arg *A;
6213 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6214 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6215 (A = Args.getLastArg(options::OPT_client__name)) ||
6216 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6217 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6218 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006219 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006220 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006221
Daniel Dunbarc1964212009-03-26 16:23:12 +00006222 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6223 "-dylib_compatibility_version");
6224 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6225 "-dylib_current_version");
6226
Tim Northover157d9112014-01-16 08:48:16 +00006227 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006228
6229 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6230 "-dylib_install_name");
6231 }
6232
6233 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6234 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6235 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006236 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006237 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006238 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6239 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6240 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6241 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6242 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6243 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006244 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006245 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6246 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6247 Args.AddAllArgs(CmdArgs, options::OPT_init);
6248
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006249 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006250 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006251
Daniel Dunbarc1964212009-03-26 16:23:12 +00006252 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6253 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6254 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6255 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6256 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006257
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006258 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6259 options::OPT_fno_pie,
6260 options::OPT_fno_PIE)) {
6261 if (A->getOption().matches(options::OPT_fpie) ||
6262 A->getOption().matches(options::OPT_fPIE))
6263 CmdArgs.push_back("-pie");
6264 else
6265 CmdArgs.push_back("-no_pie");
6266 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006267
6268 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6269 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6270 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6271 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6272 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6273 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6274 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6275 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6276 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6277 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6278 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6279 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6280 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6281 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6282 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6283 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006284
Daniel Dunbar84384642011-05-02 21:03:47 +00006285 // Give --sysroot= preference, over the Apple specific behavior to also use
6286 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006287 StringRef sysroot = C.getSysRoot();
6288 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006289 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006290 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006291 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6292 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006293 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006294 }
6295
Daniel Dunbarc1964212009-03-26 16:23:12 +00006296 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6297 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6298 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6299 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6300 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006301 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006302 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6303 Args.AddAllArgs(CmdArgs, options::OPT_y);
6304 Args.AddLastArg(CmdArgs, options::OPT_w);
6305 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6306 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6307 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6308 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6309 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6310 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6311 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6312 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6313 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6314 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6315 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6316 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6317}
6318
6319void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006320 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006321 const InputInfoList &Inputs,
6322 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00006323 const char *LinkingOutput) const {
6324 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006325
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006326 // If the number of arguments surpasses the system limits, we will encode the
6327 // input files in a separate file, shortening the command line. To this end,
6328 // build a list of input file names that can be passed via a file with the
6329 // -filelist linker option.
6330 llvm::opt::ArgStringList InputFileList;
6331
Daniel Dunbarc1964212009-03-26 16:23:12 +00006332 // The logic here is derived from gcc's behavior; most of which
6333 // comes from specs (starting with link_command). Consult gcc for
6334 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006335 ArgStringList CmdArgs;
6336
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006337 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6338 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6339 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006340 for (const auto &Arg : Args)
6341 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006342 const char *Exec =
6343 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
6344 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00006345 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006346 return;
6347 }
6348
Daniel Dunbarc1964212009-03-26 16:23:12 +00006349 // I'm not sure why this particular decomposition exists in gcc, but
6350 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006351 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006352
Daniel Dunbarc1964212009-03-26 16:23:12 +00006353 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6354 Args.AddAllArgs(CmdArgs, options::OPT_s);
6355 Args.AddAllArgs(CmdArgs, options::OPT_t);
6356 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6357 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006358 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006359 Args.AddAllArgs(CmdArgs, options::OPT_r);
6360
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006361 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6362 // members of static archive libraries which implement Objective-C classes or
6363 // categories.
6364 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6365 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006366
Daniel Dunbarc1964212009-03-26 16:23:12 +00006367 CmdArgs.push_back("-o");
6368 CmdArgs.push_back(Output.getFilename());
6369
Chad Rosier06fd3c62012-05-16 23:45:12 +00006370 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006371 !Args.hasArg(options::OPT_nostartfiles))
6372 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006373
Peter Collingbournec4122c12015-06-15 21:08:13 +00006374 // SafeStack requires its own runtime libraries
6375 // These libraries should be linked first, to make sure the
6376 // __safestack_init constructor executes before everything else
6377 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
6378 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
6379 "libclang_rt.safestack_osx.a",
6380 /*AlwaysLink=*/true);
6381 }
6382
Daniel Dunbarc1964212009-03-26 16:23:12 +00006383 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006384
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006385 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6386 options::OPT_fno_openmp, false)) {
6387 switch (getOpenMPRuntime(getToolChain(), Args)) {
6388 case OMPRT_OMP:
6389 CmdArgs.push_back("-lomp");
6390 break;
6391 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00006392 CmdArgs.push_back("-lgomp");
6393 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006394 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00006395 CmdArgs.push_back("-liomp5");
6396 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006397 case OMPRT_Unknown:
6398 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00006399 break;
6400 }
Alexey Bataev186b28a2014-03-06 05:43:53 +00006401 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006402
Douglas Gregor9295df02012-05-15 21:00:27 +00006403 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006404 // Build the input file for -filelist (list of linker input files) in case we
6405 // need it later
6406 for (const auto &II : Inputs) {
6407 if (!II.isFilename()) {
6408 // This is a linker input argument.
6409 // We cannot mix input arguments and file names in a -filelist input, thus
6410 // we prematurely stop our list (remaining files shall be passed as
6411 // arguments).
6412 if (InputFileList.size() > 0)
6413 break;
6414
6415 continue;
6416 }
6417
6418 InputFileList.push_back(II.getFilename());
6419 }
6420
Bob Wilson16d93952012-05-15 18:57:39 +00006421 if (isObjCRuntimeLinked(Args) &&
6422 !Args.hasArg(options::OPT_nostdlib) &&
6423 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006424 // We use arclite library for both ARC and subscripting support.
6425 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6426
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006427 CmdArgs.push_back("-framework");
6428 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006429 // Link libobj.
6430 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006431 }
John McCall31168b02011-06-15 23:02:42 +00006432
Daniel Dunbarc1964212009-03-26 16:23:12 +00006433 if (LinkingOutput) {
6434 CmdArgs.push_back("-arch_multiple");
6435 CmdArgs.push_back("-final_output");
6436 CmdArgs.push_back(LinkingOutput);
6437 }
6438
Daniel Dunbarc1964212009-03-26 16:23:12 +00006439 if (Args.hasArg(options::OPT_fnested_functions))
6440 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006441
Justin Bognerc7701242015-05-12 05:44:36 +00006442 // TODO: It would be nice to use addProfileRT() here, but darwin's compiler-rt
6443 // paths are different enough from other toolchains that this needs a fair
6444 // amount of refactoring done first.
6445 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6446
Daniel Dunbarc1964212009-03-26 16:23:12 +00006447 if (!Args.hasArg(options::OPT_nostdlib) &&
6448 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006449 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006450 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006451
Daniel Dunbarc1964212009-03-26 16:23:12 +00006452 // link_ssp spec is empty.
6453
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006454 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006455 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006456 }
6457
Chad Rosier06fd3c62012-05-16 23:45:12 +00006458 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006459 !Args.hasArg(options::OPT_nostartfiles)) {
6460 // endfile_spec is empty.
6461 }
6462
6463 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6464 Args.AddAllArgs(CmdArgs, options::OPT_F);
6465
Steven Wu3ffb61b2015-02-06 18:08:29 +00006466 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00006467 for (const Arg *A : Args.filtered(options::OPT_iframework))
6468 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00006469
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006470 if (!Args.hasArg(options::OPT_nostdlib) &&
6471 !Args.hasArg(options::OPT_nodefaultlibs)) {
6472 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6473 if (A->getValue() == StringRef("Accelerate")) {
6474 CmdArgs.push_back("-framework");
6475 CmdArgs.push_back("Accelerate");
6476 }
6477 }
6478 }
6479
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006480 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006481 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006482 std::unique_ptr<Command> Cmd =
6483 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
6484 Cmd->setInputFileList(std::move(InputFileList));
6485 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006486}
6487
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006488void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006489 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006490 const InputInfoList &Inputs,
6491 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006492 const char *LinkingOutput) const {
6493 ArgStringList CmdArgs;
6494
6495 CmdArgs.push_back("-create");
6496 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006497
6498 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006499 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006500
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006501 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006502 assert(II.isFilename() && "Unexpected lipo input.");
6503 CmdArgs.push_back(II.getFilename());
6504 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006505
6506 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00006507 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006508}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006509
Daniel Dunbar88299622010-06-04 18:28:36 +00006510void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006511 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00006512 const InputInfoList &Inputs,
6513 const ArgList &Args,
6514 const char *LinkingOutput) const {
6515 ArgStringList CmdArgs;
6516
Daniel Dunbareb86b042011-05-09 17:23:16 +00006517 CmdArgs.push_back("-o");
6518 CmdArgs.push_back(Output.getFilename());
6519
Daniel Dunbar88299622010-06-04 18:28:36 +00006520 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6521 const InputInfo &Input = Inputs[0];
6522 assert(Input.isFilename() && "Unexpected dsymutil input.");
6523 CmdArgs.push_back(Input.getFilename());
6524
Daniel Dunbar88299622010-06-04 18:28:36 +00006525 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006526 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00006527 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006528}
6529
Eric Christopher551ef452011-08-23 17:56:55 +00006530void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006531 const InputInfo &Output,
6532 const InputInfoList &Inputs,
6533 const ArgList &Args,
6534 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006535 ArgStringList CmdArgs;
6536 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006537 CmdArgs.push_back("--debug-info");
6538 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006539 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006540
6541 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6542 const InputInfo &Input = Inputs[0];
6543 assert(Input.isFilename() && "Unexpected verify input");
6544
6545 // Grabbing the output of the earlier dsymutil run.
6546 CmdArgs.push_back(Input.getFilename());
6547
6548 const char *Exec =
6549 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00006550 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006551}
6552
David Chisnallf571cde2012-02-15 13:39:01 +00006553void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6554 const InputInfo &Output,
6555 const InputInfoList &Inputs,
6556 const ArgList &Args,
6557 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006558 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006559 ArgStringList CmdArgs;
6560
6561 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6562 options::OPT_Xassembler);
6563
6564 CmdArgs.push_back("-o");
6565 CmdArgs.push_back(Output.getFilename());
6566
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006567 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006568 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006569
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006570 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006571 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006572}
6573
David Chisnallf571cde2012-02-15 13:39:01 +00006574void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6575 const InputInfo &Output,
6576 const InputInfoList &Inputs,
6577 const ArgList &Args,
6578 const char *LinkingOutput) const {
6579 // FIXME: Find a real GCC, don't hard-code versions here
6580 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6581 const llvm::Triple &T = getToolChain().getTriple();
6582 std::string LibPath = "/usr/lib/";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006583 const llvm::Triple::ArchType Arch = T.getArch();
David Chisnallf571cde2012-02-15 13:39:01 +00006584 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006585 case llvm::Triple::x86:
6586 GCCLibPath +=
6587 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6588 break;
6589 case llvm::Triple::x86_64:
6590 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6591 GCCLibPath += "/4.5.2/amd64/";
6592 LibPath += "amd64/";
6593 break;
6594 default:
6595 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006596 }
6597
6598 ArgStringList CmdArgs;
6599
David Chisnall272a0712012-02-29 15:06:12 +00006600 // Demangle C++ names in errors
6601 CmdArgs.push_back("-C");
6602
David Chisnallf571cde2012-02-15 13:39:01 +00006603 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6604 (!Args.hasArg(options::OPT_shared))) {
6605 CmdArgs.push_back("-e");
6606 CmdArgs.push_back("_start");
6607 }
6608
6609 if (Args.hasArg(options::OPT_static)) {
6610 CmdArgs.push_back("-Bstatic");
6611 CmdArgs.push_back("-dn");
6612 } else {
6613 CmdArgs.push_back("-Bdynamic");
6614 if (Args.hasArg(options::OPT_shared)) {
6615 CmdArgs.push_back("-shared");
6616 } else {
6617 CmdArgs.push_back("--dynamic-linker");
6618 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6619 }
6620 }
6621
6622 if (Output.isFilename()) {
6623 CmdArgs.push_back("-o");
6624 CmdArgs.push_back(Output.getFilename());
6625 } else {
6626 assert(Output.isNothing() && "Invalid output.");
6627 }
6628
6629 if (!Args.hasArg(options::OPT_nostdlib) &&
6630 !Args.hasArg(options::OPT_nostartfiles)) {
6631 if (!Args.hasArg(options::OPT_shared)) {
6632 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6633 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006634 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006635 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6636 } else {
6637 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006638 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6639 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006640 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006641 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006642 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006643 }
6644
6645 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6646
6647 Args.AddAllArgs(CmdArgs, options::OPT_L);
6648 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6649 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006650 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006651
6652 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6653
6654 if (!Args.hasArg(options::OPT_nostdlib) &&
6655 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006656 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006657 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006658 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006659 if (!Args.hasArg(options::OPT_shared)) {
6660 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006661 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006662 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006663 }
David Chisnallf571cde2012-02-15 13:39:01 +00006664 }
6665
6666 if (!Args.hasArg(options::OPT_nostdlib) &&
6667 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006668 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006669 }
David Chisnall96de9932012-02-16 16:00:47 +00006670 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006671
Alexey Samsonov7811d192014-02-20 13:57:37 +00006672 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006673
6674 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006675 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006676 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006677}
6678
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006679void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006680 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006681 const InputInfoList &Inputs,
6682 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006683 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006684 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006685 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006686 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006687
Rafael Espindolacc126272014-02-28 01:55:21 +00006688 switch (getToolChain().getArch()) {
6689 case llvm::Triple::x86:
6690 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6691 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006692 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006693 break;
6694
6695 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006696 CmdArgs.push_back("-mppc");
6697 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006698 break;
6699
6700 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006701 case llvm::Triple::sparcel:
Rafael Espindolacc126272014-02-28 01:55:21 +00006702 CmdArgs.push_back("-32");
6703 NeedsKPIC = true;
6704 break;
6705
6706 case llvm::Triple::sparcv9:
6707 CmdArgs.push_back("-64");
6708 CmdArgs.push_back("-Av9a");
6709 NeedsKPIC = true;
6710 break;
6711
6712 case llvm::Triple::mips64:
6713 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006714 StringRef CPUName;
6715 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006716 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006717
6718 CmdArgs.push_back("-mabi");
6719 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6720
6721 if (getToolChain().getArch() == llvm::Triple::mips64)
6722 CmdArgs.push_back("-EB");
6723 else
6724 CmdArgs.push_back("-EL");
6725
Rafael Espindolacc126272014-02-28 01:55:21 +00006726 NeedsKPIC = true;
6727 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006728 }
6729
Rafael Espindolacc126272014-02-28 01:55:21 +00006730 default:
6731 break;
6732 }
6733
6734 if (NeedsKPIC)
6735 addAssemblerKPIC(Args, CmdArgs);
6736
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006737 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6738 options::OPT_Xassembler);
6739
6740 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006741 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006742
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006743 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006744 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006745
6746 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006747 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006748 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006749}
6750
6751void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006752 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006753 const InputInfoList &Inputs,
6754 const ArgList &Args,
6755 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006756 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006757 ArgStringList CmdArgs;
6758
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006759 // Silence warning for "clang -g foo.o -o foo"
6760 Args.ClaimAllArgs(options::OPT_g_Group);
6761 // and "clang -emit-llvm foo.o -o foo"
6762 Args.ClaimAllArgs(options::OPT_emit_llvm);
6763 // and for "clang -w foo.o -o foo". Other warning options are already
6764 // handled somewhere else.
6765 Args.ClaimAllArgs(options::OPT_w);
6766
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006767 if (getToolChain().getArch() == llvm::Triple::mips64)
6768 CmdArgs.push_back("-EB");
6769 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6770 CmdArgs.push_back("-EL");
6771
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006772 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006773 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006774 CmdArgs.push_back("-e");
6775 CmdArgs.push_back("__start");
6776 }
6777
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006778 if (Args.hasArg(options::OPT_static)) {
6779 CmdArgs.push_back("-Bstatic");
6780 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006781 if (Args.hasArg(options::OPT_rdynamic))
6782 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006783 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006784 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006785 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006786 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006787 } else {
6788 CmdArgs.push_back("-dynamic-linker");
6789 CmdArgs.push_back("/usr/libexec/ld.so");
6790 }
6791 }
6792
Rafael Espindola044f7832013-06-05 04:28:55 +00006793 if (Args.hasArg(options::OPT_nopie))
6794 CmdArgs.push_back("-nopie");
6795
Daniel Dunbarb440f562010-08-02 02:38:21 +00006796 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006797 CmdArgs.push_back("-o");
6798 CmdArgs.push_back(Output.getFilename());
6799 } else {
6800 assert(Output.isNothing() && "Invalid output.");
6801 }
6802
6803 if (!Args.hasArg(options::OPT_nostdlib) &&
6804 !Args.hasArg(options::OPT_nostartfiles)) {
6805 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006806 if (Args.hasArg(options::OPT_pg))
6807 CmdArgs.push_back(Args.MakeArgString(
6808 getToolChain().GetFilePath("gcrt0.o")));
6809 else
6810 CmdArgs.push_back(Args.MakeArgString(
6811 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006812 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006813 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006814 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006815 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006816 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006817 }
6818 }
6819
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006820 std::string Triple = getToolChain().getTripleString();
6821 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006822 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006823 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006824 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006825
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006826 Args.AddAllArgs(CmdArgs, options::OPT_L);
6827 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6828 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006829 Args.AddAllArgs(CmdArgs, options::OPT_s);
6830 Args.AddAllArgs(CmdArgs, options::OPT_t);
6831 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6832 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006833
Daniel Dunbar54423b22010-09-17 00:24:54 +00006834 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006835
6836 if (!Args.hasArg(options::OPT_nostdlib) &&
6837 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006838 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006839 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006840 if (Args.hasArg(options::OPT_pg))
6841 CmdArgs.push_back("-lm_p");
6842 else
6843 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006844 }
6845
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006846 // FIXME: For some reason GCC passes -lgcc before adding
6847 // the default system libraries. Just mimic this for now.
6848 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006849
Eric Christopher17674ec2012-09-13 06:32:34 +00006850 if (Args.hasArg(options::OPT_pthread)) {
6851 if (!Args.hasArg(options::OPT_shared) &&
6852 Args.hasArg(options::OPT_pg))
6853 CmdArgs.push_back("-lpthread_p");
6854 else
6855 CmdArgs.push_back("-lpthread");
6856 }
6857
Chandler Carruth45661652011-12-17 22:32:42 +00006858 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006859 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006860 CmdArgs.push_back("-lc_p");
6861 else
6862 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006863 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006864
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006865 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006866 }
6867
6868 if (!Args.hasArg(options::OPT_nostdlib) &&
6869 !Args.hasArg(options::OPT_nostartfiles)) {
6870 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006871 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006872 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006873 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006874 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006875 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006876 }
6877
6878 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006879 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006880 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006881}
Ed Schoutene33194b2009-04-02 19:13:12 +00006882
Eli Friedman9fa28852012-08-08 23:57:20 +00006883void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6884 const InputInfo &Output,
6885 const InputInfoList &Inputs,
6886 const ArgList &Args,
6887 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006888 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00006889 ArgStringList CmdArgs;
6890
6891 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6892 options::OPT_Xassembler);
6893
6894 CmdArgs.push_back("-o");
6895 CmdArgs.push_back(Output.getFilename());
6896
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006897 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006898 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006899
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006900 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006901 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006902}
6903
6904void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6905 const InputInfo &Output,
6906 const InputInfoList &Inputs,
6907 const ArgList &Args,
6908 const char *LinkingOutput) const {
6909 const Driver &D = getToolChain().getDriver();
6910 ArgStringList CmdArgs;
6911
6912 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6913 (!Args.hasArg(options::OPT_shared))) {
6914 CmdArgs.push_back("-e");
6915 CmdArgs.push_back("__start");
6916 }
6917
6918 if (Args.hasArg(options::OPT_static)) {
6919 CmdArgs.push_back("-Bstatic");
6920 } else {
6921 if (Args.hasArg(options::OPT_rdynamic))
6922 CmdArgs.push_back("-export-dynamic");
6923 CmdArgs.push_back("--eh-frame-hdr");
6924 CmdArgs.push_back("-Bdynamic");
6925 if (Args.hasArg(options::OPT_shared)) {
6926 CmdArgs.push_back("-shared");
6927 } else {
6928 CmdArgs.push_back("-dynamic-linker");
6929 CmdArgs.push_back("/usr/libexec/ld.so");
6930 }
6931 }
6932
6933 if (Output.isFilename()) {
6934 CmdArgs.push_back("-o");
6935 CmdArgs.push_back(Output.getFilename());
6936 } else {
6937 assert(Output.isNothing() && "Invalid output.");
6938 }
6939
6940 if (!Args.hasArg(options::OPT_nostdlib) &&
6941 !Args.hasArg(options::OPT_nostartfiles)) {
6942 if (!Args.hasArg(options::OPT_shared)) {
6943 if (Args.hasArg(options::OPT_pg))
6944 CmdArgs.push_back(Args.MakeArgString(
6945 getToolChain().GetFilePath("gcrt0.o")));
6946 else
6947 CmdArgs.push_back(Args.MakeArgString(
6948 getToolChain().GetFilePath("crt0.o")));
6949 CmdArgs.push_back(Args.MakeArgString(
6950 getToolChain().GetFilePath("crtbegin.o")));
6951 } else {
6952 CmdArgs.push_back(Args.MakeArgString(
6953 getToolChain().GetFilePath("crtbeginS.o")));
6954 }
6955 }
6956
6957 Args.AddAllArgs(CmdArgs, options::OPT_L);
6958 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6959 Args.AddAllArgs(CmdArgs, options::OPT_e);
6960
6961 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6962
6963 if (!Args.hasArg(options::OPT_nostdlib) &&
6964 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006965 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006966 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6967 if (Args.hasArg(options::OPT_pg))
6968 CmdArgs.push_back("-lm_p");
6969 else
6970 CmdArgs.push_back("-lm");
6971 }
6972
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006973 if (Args.hasArg(options::OPT_pthread)) {
6974 if (!Args.hasArg(options::OPT_shared) &&
6975 Args.hasArg(options::OPT_pg))
6976 CmdArgs.push_back("-lpthread_p");
6977 else
6978 CmdArgs.push_back("-lpthread");
6979 }
6980
Eli Friedman9fa28852012-08-08 23:57:20 +00006981 if (!Args.hasArg(options::OPT_shared)) {
6982 if (Args.hasArg(options::OPT_pg))
6983 CmdArgs.push_back("-lc_p");
6984 else
6985 CmdArgs.push_back("-lc");
6986 }
6987
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006988 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006989 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006990 case llvm::Triple::arm:
6991 MyArch = "arm";
6992 break;
6993 case llvm::Triple::x86:
6994 MyArch = "i386";
6995 break;
6996 case llvm::Triple::x86_64:
6997 MyArch = "amd64";
6998 break;
6999 default:
7000 llvm_unreachable("Unsupported architecture");
7001 }
7002 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00007003 }
7004
7005 if (!Args.hasArg(options::OPT_nostdlib) &&
7006 !Args.hasArg(options::OPT_nostartfiles)) {
7007 if (!Args.hasArg(options::OPT_shared))
7008 CmdArgs.push_back(Args.MakeArgString(
7009 getToolChain().GetFilePath("crtend.o")));
7010 else
7011 CmdArgs.push_back(Args.MakeArgString(
7012 getToolChain().GetFilePath("crtendS.o")));
7013 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00007014
7015 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007016 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007017 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007018}
7019
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007020void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007021 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007022 const InputInfoList &Inputs,
7023 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00007024 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007025 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007026 ArgStringList CmdArgs;
7027
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007028 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7029 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007030 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007031 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007032 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00007033 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007034 else if (getToolChain().getArch() == llvm::Triple::mips ||
7035 getToolChain().getArch() == llvm::Triple::mipsel ||
7036 getToolChain().getArch() == llvm::Triple::mips64 ||
7037 getToolChain().getArch() == llvm::Triple::mips64el) {
7038 StringRef CPUName;
7039 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007040 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007041
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007042 CmdArgs.push_back("-march");
7043 CmdArgs.push_back(CPUName.data());
7044
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007045 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00007046 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007047
7048 if (getToolChain().getArch() == llvm::Triple::mips ||
7049 getToolChain().getArch() == llvm::Triple::mips64)
7050 CmdArgs.push_back("-EB");
7051 else
7052 CmdArgs.push_back("-EL");
7053
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007054 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007055 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007056 getToolChain().getArch() == llvm::Triple::armeb ||
7057 getToolChain().getArch() == llvm::Triple::thumb ||
7058 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00007059 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007060 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00007061 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
7062
7063 if (FloatABI == "hard") {
7064 CmdArgs.push_back("-mfpu=vfp");
7065 } else {
7066 CmdArgs.push_back("-mfpu=softvfp");
7067 }
7068
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007069 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00007070 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007071 case llvm::Triple::GNUEABI:
7072 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00007073 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007074 break;
7075
7076 default:
7077 CmdArgs.push_back("-matpcs");
7078 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00007079 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007080 getToolChain().getArch() == llvm::Triple::sparcel ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00007081 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00007082 if (getToolChain().getArch() == llvm::Triple::sparc)
7083 CmdArgs.push_back("-Av8plusa");
7084 else
7085 CmdArgs.push_back("-Av9a");
7086
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007087 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007088 }
Eric Christopher0b26a612010-03-02 02:41:08 +00007089
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007090 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7091 options::OPT_Xassembler);
7092
7093 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007094 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007095
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007096 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007097 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007098
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007099 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007100 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007101}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007102
7103void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007104 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007105 const InputInfoList &Inputs,
7106 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00007107 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007108 const toolchains::FreeBSD &ToolChain =
7109 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00007110 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007111 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007112 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007113 !Args.hasArg(options::OPT_shared) &&
7114 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007115 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00007116
7117 // Silence warning for "clang -g foo.o -o foo"
7118 Args.ClaimAllArgs(options::OPT_g_Group);
7119 // and "clang -emit-llvm foo.o -o foo"
7120 Args.ClaimAllArgs(options::OPT_emit_llvm);
7121 // and for "clang -w foo.o -o foo". Other warning options are already
7122 // handled somewhere else.
7123 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007124
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007125 if (!D.SysRoot.empty())
7126 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7127
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007128 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007129 CmdArgs.push_back("-pie");
7130
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007131 if (Args.hasArg(options::OPT_static)) {
7132 CmdArgs.push_back("-Bstatic");
7133 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007134 if (Args.hasArg(options::OPT_rdynamic))
7135 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007136 CmdArgs.push_back("--eh-frame-hdr");
7137 if (Args.hasArg(options::OPT_shared)) {
7138 CmdArgs.push_back("-Bshareable");
7139 } else {
7140 CmdArgs.push_back("-dynamic-linker");
7141 CmdArgs.push_back("/libexec/ld-elf.so.1");
7142 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007143 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00007144 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7145 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7146 CmdArgs.push_back("--hash-style=both");
7147 }
7148 }
7149 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007150 }
7151
7152 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7153 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007154 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007155 CmdArgs.push_back("-m");
7156 CmdArgs.push_back("elf_i386_fbsd");
7157 }
7158
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007159 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00007160 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00007161 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00007162 }
7163
Daniel Dunbarb440f562010-08-02 02:38:21 +00007164 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007165 CmdArgs.push_back("-o");
7166 CmdArgs.push_back(Output.getFilename());
7167 } else {
7168 assert(Output.isNothing() && "Invalid output.");
7169 }
7170
7171 if (!Args.hasArg(options::OPT_nostdlib) &&
7172 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007173 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007174 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007175 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00007176 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007177 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007178 crt1 = "Scrt1.o";
7179 else
7180 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007181 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007182 if (crt1)
7183 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7184
7185 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7186
Craig Topper92fc2df2014-05-17 16:56:41 +00007187 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00007188 if (Args.hasArg(options::OPT_static))
7189 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007190 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007191 crtbegin = "crtbeginS.o";
7192 else
7193 crtbegin = "crtbegin.o";
7194
7195 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007196 }
7197
7198 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007199 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007200 for (const auto &Path : Paths)
7201 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007202 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7203 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00007204 Args.AddAllArgs(CmdArgs, options::OPT_s);
7205 Args.AddAllArgs(CmdArgs, options::OPT_t);
7206 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7207 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007208
Peter Collingbournea4ccff32015-02-20 20:30:56 +00007209 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007210 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00007211
Alexey Samsonov52550342014-09-15 19:58:40 +00007212 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00007213 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007214
7215 if (!Args.hasArg(options::OPT_nostdlib) &&
7216 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007217 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00007218 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00007219 if (Args.hasArg(options::OPT_pg))
7220 CmdArgs.push_back("-lm_p");
7221 else
7222 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007223 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007224 if (NeedsSanitizerDeps)
7225 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007226 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7227 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007228 if (Args.hasArg(options::OPT_pg))
7229 CmdArgs.push_back("-lgcc_p");
7230 else
7231 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007232 if (Args.hasArg(options::OPT_static)) {
7233 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007234 } else if (Args.hasArg(options::OPT_pg)) {
7235 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007236 } else {
7237 CmdArgs.push_back("--as-needed");
7238 CmdArgs.push_back("-lgcc_s");
7239 CmdArgs.push_back("--no-as-needed");
7240 }
7241
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007242 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007243 if (Args.hasArg(options::OPT_pg))
7244 CmdArgs.push_back("-lpthread_p");
7245 else
7246 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007247 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007248
Roman Divacky66f22762011-02-10 16:59:40 +00007249 if (Args.hasArg(options::OPT_pg)) {
7250 if (Args.hasArg(options::OPT_shared))
7251 CmdArgs.push_back("-lc");
7252 else
7253 CmdArgs.push_back("-lc_p");
7254 CmdArgs.push_back("-lgcc_p");
7255 } else {
7256 CmdArgs.push_back("-lc");
7257 CmdArgs.push_back("-lgcc");
7258 }
7259
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007260 if (Args.hasArg(options::OPT_static)) {
7261 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007262 } else if (Args.hasArg(options::OPT_pg)) {
7263 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007264 } else {
7265 CmdArgs.push_back("--as-needed");
7266 CmdArgs.push_back("-lgcc_s");
7267 CmdArgs.push_back("--no-as-needed");
7268 }
7269 }
7270
7271 if (!Args.hasArg(options::OPT_nostdlib) &&
7272 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007273 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007274 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007275 else
7276 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007277 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007278 }
7279
Alexey Samsonov7811d192014-02-20 13:57:37 +00007280 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007281
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007282 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007283 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007284 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007285}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007286
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007287void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7288 const InputInfo &Output,
7289 const InputInfoList &Inputs,
7290 const ArgList &Args,
7291 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007292 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007293 ArgStringList CmdArgs;
7294
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007295 // GNU as needs different flags for creating the correct output format
7296 // on architectures with different ABIs or optional feature sets.
7297 switch (getToolChain().getArch()) {
7298 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007299 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007300 break;
7301 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007302 case llvm::Triple::armeb:
7303 case llvm::Triple::thumb:
7304 case llvm::Triple::thumbeb: {
Gabor Ballabas208826c2015-06-04 17:56:32 +00007305 std::string MArch = arm::getARMTargetCPU(Args, getToolChain().getTriple());
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007306 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007307 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007308 }
7309
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007310 case llvm::Triple::mips:
7311 case llvm::Triple::mipsel:
7312 case llvm::Triple::mips64:
7313 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007314 StringRef CPUName;
7315 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007316 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007317
7318 CmdArgs.push_back("-march");
7319 CmdArgs.push_back(CPUName.data());
7320
7321 CmdArgs.push_back("-mabi");
7322 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7323
7324 if (getToolChain().getArch() == llvm::Triple::mips ||
7325 getToolChain().getArch() == llvm::Triple::mips64)
7326 CmdArgs.push_back("-EB");
7327 else
7328 CmdArgs.push_back("-EL");
7329
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007330 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007331 break;
7332 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007333
7334 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007335 case llvm::Triple::sparcel:
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007336 CmdArgs.push_back("-32");
7337 addAssemblerKPIC(Args, CmdArgs);
7338 break;
7339
7340 case llvm::Triple::sparcv9:
7341 CmdArgs.push_back("-64");
7342 CmdArgs.push_back("-Av9");
7343 addAssemblerKPIC(Args, CmdArgs);
7344 break;
7345
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007346 default:
7347 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007348 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007349
7350 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7351 options::OPT_Xassembler);
7352
7353 CmdArgs.push_back("-o");
7354 CmdArgs.push_back(Output.getFilename());
7355
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007356 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007357 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007358
David Chisnallddbd68f2011-09-27 22:03:18 +00007359 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00007360 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007361}
7362
7363void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
7364 const InputInfo &Output,
7365 const InputInfoList &Inputs,
7366 const ArgList &Args,
7367 const char *LinkingOutput) const {
7368 const Driver &D = getToolChain().getDriver();
7369 ArgStringList CmdArgs;
7370
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007371 if (!D.SysRoot.empty())
7372 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7373
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007374 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007375 if (Args.hasArg(options::OPT_static)) {
7376 CmdArgs.push_back("-Bstatic");
7377 } else {
7378 if (Args.hasArg(options::OPT_rdynamic))
7379 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007380 if (Args.hasArg(options::OPT_shared)) {
7381 CmdArgs.push_back("-Bshareable");
7382 } else {
7383 CmdArgs.push_back("-dynamic-linker");
7384 CmdArgs.push_back("/libexec/ld.elf_so");
7385 }
7386 }
7387
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007388 // Many NetBSD architectures support more than one ABI.
7389 // Determine the correct emulation for ld.
7390 switch (getToolChain().getArch()) {
7391 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007392 CmdArgs.push_back("-m");
7393 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007394 break;
7395 case llvm::Triple::arm:
7396 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007397 CmdArgs.push_back("-m");
7398 switch (getToolChain().getTriple().getEnvironment()) {
7399 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007400 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007401 CmdArgs.push_back("armelf_nbsd_eabi");
7402 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007403 case llvm::Triple::EABIHF:
7404 case llvm::Triple::GNUEABIHF:
7405 CmdArgs.push_back("armelf_nbsd_eabihf");
7406 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007407 default:
7408 CmdArgs.push_back("armelf_nbsd");
7409 break;
7410 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007411 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007412 case llvm::Triple::armeb:
7413 case llvm::Triple::thumbeb:
John Brawn94fd9632015-05-21 12:19:49 +00007414 arm::appendEBLinkFlags(Args, CmdArgs,
7415 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007416 CmdArgs.push_back("-m");
7417 switch (getToolChain().getTriple().getEnvironment()) {
7418 case llvm::Triple::EABI:
7419 case llvm::Triple::GNUEABI:
7420 CmdArgs.push_back("armelfb_nbsd_eabi");
7421 break;
7422 case llvm::Triple::EABIHF:
7423 case llvm::Triple::GNUEABIHF:
7424 CmdArgs.push_back("armelfb_nbsd_eabihf");
7425 break;
7426 default:
7427 CmdArgs.push_back("armelfb_nbsd");
7428 break;
7429 }
7430 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007431 case llvm::Triple::mips64:
7432 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007433 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007434 CmdArgs.push_back("-m");
7435 if (getToolChain().getArch() == llvm::Triple::mips64)
7436 CmdArgs.push_back("elf32btsmip");
7437 else
7438 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007439 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007440 CmdArgs.push_back("-m");
7441 if (getToolChain().getArch() == llvm::Triple::mips64)
7442 CmdArgs.push_back("elf64btsmip");
7443 else
7444 CmdArgs.push_back("elf64ltsmip");
7445 }
7446 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007447 case llvm::Triple::ppc:
7448 CmdArgs.push_back("-m");
7449 CmdArgs.push_back("elf32ppc_nbsd");
7450 break;
7451
7452 case llvm::Triple::ppc64:
7453 case llvm::Triple::ppc64le:
7454 CmdArgs.push_back("-m");
7455 CmdArgs.push_back("elf64ppc");
7456 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007457
7458 case llvm::Triple::sparc:
7459 CmdArgs.push_back("-m");
7460 CmdArgs.push_back("elf32_sparc");
7461 break;
7462
7463 case llvm::Triple::sparcv9:
7464 CmdArgs.push_back("-m");
7465 CmdArgs.push_back("elf64_sparc");
7466 break;
7467
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007468 default:
7469 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007470 }
7471
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007472 if (Output.isFilename()) {
7473 CmdArgs.push_back("-o");
7474 CmdArgs.push_back(Output.getFilename());
7475 } else {
7476 assert(Output.isNothing() && "Invalid output.");
7477 }
7478
7479 if (!Args.hasArg(options::OPT_nostdlib) &&
7480 !Args.hasArg(options::OPT_nostartfiles)) {
7481 if (!Args.hasArg(options::OPT_shared)) {
7482 CmdArgs.push_back(Args.MakeArgString(
7483 getToolChain().GetFilePath("crt0.o")));
7484 CmdArgs.push_back(Args.MakeArgString(
7485 getToolChain().GetFilePath("crti.o")));
7486 CmdArgs.push_back(Args.MakeArgString(
7487 getToolChain().GetFilePath("crtbegin.o")));
7488 } else {
7489 CmdArgs.push_back(Args.MakeArgString(
7490 getToolChain().GetFilePath("crti.o")));
7491 CmdArgs.push_back(Args.MakeArgString(
7492 getToolChain().GetFilePath("crtbeginS.o")));
7493 }
7494 }
7495
7496 Args.AddAllArgs(CmdArgs, options::OPT_L);
7497 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7498 Args.AddAllArgs(CmdArgs, options::OPT_e);
7499 Args.AddAllArgs(CmdArgs, options::OPT_s);
7500 Args.AddAllArgs(CmdArgs, options::OPT_t);
7501 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7502 Args.AddAllArgs(CmdArgs, options::OPT_r);
7503
7504 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7505
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007506 unsigned Major, Minor, Micro;
7507 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7508 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007509 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007510 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007511 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00007512 case llvm::Triple::arm:
7513 case llvm::Triple::armeb:
7514 case llvm::Triple::thumb:
7515 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007516 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007517 case llvm::Triple::ppc64:
7518 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007519 case llvm::Triple::x86:
7520 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007521 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007522 break;
7523 default:
7524 break;
7525 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007526 }
7527
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007528 if (!Args.hasArg(options::OPT_nostdlib) &&
7529 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007530 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007531 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7532 CmdArgs.push_back("-lm");
7533 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007534 if (Args.hasArg(options::OPT_pthread))
7535 CmdArgs.push_back("-lpthread");
7536 CmdArgs.push_back("-lc");
7537
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007538 if (useLibgcc) {
7539 if (Args.hasArg(options::OPT_static)) {
7540 // libgcc_eh depends on libc, so resolve as much as possible,
7541 // pull in any new requirements from libc and then get the rest
7542 // of libgcc.
7543 CmdArgs.push_back("-lgcc_eh");
7544 CmdArgs.push_back("-lc");
7545 CmdArgs.push_back("-lgcc");
7546 } else {
7547 CmdArgs.push_back("-lgcc");
7548 CmdArgs.push_back("--as-needed");
7549 CmdArgs.push_back("-lgcc_s");
7550 CmdArgs.push_back("--no-as-needed");
7551 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007552 }
7553 }
7554
7555 if (!Args.hasArg(options::OPT_nostdlib) &&
7556 !Args.hasArg(options::OPT_nostartfiles)) {
7557 if (!Args.hasArg(options::OPT_shared))
7558 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7559 "crtend.o")));
7560 else
7561 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7562 "crtendS.o")));
7563 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7564 "crtn.o")));
7565 }
7566
Alexey Samsonov7811d192014-02-20 13:57:37 +00007567 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007568
Logan Chieneb9162f2014-06-26 14:23:45 +00007569 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007570 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007571}
7572
Thomas Schwinge4e555262013-03-28 19:04:25 +00007573void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7574 const InputInfo &Output,
7575 const InputInfoList &Inputs,
7576 const ArgList &Args,
7577 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007578 claimNoWarnArgs(Args);
7579
Rafael Espindola92b00932010-08-10 00:25:48 +00007580 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007581 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007582
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007583 switch (getToolChain().getArch()) {
7584 default:
7585 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00007586 // Add --32/--64 to make sure we get the format we want.
7587 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007588 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00007589 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007590 break;
7591 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00007592 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7593 CmdArgs.push_back("--x32");
7594 else
7595 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007596 break;
7597 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007598 CmdArgs.push_back("-a32");
7599 CmdArgs.push_back("-mppc");
7600 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007601 break;
7602 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007603 CmdArgs.push_back("-a64");
7604 CmdArgs.push_back("-mppc64");
7605 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007606 break;
7607 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00007608 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007609 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007610 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007611 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007612 break;
7613 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007614 case llvm::Triple::sparcel:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007615 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007616 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007617 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007618 break;
7619 case llvm::Triple::sparcv9:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007620 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007621 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007622 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007623 break;
7624 case llvm::Triple::arm:
7625 case llvm::Triple::armeb:
7626 case llvm::Triple::thumb:
7627 case llvm::Triple::thumbeb: {
Scott Douglass3205f522015-03-23 10:54:24 +00007628 const llvm::Triple &Triple = getToolChain().getTriple();
7629 switch (Triple.getSubArch()) {
7630 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00007631 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00007632 break;
7633 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00007634 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00007635 break;
7636 default:
7637 break;
7638 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007639
Tim Northover9c7e0352013-12-12 11:55:52 +00007640 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
Derek Schuffa419e1c2015-04-10 23:07:19 +00007641 getToolChain().getDriver(), Args,
7642 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007643 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007644
7645 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007646
7647 // FIXME: remove krait check when GNU tools support krait cpu
7648 // for now replace it with -march=armv7-a to avoid a lower
7649 // march from being picked in the absence of a cpu flag.
7650 Arg *A;
7651 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Gabor Ballabas208826c2015-06-04 17:56:32 +00007652 StringRef(A->getValue()).lower() == "krait")
Ana Pazosdd6068d2013-12-06 22:43:17 +00007653 CmdArgs.push_back("-march=armv7-a");
7654 else
7655 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007656 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007657 break;
7658 }
7659 case llvm::Triple::mips:
7660 case llvm::Triple::mipsel:
7661 case llvm::Triple::mips64:
7662 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007663 StringRef CPUName;
7664 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007665 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007666 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007667
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007668 CmdArgs.push_back("-march");
7669 CmdArgs.push_back(CPUName.data());
7670
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007671 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007672 CmdArgs.push_back(ABIName.data());
7673
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007674 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7675 // or -mshared (not implemented) is in effect.
7676 bool IsPicOrPie = false;
7677 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7678 options::OPT_fpic, options::OPT_fno_pic,
7679 options::OPT_fPIE, options::OPT_fno_PIE,
7680 options::OPT_fpie, options::OPT_fno_pie)) {
7681 if (A->getOption().matches(options::OPT_fPIC) ||
7682 A->getOption().matches(options::OPT_fpic) ||
7683 A->getOption().matches(options::OPT_fPIE) ||
7684 A->getOption().matches(options::OPT_fpie))
7685 IsPicOrPie = true;
7686 }
7687 if (!IsPicOrPie)
7688 CmdArgs.push_back("-mno-shared");
7689
Daniel Sanders379d44b2014-07-16 11:52:23 +00007690 // LLVM doesn't support -mplt yet and acts as if it is always given.
7691 // However, -mplt has no effect with the N64 ABI.
7692 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007693
7694 if (getToolChain().getArch() == llvm::Triple::mips ||
7695 getToolChain().getArch() == llvm::Triple::mips64)
7696 CmdArgs.push_back("-EB");
7697 else
7698 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007699
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007700 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7701 if (StringRef(A->getValue()) == "2008")
7702 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7703 }
7704
Daniel Sanders379d44b2014-07-16 11:52:23 +00007705 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7706 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7707 options::OPT_mfp64)) {
7708 A->claim();
7709 A->render(Args, CmdArgs);
7710 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7711 ABIName))
7712 CmdArgs.push_back("-mfpxx");
7713
7714 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7715 // -mno-mips16 is actually -no-mips16.
7716 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7717 options::OPT_mno_mips16)) {
7718 if (A->getOption().matches(options::OPT_mips16)) {
7719 A->claim();
7720 A->render(Args, CmdArgs);
7721 } else {
7722 A->claim();
7723 CmdArgs.push_back("-no-mips16");
7724 }
7725 }
7726
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007727 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7728 options::OPT_mno_micromips);
7729 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7730 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7731
Simon Atanasyanbd986632013-11-26 11:58:04 +00007732 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7733 // Do not use AddLastArg because not all versions of MIPS assembler
7734 // support -mmsa / -mno-msa options.
7735 if (A->getOption().matches(options::OPT_mmsa))
7736 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7737 }
7738
Daniel Sanders379d44b2014-07-16 11:52:23 +00007739 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7740 options::OPT_msoft_float);
7741
Toma Tabacub36d6102015-06-11 12:13:18 +00007742 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
7743 options::OPT_msingle_float);
7744
Daniel Sanders379d44b2014-07-16 11:52:23 +00007745 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7746 options::OPT_mno_odd_spreg);
7747
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007748 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007749 break;
7750 }
7751 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007752 // Always pass an -march option, since our default of z10 is later
7753 // than the GNU assembler's default.
7754 StringRef CPUName = getSystemZTargetCPU(Args);
7755 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007756 break;
7757 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007758 }
7759
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007760 if (NeedsKPIC)
7761 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007762
7763 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7764 options::OPT_Xassembler);
7765
7766 CmdArgs.push_back("-o");
7767 CmdArgs.push_back(Output.getFilename());
7768
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007769 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007770 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007771
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007772 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007773 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007774
7775 // Handle the debug info splitting at object creation time if we're
7776 // creating an object.
7777 // TODO: Currently only works on linux with newer objcopy.
7778 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007779 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007780 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00007781 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00007782}
7783
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007784static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007785 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007786 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007787 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7788 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007789 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007790 CmdArgs.push_back("-lgcc");
7791
Logan Chien3d3373c2012-11-19 12:04:11 +00007792 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007793 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007794 CmdArgs.push_back("-lgcc");
7795 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007796 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007797 CmdArgs.push_back("--as-needed");
7798 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007799 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007800 CmdArgs.push_back("--no-as-needed");
7801 }
7802
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007803 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007804 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007805 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007806 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007807
7808 // According to Android ABI, we have to link with libdl if we are
7809 // linking with non-static libgcc.
7810 //
7811 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7812 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7813 if (isAndroid && !StaticLibgcc)
7814 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007815}
7816
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007817static std::string getLinuxDynamicLinker(const ArgList &Args,
7818 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007819 const llvm::Triple::ArchType Arch = ToolChain.getArch();
7820
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007821 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7822 if (ToolChain.getTriple().isArch64Bit())
7823 return "/system/bin/linker64";
7824 else
7825 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007826 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
7827 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007828 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007829 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007830 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007831 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007832 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007833 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007834 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7835 return "/lib/ld-linux-armhf.so.3";
7836 else
7837 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007838 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
7839 // TODO: check which dynamic linker name.
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007840 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007841 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007842 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007843 return "/lib/ld-linux.so.3";
7844 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
7845 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007846 StringRef CPUName;
7847 StringRef ABIName;
7848 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7849 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7850
7851 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7852 .Case("o32", "/lib")
7853 .Case("n32", "/lib32")
7854 .Case("n64", "/lib64")
7855 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007856 StringRef LibName;
7857 if (mips::isUCLibc(Args))
7858 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7859 else
7860 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007861
7862 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007863 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007864 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007865 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007866 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7867 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007868 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007869 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007870 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7871 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007872 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007873 } else if (Arch == llvm::Triple::systemz)
Ulrich Weigand8afad612014-07-28 13:17:52 +00007874 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007875 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007876 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007877 else if (Arch == llvm::Triple::x86_64 &&
Zinovy Nis1db95732014-07-10 15:27:19 +00007878 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7879 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007880 else
7881 return "/lib64/ld-linux-x86-64.so.2";
7882}
7883
Renato Golinc4b49242014-02-13 10:01:16 +00007884static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007885 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007886 // Make use of compiler-rt if --rtlib option is used
7887 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7888
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007889 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007890 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007891 switch (TC.getTriple().getOS()) {
7892 default: llvm_unreachable("unsupported OS");
7893 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007894 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007895 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007896 break;
7897 }
Renato Golinc4b49242014-02-13 10:01:16 +00007898 break;
7899 case ToolChain::RLT_Libgcc:
7900 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7901 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007902 }
7903}
7904
Rafael Espindola1e085772014-08-15 17:14:35 +00007905static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7906 switch (T.getArch()) {
7907 case llvm::Triple::x86:
7908 return "elf_i386";
7909 case llvm::Triple::aarch64:
7910 return "aarch64linux";
7911 case llvm::Triple::aarch64_be:
7912 return "aarch64_be_linux";
7913 case llvm::Triple::arm:
7914 case llvm::Triple::thumb:
7915 return "armelf_linux_eabi";
7916 case llvm::Triple::armeb:
7917 case llvm::Triple::thumbeb:
7918 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7919 case llvm::Triple::ppc:
7920 return "elf32ppclinux";
7921 case llvm::Triple::ppc64:
7922 return "elf64ppc";
7923 case llvm::Triple::ppc64le:
7924 return "elf64lppc";
7925 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007926 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00007927 return "elf32_sparc";
7928 case llvm::Triple::sparcv9:
7929 return "elf64_sparc";
7930 case llvm::Triple::mips:
7931 return "elf32btsmip";
7932 case llvm::Triple::mipsel:
7933 return "elf32ltsmip";
7934 case llvm::Triple::mips64:
7935 if (mips::hasMipsAbiArg(Args, "n32"))
7936 return "elf32btsmipn32";
7937 return "elf64btsmip";
7938 case llvm::Triple::mips64el:
7939 if (mips::hasMipsAbiArg(Args, "n32"))
7940 return "elf32ltsmipn32";
7941 return "elf64ltsmip";
7942 case llvm::Triple::systemz:
7943 return "elf64_s390";
7944 case llvm::Triple::x86_64:
7945 if (T.getEnvironment() == llvm::Triple::GNUX32)
7946 return "elf32_x86_64";
7947 return "elf_x86_64";
7948 default:
7949 llvm_unreachable("Unexpected arch");
7950 }
7951}
7952
Thomas Schwinge4e555262013-03-28 19:04:25 +00007953void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7954 const InputInfo &Output,
7955 const InputInfoList &Inputs,
7956 const ArgList &Args,
7957 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007958 const toolchains::Linux &ToolChain =
7959 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007960 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007961 const llvm::Triple::ArchType Arch = ToolChain.getArch();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007962 const bool isAndroid =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007963 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007964 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007965 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
7966 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007967
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007968 ArgStringList CmdArgs;
7969
Rafael Espindolad1002f62010-11-15 18:28:16 +00007970 // Silence warning for "clang -g foo.o -o foo"
7971 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007972 // and "clang -emit-llvm foo.o -o foo"
7973 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007974 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007975 // handled somewhere else.
7976 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007977
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007978 if (!D.SysRoot.empty())
7979 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007980
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007981 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007982 CmdArgs.push_back("-pie");
7983
Rafael Espindola1c76c592010-11-07 22:57:16 +00007984 if (Args.hasArg(options::OPT_rdynamic))
7985 CmdArgs.push_back("-export-dynamic");
7986
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007987 if (Args.hasArg(options::OPT_s))
7988 CmdArgs.push_back("-s");
7989
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007990 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
7991 arm::appendEBLinkFlags(
7992 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00007993 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007994
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007995 for (const auto &Opt : ToolChain.ExtraOpts)
7996 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007997
7998 if (!Args.hasArg(options::OPT_static)) {
7999 CmdArgs.push_back("--eh-frame-hdr");
8000 }
8001
8002 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00008003 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008004
8005 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008006 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8007 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008008 CmdArgs.push_back("-Bstatic");
8009 else
8010 CmdArgs.push_back("-static");
8011 } else if (Args.hasArg(options::OPT_shared)) {
8012 CmdArgs.push_back("-shared");
8013 }
8014
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008015 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8016 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008017 (!Args.hasArg(options::OPT_static) &&
8018 !Args.hasArg(options::OPT_shared))) {
8019 CmdArgs.push_back("-dynamic-linker");
8020 CmdArgs.push_back(Args.MakeArgString(
8021 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
8022 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008023
8024 CmdArgs.push_back("-o");
8025 CmdArgs.push_back(Output.getFilename());
8026
Rafael Espindola81937ec2010-12-01 01:52:43 +00008027 if (!Args.hasArg(options::OPT_nostdlib) &&
8028 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008029 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008030 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008031 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00008032 if (Args.hasArg(options::OPT_pg))
8033 crt1 = "gcrt1.o";
8034 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008035 crt1 = "Scrt1.o";
8036 else
8037 crt1 = "crt1.o";
8038 }
8039 if (crt1)
8040 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008041
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008042 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8043 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008044
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008045 const char *crtbegin;
8046 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008047 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008048 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008049 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008050 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008051 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008052 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008053 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008054 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00008055
8056 // Add crtfastmath.o if available and fast math is enabled.
8057 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008058 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008059
8060 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00008061 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008062
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00008063 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008064
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008065 for (const auto &Path : Paths)
8066 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008067
Peter Collingbournea4ccff32015-02-20 20:30:56 +00008068 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00008069 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00008070
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00008071 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8072 CmdArgs.push_back("--no-demangle");
8073
Alexey Samsonov52550342014-09-15 19:58:40 +00008074 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008075 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008076 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00008077 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008078
Hans Wennborg70850d82013-07-18 20:29:38 +00008079 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00008080 !Args.hasArg(options::OPT_nostdlib) &&
8081 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00008082 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8083 !Args.hasArg(options::OPT_static);
8084 if (OnlyLibstdcxxStatic)
8085 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008086 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008087 if (OnlyLibstdcxxStatic)
8088 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008089 CmdArgs.push_back("-lm");
8090 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00008091 // Silence warnings when linking C code with a C++ '-stdlib' argument.
8092 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008093
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008094 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00008095 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8096 if (Args.hasArg(options::OPT_static))
8097 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00008098
Alexey Samsonov52550342014-09-15 19:58:40 +00008099 if (NeedsSanitizerDeps)
8100 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
8101
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008102 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8103 Args.hasArg(options::OPT_pthreads);
8104
8105 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8106 options::OPT_fno_openmp, false)) {
8107 // OpenMP runtimes implies pthreads when using the GNU toolchain.
8108 // FIXME: Does this really make sense for all GNU toolchains?
8109 WantPthread = true;
8110
8111 // Also link the particular OpenMP runtimes.
8112 switch (getOpenMPRuntime(ToolChain, Args)) {
8113 case OMPRT_OMP:
8114 CmdArgs.push_back("-lomp");
8115 break;
8116 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00008117 CmdArgs.push_back("-lgomp");
8118
8119 // FIXME: Exclude this for platforms with libgomp that don't require
8120 // librt. Most modern Linux platforms require it, but some may not.
8121 CmdArgs.push_back("-lrt");
8122 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008123 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00008124 CmdArgs.push_back("-liomp5");
8125 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008126 case OMPRT_Unknown:
8127 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00008128 break;
8129 }
Chandler Carruth01538002013-01-17 13:19:29 +00008130 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008131
Renato Golinc4b49242014-02-13 10:01:16 +00008132 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008133
Richard Smith31d1de22015-05-20 22:48:44 +00008134 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00008135 CmdArgs.push_back("-lpthread");
8136
8137 CmdArgs.push_back("-lc");
8138
8139 if (Args.hasArg(options::OPT_static))
8140 CmdArgs.push_back("--end-group");
8141 else
Renato Golinc4b49242014-02-13 10:01:16 +00008142 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00008143 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00008144
Rafael Espindola81937ec2010-12-01 01:52:43 +00008145 if (!Args.hasArg(options::OPT_nostartfiles)) {
8146 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008147 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008148 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008149 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008150 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00008151 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008152 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008153
Rafael Espindola81937ec2010-12-01 01:52:43 +00008154 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008155 if (!isAndroid)
8156 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00008157 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008158 }
8159
David Blaikiec11bf802014-09-04 16:04:28 +00008160 C.addCommand(
8161 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00008162}
8163
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008164
8165// NaCl ARM assembly (inline or standalone) can be written with a set of macros
8166// for the various SFI requirements like register masking. The assembly tool
8167// inserts the file containing the macros as an input into all the assembly
8168// jobs.
8169void nacltools::AssembleARM::ConstructJob(Compilation &C, const JobAction &JA,
8170 const InputInfo &Output,
8171 const InputInfoList &Inputs,
8172 const ArgList &Args,
8173 const char *LinkingOutput) const {
8174 const toolchains::NaCl_TC& ToolChain =
8175 static_cast<const toolchains::NaCl_TC&>(getToolChain());
8176 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8177 "nacl-arm-macros.s");
8178 InputInfoList NewInputs;
8179 NewInputs.push_back(NaClMacros);
8180 NewInputs.append(Inputs.begin(), Inputs.end());
8181 gnutools::Assemble::ConstructJob(C, JA, Output, NewInputs, Args,
8182 LinkingOutput);
8183}
8184
8185
8186// This is quite similar to gnutools::link::ConstructJob with changes that
8187// we use static by default, do not yet support sanitizers or LTO, and a few
8188// others. Eventually we can support more of that and hopefully migrate back
8189// to gnutools::link.
8190void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008191 const InputInfo &Output,
8192 const InputInfoList &Inputs,
8193 const ArgList &Args,
8194 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008195
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008196 const toolchains::NaCl_TC &ToolChain =
8197 static_cast<const toolchains::NaCl_TC &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008198 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008199 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008200 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008201 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008202
8203 ArgStringList CmdArgs;
8204
8205 // Silence warning for "clang -g foo.o -o foo"
8206 Args.ClaimAllArgs(options::OPT_g_Group);
8207 // and "clang -emit-llvm foo.o -o foo"
8208 Args.ClaimAllArgs(options::OPT_emit_llvm);
8209 // and for "clang -w foo.o -o foo". Other warning options are already
8210 // handled somewhere else.
8211 Args.ClaimAllArgs(options::OPT_w);
8212
8213 if (!D.SysRoot.empty())
8214 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8215
8216 if (Args.hasArg(options::OPT_rdynamic))
8217 CmdArgs.push_back("-export-dynamic");
8218
8219 if (Args.hasArg(options::OPT_s))
8220 CmdArgs.push_back("-s");
8221
8222 // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from
8223 // there is --build-id, which we do want.
8224 CmdArgs.push_back("--build-id");
8225
8226 if (!IsStatic)
8227 CmdArgs.push_back("--eh-frame-hdr");
8228
8229 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008230 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008231 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008232 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008233 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008234 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008235 CmdArgs.push_back("elf_x86_64_nacl");
8236 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008237 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8238 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008239
8240 if (IsStatic)
8241 CmdArgs.push_back("-static");
8242 else if (Args.hasArg(options::OPT_shared))
8243 CmdArgs.push_back("-shared");
8244
8245 CmdArgs.push_back("-o");
8246 CmdArgs.push_back(Output.getFilename());
8247 if (!Args.hasArg(options::OPT_nostdlib) &&
8248 !Args.hasArg(options::OPT_nostartfiles)) {
8249 if (!Args.hasArg(options::OPT_shared))
8250 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8251 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8252
8253 const char *crtbegin;
8254 if (IsStatic)
8255 crtbegin = "crtbeginT.o";
8256 else if (Args.hasArg(options::OPT_shared))
8257 crtbegin = "crtbeginS.o";
8258 else
8259 crtbegin = "crtbegin.o";
8260 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8261 }
8262
8263 Args.AddAllArgs(CmdArgs, options::OPT_L);
8264 Args.AddAllArgs(CmdArgs, options::OPT_u);
8265
8266 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8267
8268 for (const auto &Path : Paths)
8269 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8270
8271 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8272 CmdArgs.push_back("--no-demangle");
8273
8274 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8275
8276 if (D.CCCIsCXX() &&
8277 !Args.hasArg(options::OPT_nostdlib) &&
8278 !Args.hasArg(options::OPT_nodefaultlibs)) {
8279 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8280 !IsStatic;
8281 if (OnlyLibstdcxxStatic)
8282 CmdArgs.push_back("-Bstatic");
8283 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8284 if (OnlyLibstdcxxStatic)
8285 CmdArgs.push_back("-Bdynamic");
8286 CmdArgs.push_back("-lm");
8287 }
8288
8289 if (!Args.hasArg(options::OPT_nostdlib)) {
8290 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8291 // Always use groups, since it has no effect on dynamic libraries.
8292 CmdArgs.push_back("--start-group");
8293 CmdArgs.push_back("-lc");
8294 // NaCl's libc++ currently requires libpthread, so just always include it
8295 // in the group for C++.
8296 if (Args.hasArg(options::OPT_pthread) ||
8297 Args.hasArg(options::OPT_pthreads) ||
8298 D.CCCIsCXX()) {
8299 CmdArgs.push_back("-lpthread");
8300 }
8301
8302 CmdArgs.push_back("-lgcc");
8303 CmdArgs.push_back("--as-needed");
8304 if (IsStatic)
8305 CmdArgs.push_back("-lgcc_eh");
8306 else
8307 CmdArgs.push_back("-lgcc_s");
8308 CmdArgs.push_back("--no-as-needed");
8309 CmdArgs.push_back("--end-group");
8310 }
8311
8312 if (!Args.hasArg(options::OPT_nostartfiles)) {
8313 const char *crtend;
8314 if (Args.hasArg(options::OPT_shared))
8315 crtend = "crtendS.o";
8316 else
8317 crtend = "crtend.o";
8318
8319 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8320 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8321 }
8322 }
8323
8324 C.addCommand(llvm::make_unique<Command>(JA, *this,
8325 ToolChain.Linker.c_str(), CmdArgs));
8326}
8327
8328
Chris Lattner3e2ee142010-07-07 16:01:42 +00008329void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008330 const InputInfo &Output,
8331 const InputInfoList &Inputs,
8332 const ArgList &Args,
8333 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008334 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008335 ArgStringList CmdArgs;
8336
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008337 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008338
8339 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008340 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008341
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008342 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008343 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008344
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008345 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008346 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008347}
8348
8349void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008350 const InputInfo &Output,
8351 const InputInfoList &Inputs,
8352 const ArgList &Args,
8353 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008354 const Driver &D = getToolChain().getDriver();
8355 ArgStringList CmdArgs;
8356
Daniel Dunbarb440f562010-08-02 02:38:21 +00008357 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008358 CmdArgs.push_back("-o");
8359 CmdArgs.push_back(Output.getFilename());
8360 } else {
8361 assert(Output.isNothing() && "Invalid output.");
8362 }
8363
8364 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008365 !Args.hasArg(options::OPT_nostartfiles)) {
8366 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8367 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8368 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8369 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8370 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008371
8372 Args.AddAllArgs(CmdArgs, options::OPT_L);
8373 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8374 Args.AddAllArgs(CmdArgs, options::OPT_e);
8375
Daniel Dunbar54423b22010-09-17 00:24:54 +00008376 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008377
Alexey Samsonov7811d192014-02-20 13:57:37 +00008378 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008379
Chris Lattner3e2ee142010-07-07 16:01:42 +00008380 if (!Args.hasArg(options::OPT_nostdlib) &&
8381 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008382 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008383 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008384 CmdArgs.push_back("-lm");
8385 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008386 }
8387
8388 if (!Args.hasArg(options::OPT_nostdlib) &&
8389 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008390 if (Args.hasArg(options::OPT_pthread))
8391 CmdArgs.push_back("-lpthread");
8392 CmdArgs.push_back("-lc");
8393 CmdArgs.push_back("-lCompilerRT-Generic");
8394 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8395 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00008396 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008397 }
8398
Logan Chieneb9162f2014-06-26 14:23:45 +00008399 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008400 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008401}
8402
Daniel Dunbarcc912342009-05-02 18:28:39 +00008403/// DragonFly Tools
8404
8405// For now, DragonFly Assemble does just about the same as for
8406// FreeBSD, but this may change soon.
8407void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008408 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00008409 const InputInfoList &Inputs,
8410 const ArgList &Args,
8411 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008412 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008413 ArgStringList CmdArgs;
8414
8415 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8416 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008417 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008418 CmdArgs.push_back("--32");
8419
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008420 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008421
8422 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008423 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008424
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008425 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008426 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008427
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008428 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008429 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008430}
8431
8432void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008433 const InputInfo &Output,
8434 const InputInfoList &Inputs,
8435 const ArgList &Args,
8436 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008437 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008438 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008439 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008440
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008441 if (!D.SysRoot.empty())
8442 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8443
John McCall65b8da02013-04-11 22:55:55 +00008444 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008445 if (Args.hasArg(options::OPT_static)) {
8446 CmdArgs.push_back("-Bstatic");
8447 } else {
John McCall65b8da02013-04-11 22:55:55 +00008448 if (Args.hasArg(options::OPT_rdynamic))
8449 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008450 if (Args.hasArg(options::OPT_shared))
8451 CmdArgs.push_back("-Bshareable");
8452 else {
8453 CmdArgs.push_back("-dynamic-linker");
8454 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8455 }
John McCall65b8da02013-04-11 22:55:55 +00008456 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008457 }
8458
8459 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8460 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008461 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008462 CmdArgs.push_back("-m");
8463 CmdArgs.push_back("elf_i386");
8464 }
8465
Daniel Dunbarb440f562010-08-02 02:38:21 +00008466 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008467 CmdArgs.push_back("-o");
8468 CmdArgs.push_back(Output.getFilename());
8469 } else {
8470 assert(Output.isNothing() && "Invalid output.");
8471 }
8472
8473 if (!Args.hasArg(options::OPT_nostdlib) &&
8474 !Args.hasArg(options::OPT_nostartfiles)) {
8475 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008476 if (Args.hasArg(options::OPT_pg))
8477 CmdArgs.push_back(Args.MakeArgString(
8478 getToolChain().GetFilePath("gcrt1.o")));
8479 else {
8480 if (Args.hasArg(options::OPT_pie))
8481 CmdArgs.push_back(Args.MakeArgString(
8482 getToolChain().GetFilePath("Scrt1.o")));
8483 else
8484 CmdArgs.push_back(Args.MakeArgString(
8485 getToolChain().GetFilePath("crt1.o")));
8486 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008487 }
John McCall65b8da02013-04-11 22:55:55 +00008488 CmdArgs.push_back(Args.MakeArgString(
8489 getToolChain().GetFilePath("crti.o")));
8490 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8491 CmdArgs.push_back(Args.MakeArgString(
8492 getToolChain().GetFilePath("crtbeginS.o")));
8493 else
8494 CmdArgs.push_back(Args.MakeArgString(
8495 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008496 }
8497
8498 Args.AddAllArgs(CmdArgs, options::OPT_L);
8499 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8500 Args.AddAllArgs(CmdArgs, options::OPT_e);
8501
Daniel Dunbar54423b22010-09-17 00:24:54 +00008502 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008503
8504 if (!Args.hasArg(options::OPT_nostdlib) &&
8505 !Args.hasArg(options::OPT_nodefaultlibs)) {
8506 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8507 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00008508 if (UseGCC47)
8509 CmdArgs.push_back("-L/usr/lib/gcc47");
8510 else
8511 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008512
8513 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00008514 if (UseGCC47) {
8515 CmdArgs.push_back("-rpath");
8516 CmdArgs.push_back("/usr/lib/gcc47");
8517 } else {
8518 CmdArgs.push_back("-rpath");
8519 CmdArgs.push_back("/usr/lib/gcc44");
8520 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008521 }
8522
Hans Wennborg70850d82013-07-18 20:29:38 +00008523 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008524 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00008525 CmdArgs.push_back("-lm");
8526 }
8527
Daniel Dunbarcc912342009-05-02 18:28:39 +00008528 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00008529 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008530
8531 if (!Args.hasArg(options::OPT_nolibc)) {
8532 CmdArgs.push_back("-lc");
8533 }
8534
John McCall65b8da02013-04-11 22:55:55 +00008535 if (UseGCC47) {
8536 if (Args.hasArg(options::OPT_static) ||
8537 Args.hasArg(options::OPT_static_libgcc)) {
8538 CmdArgs.push_back("-lgcc");
8539 CmdArgs.push_back("-lgcc_eh");
8540 } else {
8541 if (Args.hasArg(options::OPT_shared_libgcc)) {
8542 CmdArgs.push_back("-lgcc_pic");
8543 if (!Args.hasArg(options::OPT_shared))
8544 CmdArgs.push_back("-lgcc");
8545 } else {
8546 CmdArgs.push_back("-lgcc");
8547 CmdArgs.push_back("--as-needed");
8548 CmdArgs.push_back("-lgcc_pic");
8549 CmdArgs.push_back("--no-as-needed");
8550 }
8551 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008552 } else {
John McCall65b8da02013-04-11 22:55:55 +00008553 if (Args.hasArg(options::OPT_shared)) {
8554 CmdArgs.push_back("-lgcc_pic");
8555 } else {
8556 CmdArgs.push_back("-lgcc");
8557 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008558 }
8559 }
8560
8561 if (!Args.hasArg(options::OPT_nostdlib) &&
8562 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00008563 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00008564 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00008565 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008566 else
8567 CmdArgs.push_back(Args.MakeArgString(
8568 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008569 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00008570 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008571 }
8572
Alexey Samsonov7811d192014-02-20 13:57:37 +00008573 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008574
Logan Chieneb9162f2014-06-26 14:23:45 +00008575 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008576 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008577}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008578
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008579// Try to find Exe from a Visual Studio distribution. This first tries to find
8580// an installed copy of Visual Studio and, failing that, looks in the PATH,
8581// making sure that whatever executable that's found is not a same-named exe
8582// from clang itself to prevent clang from falling back to itself.
8583static std::string FindVisualStudioExecutable(const ToolChain &TC,
8584 const char *Exe,
8585 const char *ClangProgramPath) {
8586 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8587 std::string visualStudioBinDir;
8588 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8589 visualStudioBinDir)) {
8590 SmallString<128> FilePath(visualStudioBinDir);
8591 llvm::sys::path::append(FilePath, Exe);
8592 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8593 return FilePath.str();
8594 }
8595
8596 return Exe;
8597}
8598
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008599void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
8600 const InputInfo &Output,
8601 const InputInfoList &Inputs,
8602 const ArgList &Args,
8603 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008604 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008605 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008606
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008607 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8608 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00008609 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
8610 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008611
8612 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008613 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008614 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008615
Zachary Turner10d75b22014-10-22 20:40:43 +00008616 if (!llvm::sys::Process::GetEnv("LIB")) {
8617 // If the VC environment hasn't been configured (perhaps because the user
8618 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00008619 // the environment variable is set however, assume the user knows what
8620 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00008621 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008622 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00008623 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8624 SmallString<128> LibDir(VisualStudioDir);
8625 llvm::sys::path::append(LibDir, "VC", "lib");
8626 switch (MSVC.getArch()) {
8627 case llvm::Triple::x86:
8628 // x86 just puts the libraries directly in lib
8629 break;
8630 case llvm::Triple::x86_64:
8631 llvm::sys::path::append(LibDir, "amd64");
8632 break;
8633 case llvm::Triple::arm:
8634 llvm::sys::path::append(LibDir, "arm");
8635 break;
8636 default:
8637 break;
8638 }
8639 CmdArgs.push_back(
8640 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8641 }
8642
8643 std::string WindowsSdkLibPath;
8644 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8645 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8646 WindowsSdkLibPath.c_str()));
8647 }
8648
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008649 CmdArgs.push_back("-nologo");
8650
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008651 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008652 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008653
Hans Wennborge4c47f22015-03-04 23:16:21 +00008654 bool DLL = Args.hasArg(options::OPT__SLASH_LD,
8655 options::OPT__SLASH_LDd,
8656 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00008657 if (DLL) {
8658 CmdArgs.push_back(Args.MakeArgString("-dll"));
8659
8660 SmallString<128> ImplibName(Output.getFilename());
8661 llvm::sys::path::replace_extension(ImplibName, "lib");
8662 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
Yaron Keren92e1b622015-03-18 10:17:07 +00008663 ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00008664 }
8665
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008666 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00008667 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00008668 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008669 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008670 static const char *CompilerRTComponents[] = {
8671 "asan_dynamic",
8672 "asan_dynamic_runtime_thunk",
8673 };
8674 for (const auto &Component : CompilerRTComponents)
8675 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00008676 // Make sure the dynamic runtime thunk is not optimized out at link time
8677 // to ensure proper SEH handling.
8678 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008679 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008680 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008681 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008682 static const char *CompilerRTComponents[] = {
8683 "asan",
8684 "asan_cxx",
8685 };
8686 for (const auto &Component : CompilerRTComponents)
8687 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008688 }
Hans Wennborg65f17522013-08-27 18:10:21 +00008689 }
8690
Hans Wennborg2e274592013-08-13 23:38:57 +00008691 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00008692
Reid Kleckner337188f2014-09-16 19:22:00 +00008693 // Add filenames, libraries, and other linker inputs.
8694 for (const auto &Input : Inputs) {
8695 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008696 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00008697 continue;
8698 }
8699
8700 const Arg &A = Input.getInputArg();
8701
8702 // Render -l options differently for the MSVC linker.
8703 if (A.getOption().matches(options::OPT_l)) {
8704 StringRef Lib = A.getValue();
8705 const char *LinkLibArg;
8706 if (Lib.endswith(".lib"))
8707 LinkLibArg = Args.MakeArgString(Lib);
8708 else
8709 LinkLibArg = Args.MakeArgString(Lib + ".lib");
8710 CmdArgs.push_back(LinkLibArg);
8711 continue;
8712 }
8713
8714 // Otherwise, this is some other kind of linker input option like -Wl, -z,
8715 // or -L. Render it, even if MSVC doesn't understand it.
8716 A.renderAsInput(Args, CmdArgs);
8717 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008718
Zachary Turner719f58c2014-12-01 23:06:47 +00008719 // We need to special case some linker paths. In the case of lld, we need to
8720 // translate 'lld' into 'lld-link', and in the case of the regular msvc
8721 // linker, we need to use a special search algorithm.
8722 llvm::SmallString<128> linkPath;
8723 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8724 if (Linker.equals_lower("lld"))
8725 Linker = "lld-link";
8726
8727 if (Linker.equals_lower("link")) {
8728 // If we're using the MSVC linker, it's not sufficient to just use link
8729 // from the program PATH, because other environments like GnuWin32 install
8730 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008731 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008732 C.getDriver().getClangProgramPath());
8733 } else {
8734 linkPath = Linker;
8735 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008736 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008737 }
8738
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008739 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00008740 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008741}
Hans Wennborg87cfa712013-09-19 20:32:16 +00008742
8743void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
8744 const InputInfo &Output,
8745 const InputInfoList &Inputs,
8746 const ArgList &Args,
8747 const char *LinkingOutput) const {
8748 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8749}
8750
David Blaikiec11bf802014-09-04 16:04:28 +00008751std::unique_ptr<Command> visualstudio::Compile::GetCommand(
8752 Compilation &C, const JobAction &JA, const InputInfo &Output,
8753 const InputInfoList &Inputs, const ArgList &Args,
8754 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00008755 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00008756 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008757 CmdArgs.push_back("/c"); // Compile only.
8758 CmdArgs.push_back("/W0"); // No warnings.
8759
8760 // The goal is to be able to invoke this tool correctly based on
8761 // any flag accepted by clang-cl.
8762
8763 // These are spelled the same way in clang and cl.exe,.
8764 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8765 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008766
8767 // Optimization level.
8768 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8769 if (A->getOption().getID() == options::OPT_O0) {
8770 CmdArgs.push_back("/Od");
8771 } else {
8772 StringRef OptLevel = A->getValue();
8773 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8774 A->render(Args, CmdArgs);
8775 else if (OptLevel == "3")
8776 CmdArgs.push_back("/Ox");
8777 }
8778 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008779
Nico Weber3f8dafb2015-03-12 19:37:10 +00008780 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00008781 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8782
David Majnemerf6072342014-07-01 22:24:56 +00008783 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8784 /*default=*/false))
8785 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008786 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8787 options::OPT_fno_function_sections))
8788 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8789 ? "/Gy"
8790 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008791 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8792 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008793 CmdArgs.push_back(
8794 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008795 if (Args.hasArg(options::OPT_fsyntax_only))
8796 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008797 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8798 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008799
Nico Weber3f8dafb2015-03-12 19:37:10 +00008800 std::vector<std::string> Includes =
8801 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008802 for (const auto &Include : Includes)
8803 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008804
Hans Wennborg87cfa712013-09-19 20:32:16 +00008805 // Flags that can simply be passed through.
8806 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8807 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008808 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008809
8810 // The order of these flags is relevant, so pick the last one.
8811 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8812 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8813 A->render(Args, CmdArgs);
8814
8815
8816 // Input filename.
8817 assert(Inputs.size() == 1);
8818 const InputInfo &II = Inputs[0];
8819 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8820 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8821 if (II.isFilename())
8822 CmdArgs.push_back(II.getFilename());
8823 else
8824 II.getInputArg().renderAsInput(Args, CmdArgs);
8825
8826 // Output filename.
8827 assert(Output.getType() == types::TY_Object);
8828 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8829 Output.getFilename());
8830 CmdArgs.push_back(Fo);
8831
Hans Wennborg188382e2013-09-20 18:16:35 +00008832 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008833 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8834 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008835 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8836 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008837}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008838
8839
8840/// XCore Tools
8841// We pass assemble and link construction to the xcc tool.
8842
8843void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8844 const InputInfo &Output,
8845 const InputInfoList &Inputs,
8846 const ArgList &Args,
8847 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008848 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008849 ArgStringList CmdArgs;
8850
8851 CmdArgs.push_back("-o");
8852 CmdArgs.push_back(Output.getFilename());
8853
8854 CmdArgs.push_back("-c");
8855
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008856 if (Args.hasArg(options::OPT_v))
8857 CmdArgs.push_back("-v");
8858
Robert Lytton894d25c2014-05-02 09:33:25 +00008859 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8860 if (!A->getOption().matches(options::OPT_g0))
8861 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008862
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008863 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8864 false))
8865 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008866
8867 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8868 options::OPT_Xassembler);
8869
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008870 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008871 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008872
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008873 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008874 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008875}
8876
8877void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8878 const InputInfo &Output,
8879 const InputInfoList &Inputs,
8880 const ArgList &Args,
8881 const char *LinkingOutput) const {
8882 ArgStringList CmdArgs;
8883
8884 if (Output.isFilename()) {
8885 CmdArgs.push_back("-o");
8886 CmdArgs.push_back(Output.getFilename());
8887 } else {
8888 assert(Output.isNothing() && "Invalid output.");
8889 }
8890
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008891 if (Args.hasArg(options::OPT_v))
8892 CmdArgs.push_back("-v");
8893
David Majnemer8de68642014-12-05 08:11:58 +00008894 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008895 CmdArgs.push_back("-fexceptions");
8896
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008897 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8898
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008899 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008900 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008901}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008902
8903void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8904 const InputInfo &Output,
8905 const InputInfoList &Inputs,
8906 const ArgList &Args,
8907 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008908 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008909 const auto &TC =
8910 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8911 ArgStringList CmdArgs;
8912 const char *Exec;
8913
8914 switch (TC.getArch()) {
8915 default: llvm_unreachable("unsupported architecture");
8916 case llvm::Triple::arm:
8917 case llvm::Triple::thumb:
8918 break;
8919 case llvm::Triple::x86:
8920 CmdArgs.push_back("--32");
8921 break;
8922 case llvm::Triple::x86_64:
8923 CmdArgs.push_back("--64");
8924 break;
8925 }
8926
8927 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8928
8929 CmdArgs.push_back("-o");
8930 CmdArgs.push_back(Output.getFilename());
8931
8932 for (const auto &Input : Inputs)
8933 CmdArgs.push_back(Input.getFilename());
8934
8935 const std::string Assembler = TC.GetProgramPath("as");
8936 Exec = Args.MakeArgString(Assembler);
8937
8938 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8939}
8940
8941void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8942 const InputInfo &Output,
8943 const InputInfoList &Inputs,
8944 const ArgList &Args,
8945 const char *LinkingOutput) const {
8946 const auto &TC =
8947 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8948 const llvm::Triple &T = TC.getTriple();
8949 const Driver &D = TC.getDriver();
8950 SmallString<128> EntryPoint;
8951 ArgStringList CmdArgs;
8952 const char *Exec;
8953
8954 // Silence warning for "clang -g foo.o -o foo"
8955 Args.ClaimAllArgs(options::OPT_g_Group);
8956 // and "clang -emit-llvm foo.o -o foo"
8957 Args.ClaimAllArgs(options::OPT_emit_llvm);
8958 // and for "clang -w foo.o -o foo"
8959 Args.ClaimAllArgs(options::OPT_w);
8960 // Other warning options are already handled somewhere else.
8961
8962 if (!D.SysRoot.empty())
8963 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8964
8965 if (Args.hasArg(options::OPT_pie))
8966 CmdArgs.push_back("-pie");
8967 if (Args.hasArg(options::OPT_rdynamic))
8968 CmdArgs.push_back("-export-dynamic");
8969 if (Args.hasArg(options::OPT_s))
8970 CmdArgs.push_back("--strip-all");
8971
8972 CmdArgs.push_back("-m");
8973 switch (TC.getArch()) {
8974 default: llvm_unreachable("unsupported architecture");
8975 case llvm::Triple::arm:
8976 case llvm::Triple::thumb:
8977 // FIXME: this is incorrect for WinCE
8978 CmdArgs.push_back("thumb2pe");
8979 break;
8980 case llvm::Triple::x86:
8981 CmdArgs.push_back("i386pe");
8982 EntryPoint.append("_");
8983 break;
8984 case llvm::Triple::x86_64:
8985 CmdArgs.push_back("i386pep");
8986 break;
8987 }
8988
8989 if (Args.hasArg(options::OPT_shared)) {
8990 switch (T.getArch()) {
8991 default: llvm_unreachable("unsupported architecture");
8992 case llvm::Triple::arm:
8993 case llvm::Triple::thumb:
8994 case llvm::Triple::x86_64:
8995 EntryPoint.append("_DllMainCRTStartup");
8996 break;
8997 case llvm::Triple::x86:
8998 EntryPoint.append("_DllMainCRTStartup@12");
8999 break;
9000 }
9001
9002 CmdArgs.push_back("-shared");
9003 CmdArgs.push_back("-Bdynamic");
9004
9005 CmdArgs.push_back("--enable-auto-image-base");
9006
9007 CmdArgs.push_back("--entry");
9008 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9009 } else {
9010 EntryPoint.append("mainCRTStartup");
9011
9012 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
9013 : "-Bdynamic");
9014
9015 if (!Args.hasArg(options::OPT_nostdlib) &&
9016 !Args.hasArg(options::OPT_nostartfiles)) {
9017 CmdArgs.push_back("--entry");
9018 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9019 }
9020
9021 // FIXME: handle subsystem
9022 }
9023
9024 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00009025 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009026
9027 CmdArgs.push_back("-o");
9028 CmdArgs.push_back(Output.getFilename());
9029
9030 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9031 SmallString<261> ImpLib(Output.getFilename());
9032 llvm::sys::path::replace_extension(ImpLib, ".lib");
9033
9034 CmdArgs.push_back("--out-implib");
9035 CmdArgs.push_back(Args.MakeArgString(ImpLib));
9036 }
9037
9038 if (!Args.hasArg(options::OPT_nostdlib) &&
9039 !Args.hasArg(options::OPT_nostartfiles)) {
9040 const std::string CRTPath(D.SysRoot + "/usr/lib/");
9041 const char *CRTBegin;
9042
9043 CRTBegin =
9044 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
9045 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9046 }
9047
9048 Args.AddAllArgs(CmdArgs, options::OPT_L);
9049
9050 const auto &Paths = TC.getFilePaths();
9051 for (const auto &Path : Paths)
9052 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9053
9054 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9055
9056 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9057 !Args.hasArg(options::OPT_nodefaultlibs)) {
9058 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9059 !Args.hasArg(options::OPT_static);
9060 if (StaticCXX)
9061 CmdArgs.push_back("-Bstatic");
9062 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9063 if (StaticCXX)
9064 CmdArgs.push_back("-Bdynamic");
9065 }
9066
9067 if (!Args.hasArg(options::OPT_nostdlib)) {
9068 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9069 // TODO handle /MT[d] /MD[d]
9070 CmdArgs.push_back("-lmsvcrt");
9071 AddRunTimeLibs(TC, D, CmdArgs, Args);
9072 }
9073 }
9074
9075 const std::string Linker = TC.GetProgramPath("ld");
9076 Exec = Args.MakeArgString(Linker);
9077
9078 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9079}