blob: 454f1d85857b9f8cabd95021d67b95b01cb1b818 [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)) {
682 StringRef 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);
John Brawn94fd9632015-05-21 12:19:49 +0000692 StringRef Arch = arm::getARMArch(Args, Triple);
693 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();
Kevin Qin110db6f2014-07-18 07:03:22 +0000853 CPU = Mcpu.split("+").first;
Tim Northovera2ee4332014-03-29 15:09:45 +0000854 }
855
Kevin Qin110db6f2014-07-18 07:03:22 +0000856 // Handle CPU name is 'native'.
857 if (CPU == "native")
858 return llvm::sys::getHostCPUName();
859 else if (CPU.size())
860 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000861
James Molloy9b1586b2014-04-17 12:51:17 +0000862 // Make sure we pick "cyclone" if -arch is used.
863 // FIXME: Should this be picked by checking the target triple instead?
864 if (Args.getLastArg(options::OPT_arch))
865 return "cyclone";
866
867 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000868}
869
Tim Northover573cbee2014-05-24 12:52:07 +0000870void Clang::AddAArch64TargetArgs(const ArgList &Args,
871 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000872 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
873 llvm::Triple Triple(TripleStr);
874
875 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
876 Args.hasArg(options::OPT_mkernel) ||
877 Args.hasArg(options::OPT_fapple_kext))
878 CmdArgs.push_back("-disable-red-zone");
879
880 if (!Args.hasFlag(options::OPT_mimplicit_float,
881 options::OPT_mno_implicit_float, true))
882 CmdArgs.push_back("-no-implicit-float");
883
Craig Topper92fc2df2014-05-17 16:56:41 +0000884 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000885 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
886 ABIName = A->getValue();
887 else if (Triple.isOSDarwin())
888 ABIName = "darwinpcs";
889 else
890 ABIName = "aapcs";
891
892 CmdArgs.push_back("-target-abi");
893 CmdArgs.push_back(ABIName);
894
Bob Wilson0874e532014-07-29 00:23:18 +0000895 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
896 options::OPT_munaligned_access)) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000897 CmdArgs.push_back("-backend-option");
Bob Wilson0874e532014-07-29 00:23:18 +0000898 if (A->getOption().matches(options::OPT_mno_unaligned_access))
899 CmdArgs.push_back("-aarch64-strict-align");
900 else
901 CmdArgs.push_back("-aarch64-no-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000902 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000903
Bradley Smith9ff64332014-10-13 10:16:06 +0000904 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
905 options::OPT_mno_fix_cortex_a53_835769)) {
906 CmdArgs.push_back("-backend-option");
907 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
908 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
909 else
910 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Bradley Smith04ee8aa2014-10-16 16:35:14 +0000911 } else if (Triple.getEnvironment() == llvm::Triple::Android) {
912 // Enabled A53 errata (835769) workaround by default on android
913 CmdArgs.push_back("-backend-option");
914 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +0000915 }
916
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000917 // Forward the -mglobal-merge option for explicit control over the pass.
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000918 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
919 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000920 CmdArgs.push_back("-backend-option");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000921 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000922 CmdArgs.push_back("-aarch64-global-merge=false");
923 else
924 CmdArgs.push_back("-aarch64-global-merge=true");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000925 }
Renato Golinb625f482015-01-25 23:17:48 +0000926
927 if (Args.hasArg(options::OPT_ffixed_x18)) {
928 CmdArgs.push_back("-backend-option");
929 CmdArgs.push_back("-aarch64-reserve-x18");
930 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000931}
932
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000933// Get CPU and ABI names. They are not independent
934// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000935void mips::getMipsCPUAndABI(const ArgList &Args,
936 const llvm::Triple &Triple,
937 StringRef &CPUName,
938 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000939 const char *DefMips32CPU = "mips32r2";
940 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000941
Daniel Sanders2bf13662014-07-10 14:40:57 +0000942 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
943 // default for mips64(el)?-img-linux-gnu.
944 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
945 Triple.getEnvironment() == llvm::Triple::GNU) {
946 DefMips32CPU = "mips32r6";
947 DefMips64CPU = "mips64r6";
948 }
949
Brad Smithba26f582015-01-06 02:53:17 +0000950 // MIPS3 is the default for mips64*-unknown-openbsd.
951 if (Triple.getOS() == llvm::Triple::OpenBSD)
952 DefMips64CPU = "mips3";
953
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000954 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000955 options::OPT_mcpu_EQ))
956 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000957
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000958 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000959 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000960 // Convert a GNU style Mips ABI name to the name
961 // accepted by LLVM Mips backend.
962 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
963 .Case("32", "o32")
964 .Case("64", "n64")
965 .Default(ABIName);
966 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000967
968 // Setup default CPU and ABI names.
969 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000970 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000971 default:
972 llvm_unreachable("Unexpected triple arch name");
973 case llvm::Triple::mips:
974 case llvm::Triple::mipsel:
975 CPUName = DefMips32CPU;
976 break;
977 case llvm::Triple::mips64:
978 case llvm::Triple::mips64el:
979 CPUName = DefMips64CPU;
980 break;
981 }
982 }
983
Simon Atanasyana42a84e2014-07-02 13:20:36 +0000984 if (ABIName.empty()) {
985 // Deduce ABI name from the target triple.
986 if (Triple.getArch() == llvm::Triple::mips ||
987 Triple.getArch() == llvm::Triple::mipsel)
988 ABIName = "o32";
989 else
990 ABIName = "n64";
991 }
992
993 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000994 // Deduce CPU name from ABI name.
995 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +0000996 .Cases("o32", "eabi", DefMips32CPU)
997 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000998 .Default("");
999 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001000
1001 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001002}
1003
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001004// Convert ABI name to the GNU tools acceptable variant.
1005static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1006 return llvm::StringSwitch<llvm::StringRef>(ABI)
1007 .Case("o32", "32")
1008 .Case("n64", "64")
1009 .Default(ABI);
1010}
1011
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001012// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1013// and -mfloat-abi=.
1014static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001015 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001016 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001017 options::OPT_mhard_float,
1018 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001019 if (A->getOption().matches(options::OPT_msoft_float))
1020 FloatABI = "soft";
1021 else if (A->getOption().matches(options::OPT_mhard_float))
1022 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001023 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001024 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001025 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001026 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001027 FloatABI = "hard";
1028 }
1029 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001030 }
1031
1032 // If unspecified, choose the default based on the platform.
1033 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001034 // Assume "hard", because it's a default value used by gcc.
1035 // When we start to recognize specific target MIPS processors,
1036 // we will be able to select the default more correctly.
1037 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001038 }
1039
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001040 return FloatABI;
1041}
1042
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001043static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001044 std::vector<const char *> &Features,
1045 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001046 StringRef FeatureName) {
1047 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001048 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001049 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001050 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001051 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001052 }
1053}
1054
Daniel Sanders379d44b2014-07-16 11:52:23 +00001055static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1056 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001057 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001058 StringRef CPUName;
1059 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001060 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001061 ABIName = getGnuCompatibleMipsABIName(ABIName);
1062
Daniel Sandersfeb61302014-08-08 15:47:17 +00001063 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1064 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001065
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001066 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001067 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001068 // FIXME: Note, this is a hack. We need to pass the selected float
1069 // mode to the MipsTargetInfoBase to define appropriate macros there.
1070 // Now it is the only method.
1071 Features.push_back("+soft-float");
1072 }
1073
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001074 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001075 StringRef Val = StringRef(A->getValue());
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00001076 if (Val == "2008") {
1077 if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1078 Features.push_back("+nan2008");
1079 else {
1080 Features.push_back("-nan2008");
1081 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1082 }
1083 } else if (Val == "legacy") {
1084 if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1085 Features.push_back("-nan2008");
1086 else {
1087 Features.push_back("+nan2008");
1088 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1089 }
1090 } else
Matheus Almeida602bff32014-05-07 16:16:07 +00001091 D.Diag(diag::err_drv_unsupported_option_argument)
1092 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001093 }
1094
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001095 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1096 options::OPT_mdouble_float, "single-float");
1097 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1098 "mips16");
1099 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1100 options::OPT_mno_micromips, "micromips");
1101 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1102 "dsp");
1103 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1104 "dspr2");
1105 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1106 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001107
1108 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1109 // pass -mfpxx
1110 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1111 options::OPT_mfp64)) {
1112 if (A->getOption().matches(options::OPT_mfp32))
1113 Features.push_back(Args.MakeArgString("-fp64"));
1114 else if (A->getOption().matches(options::OPT_mfpxx)) {
1115 Features.push_back(Args.MakeArgString("+fpxx"));
1116 Features.push_back(Args.MakeArgString("+nooddspreg"));
1117 } else
1118 Features.push_back(Args.MakeArgString("+fp64"));
1119 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001120 Features.push_back(Args.MakeArgString("+fpxx"));
1121 Features.push_back(Args.MakeArgString("+nooddspreg"));
1122 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001123
Daniel Sanders28e5d392014-07-10 10:39:51 +00001124 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1125 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001126}
1127
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001128void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001129 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001130 const Driver &D = getToolChain().getDriver();
1131 StringRef CPUName;
1132 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001133 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001134 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001135
1136 CmdArgs.push_back("-target-abi");
1137 CmdArgs.push_back(ABIName.data());
1138
1139 StringRef FloatABI = getMipsFloatABI(D, Args);
1140
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001141 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001142 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001143 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001144 CmdArgs.push_back("-mfloat-abi");
1145 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001146 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001147 else {
1148 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001149 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001150 CmdArgs.push_back("-mfloat-abi");
1151 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001152 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001153
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001154 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1155 if (A->getOption().matches(options::OPT_mxgot)) {
1156 CmdArgs.push_back("-mllvm");
1157 CmdArgs.push_back("-mxgot");
1158 }
1159 }
1160
Simon Atanasyanc580b322013-05-11 06:33:44 +00001161 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1162 options::OPT_mno_ldc1_sdc1)) {
1163 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1164 CmdArgs.push_back("-mllvm");
1165 CmdArgs.push_back("-mno-ldc1-sdc1");
1166 }
1167 }
1168
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001169 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1170 options::OPT_mno_check_zero_division)) {
1171 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1172 CmdArgs.push_back("-mllvm");
1173 CmdArgs.push_back("-mno-check-zero-division");
1174 }
1175 }
1176
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001177 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001178 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001179 CmdArgs.push_back("-mllvm");
1180 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1181 A->claim();
1182 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001183}
1184
Hal Finkel8eb59282012-06-11 22:35:19 +00001185/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1186static std::string getPPCTargetCPU(const ArgList &Args) {
1187 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001188 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001189
1190 if (CPUName == "native") {
1191 std::string CPU = llvm::sys::getHostCPUName();
1192 if (!CPU.empty() && CPU != "generic")
1193 return CPU;
1194 else
1195 return "";
1196 }
1197
1198 return llvm::StringSwitch<const char *>(CPUName)
1199 .Case("common", "generic")
1200 .Case("440", "440")
1201 .Case("440fp", "440")
1202 .Case("450", "450")
1203 .Case("601", "601")
1204 .Case("602", "602")
1205 .Case("603", "603")
1206 .Case("603e", "603e")
1207 .Case("603ev", "603ev")
1208 .Case("604", "604")
1209 .Case("604e", "604e")
1210 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001211 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001212 .Case("G3", "g3")
1213 .Case("7400", "7400")
1214 .Case("G4", "g4")
1215 .Case("7450", "7450")
1216 .Case("G4+", "g4+")
1217 .Case("750", "750")
1218 .Case("970", "970")
1219 .Case("G5", "g5")
1220 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001221 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001222 .Case("e500mc", "e500mc")
1223 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001224 .Case("power3", "pwr3")
1225 .Case("power4", "pwr4")
1226 .Case("power5", "pwr5")
1227 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001228 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001229 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001230 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001231 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001232 .Case("pwr3", "pwr3")
1233 .Case("pwr4", "pwr4")
1234 .Case("pwr5", "pwr5")
1235 .Case("pwr5x", "pwr5x")
1236 .Case("pwr6", "pwr6")
1237 .Case("pwr6x", "pwr6x")
1238 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001239 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001240 .Case("powerpc", "ppc")
1241 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001242 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001243 .Default("");
1244 }
1245
1246 return "";
1247}
1248
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001249static void getPPCTargetFeatures(const ArgList &Args,
1250 std::vector<const char *> &Features) {
Sean Silva14facf32015-06-09 01:57:17 +00001251 for (const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1252 StringRef Name = A->getOption().getName();
1253 A->claim();
Eric Christopher643bb6a2013-10-16 20:40:08 +00001254
1255 // Skip over "-m".
1256 assert(Name.startswith("m") && "Invalid feature name.");
1257 Name = Name.substr(1);
1258
1259 bool IsNegative = Name.startswith("no-");
1260 if (IsNegative)
1261 Name = Name.substr(3);
1262
1263 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1264 // pass the correct option to the backend while calling the frontend
1265 // option the same.
1266 // TODO: Change the LLVM backend option maybe?
1267 if (Name == "mfcrf")
1268 Name = "mfocrf";
1269
1270 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1271 }
1272
1273 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001274 AddTargetFeature(Args, Features, options::OPT_faltivec,
1275 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001276}
1277
Ulrich Weigand8afad612014-07-28 13:17:52 +00001278void Clang::AddPPCTargetArgs(const ArgList &Args,
1279 ArgStringList &CmdArgs) const {
1280 // Select the ABI to use.
1281 const char *ABIName = nullptr;
1282 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1283 ABIName = A->getValue();
1284 } else if (getToolChain().getTriple().isOSLinux())
1285 switch(getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001286 case llvm::Triple::ppc64: {
1287 // When targeting a processor that supports QPX, or if QPX is
1288 // specifically enabled, default to using the ABI that supports QPX (so
1289 // long as it is not specifically disabled).
1290 bool HasQPX = false;
1291 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1292 HasQPX = A->getValue() == StringRef("a2q");
1293 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1294 if (HasQPX) {
1295 ABIName = "elfv1-qpx";
1296 break;
1297 }
1298
Ulrich Weigand8afad612014-07-28 13:17:52 +00001299 ABIName = "elfv1";
1300 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001301 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001302 case llvm::Triple::ppc64le:
1303 ABIName = "elfv2";
1304 break;
1305 default:
1306 break;
1307 }
1308
1309 if (ABIName) {
1310 CmdArgs.push_back("-target-abi");
1311 CmdArgs.push_back(ABIName);
1312 }
1313}
1314
1315bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1316 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1317 return A && (A->getValue() == StringRef(Value));
1318}
1319
Tom Stellard6674c702013-04-01 20:56:53 +00001320/// Get the (LLVM) name of the R600 gpu we are targeting.
1321static std::string getR600TargetGPU(const ArgList &Args) {
1322 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001323 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001324 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001325 .Cases("rv630", "rv635", "r600")
1326 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001327 .Case("rv740", "rv770")
1328 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001329 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001330 .Case("hemlock", "cypress")
1331 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001332 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001333 }
1334 return "";
1335}
1336
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001337static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001338 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001339 bool SoftFloatABI = true;
1340 if (Arg *A =
1341 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1342 if (A->getOption().matches(options::OPT_mhard_float))
1343 SoftFloatABI = false;
1344 }
1345 if (SoftFloatABI)
1346 Features.push_back("+soft-float");
1347}
1348
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001349void Clang::AddSparcTargetArgs(const ArgList &Args,
1350 ArgStringList &CmdArgs) const {
1351 const Driver &D = getToolChain().getDriver();
1352
Brad Smith10cd0f42014-07-11 20:12:08 +00001353 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001354 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001355 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1356 options::OPT_mhard_float)) {
1357 if (A->getOption().matches(options::OPT_msoft_float))
1358 FloatABI = "soft";
1359 else if (A->getOption().matches(options::OPT_mhard_float))
1360 FloatABI = "hard";
1361 }
1362
1363 // If unspecified, choose the default based on the platform.
1364 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001365 // Assume "soft", but warn the user we are guessing.
1366 FloatABI = "soft";
1367 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001368 }
1369
1370 if (FloatABI == "soft") {
1371 // Floating point operations and argument passing are soft.
1372 //
1373 // FIXME: This changes CPP defines, we need -target-soft-float.
1374 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001375 } else {
1376 assert(FloatABI == "hard" && "Invalid float abi!");
1377 CmdArgs.push_back("-mhard-float");
1378 }
1379}
1380
Richard Sandiford4652d892013-07-19 16:51:51 +00001381static const char *getSystemZTargetCPU(const ArgList &Args) {
1382 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1383 return A->getValue();
1384 return "z10";
1385}
1386
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001387static void getSystemZTargetFeatures(const ArgList &Args,
1388 std::vector<const char *> &Features) {
1389 // -m(no-)htm overrides use of the transactional-execution facility.
1390 if (Arg *A = Args.getLastArg(options::OPT_mhtm,
1391 options::OPT_mno_htm)) {
1392 if (A->getOption().matches(options::OPT_mhtm))
1393 Features.push_back("+transactional-execution");
1394 else
1395 Features.push_back("-transactional-execution");
1396 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001397 // -m(no-)vx overrides use of the vector facility.
1398 if (Arg *A = Args.getLastArg(options::OPT_mvx,
1399 options::OPT_mno_vx)) {
1400 if (A->getOption().matches(options::OPT_mvx))
1401 Features.push_back("+vector");
1402 else
1403 Features.push_back("-vector");
1404 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001405}
1406
Chandler Carruth953fb082013-01-13 11:46:33 +00001407static const char *getX86TargetCPU(const ArgList &Args,
1408 const llvm::Triple &Triple) {
1409 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001410 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001411 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001412 return "core-avx2";
1413
Chandler Carruth953fb082013-01-13 11:46:33 +00001414 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001415 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001416
1417 // FIXME: Reject attempts to use -march=native unless the target matches
1418 // the host.
1419 //
1420 // FIXME: We should also incorporate the detected target features for use
1421 // with -native.
1422 std::string CPU = llvm::sys::getHostCPUName();
1423 if (!CPU.empty() && CPU != "generic")
1424 return Args.MakeArgString(CPU);
1425 }
1426
1427 // Select the default CPU if none was given (or detection failed).
1428
1429 if (Triple.getArch() != llvm::Triple::x86_64 &&
1430 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001431 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001432
1433 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1434
1435 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001436 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001437 if (Triple.getArchName() == "x86_64h")
1438 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001439 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001440 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001441
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001442 // Set up default CPU name for PS4 compilers.
1443 if (Triple.isPS4CPU())
1444 return "btver2";
1445
Alexey Bataev286d1b92014-01-31 04:07:13 +00001446 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001447 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001448 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001449
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001450 // Everything else goes to x86-64 in 64-bit mode.
1451 if (Is64Bit)
1452 return "x86-64";
1453
1454 switch (Triple.getOS()) {
1455 case llvm::Triple::FreeBSD:
1456 case llvm::Triple::NetBSD:
1457 case llvm::Triple::OpenBSD:
1458 return "i486";
1459 case llvm::Triple::Haiku:
1460 return "i586";
1461 case llvm::Triple::Bitrig:
1462 return "i686";
1463 default:
1464 // Fallback to p4.
1465 return "pentium4";
1466 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001467}
1468
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001469static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1470 switch(T.getArch()) {
1471 default:
1472 return "";
1473
Amara Emerson703da2e2013-10-31 09:32:33 +00001474 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001475 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001476 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001477
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001478 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001479 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001480 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001481 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001482 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001483
1484 case llvm::Triple::mips:
1485 case llvm::Triple::mipsel:
1486 case llvm::Triple::mips64:
1487 case llvm::Triple::mips64el: {
1488 StringRef CPUName;
1489 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001490 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001491 return CPUName;
1492 }
1493
1494 case llvm::Triple::ppc:
1495 case llvm::Triple::ppc64:
1496 case llvm::Triple::ppc64le: {
1497 std::string TargetCPUName = getPPCTargetCPU(Args);
1498 // LLVM may default to generating code for the native CPU,
1499 // but, like gcc, we default to a more generic option for
1500 // each architecture. (except on Darwin)
1501 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1502 if (T.getArch() == llvm::Triple::ppc64)
1503 TargetCPUName = "ppc64";
1504 else if (T.getArch() == llvm::Triple::ppc64le)
1505 TargetCPUName = "ppc64le";
1506 else
1507 TargetCPUName = "ppc";
1508 }
1509 return TargetCPUName;
1510 }
1511
1512 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001513 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001514 case llvm::Triple::sparcv9:
1515 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001516 return A->getValue();
1517 return "";
1518
1519 case llvm::Triple::x86:
1520 case llvm::Triple::x86_64:
1521 return getX86TargetCPU(Args, T);
1522
1523 case llvm::Triple::hexagon:
1524 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1525
1526 case llvm::Triple::systemz:
1527 return getSystemZTargetCPU(Args);
1528
1529 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001530 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001531 return getR600TargetGPU(Args);
1532 }
1533}
1534
Alp Tokerce365ca2013-12-02 12:43:03 +00001535static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1536 ArgStringList &CmdArgs) {
1537 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1538 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1539 // forward.
1540 CmdArgs.push_back("-plugin");
Rafael Espindola3e34e652015-02-03 16:33:53 +00001541 std::string Plugin = ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001542 CmdArgs.push_back(Args.MakeArgString(Plugin));
1543
1544 // Try to pass driver level flags relevant to LTO code generation down to
1545 // the plugin.
1546
1547 // Handle flags for selecting CPU variants.
1548 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1549 if (!CPU.empty())
1550 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1551}
1552
Eric Christopherc54920a2015-03-23 19:26:05 +00001553static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001554 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001555 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001556 // If -march=native, autodetect the feature list.
1557 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1558 if (StringRef(A->getValue()) == "native") {
1559 llvm::StringMap<bool> HostFeatures;
1560 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1561 for (auto &F : HostFeatures)
1562 Features.push_back(Args.MakeArgString((F.second ? "+" : "-") +
1563 F.first()));
1564 }
1565 }
1566
Jim Grosbach82eee262013-11-16 00:53:35 +00001567 if (Triple.getArchName() == "x86_64h") {
1568 // x86_64h implies quite a few of the more modern subtarget features
1569 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1570 Features.push_back("-rdrnd");
1571 Features.push_back("-aes");
1572 Features.push_back("-pclmul");
1573 Features.push_back("-rtm");
1574 Features.push_back("-hle");
1575 Features.push_back("-fsgsbase");
1576 }
1577
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001578 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00001579 // Add features to be compatible with gcc for Android.
Alexey Bataev286d1b92014-01-31 04:07:13 +00001580 if (Triple.getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001581 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001582 Features.push_back("+sse4.2");
1583 Features.push_back("+popcnt");
1584 } else
1585 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001586 }
1587
Eric Christopherc54920a2015-03-23 19:26:05 +00001588 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001589 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1590 StringRef Arch = A->getValue();
1591 bool ArchUsed = false;
1592 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001593 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001594 if (Arch == "AVX" || Arch == "AVX2") {
1595 ArchUsed = true;
1596 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1597 }
1598 }
1599 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001600 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001601 if (Arch == "IA32") {
1602 ArchUsed = true;
1603 } else if (Arch == "SSE" || Arch == "SSE2") {
1604 ArchUsed = true;
1605 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1606 }
1607 }
1608 if (!ArchUsed)
1609 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1610 }
1611
Jim Grosbach82eee262013-11-16 00:53:35 +00001612 // Now add any that the user explicitly requested on the command line,
1613 // which may override the defaults.
Sean Silva14facf32015-06-09 01:57:17 +00001614 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1615 StringRef Name = A->getOption().getName();
1616 A->claim();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001617
1618 // Skip over "-m".
1619 assert(Name.startswith("m") && "Invalid feature name.");
1620 Name = Name.substr(1);
1621
1622 bool IsNegative = Name.startswith("no-");
1623 if (IsNegative)
1624 Name = Name.substr(3);
1625
1626 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1627 }
1628}
1629
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001630void Clang::AddX86TargetArgs(const ArgList &Args,
1631 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001632 if (!Args.hasFlag(options::OPT_mred_zone,
1633 options::OPT_mno_red_zone,
1634 true) ||
1635 Args.hasArg(options::OPT_mkernel) ||
1636 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001637 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001638
Bob Wilson2616e2e2013-02-10 16:01:41 +00001639 // Default to avoid implicit floating-point for kernel/kext code, but allow
1640 // that to be overridden with -mno-soft-float.
1641 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1642 Args.hasArg(options::OPT_fapple_kext));
1643 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1644 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001645 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001646 options::OPT_mno_implicit_float)) {
1647 const Option &O = A->getOption();
1648 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1649 O.matches(options::OPT_msoft_float));
1650 }
1651 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001652 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001653
1654 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1655 StringRef Value = A->getValue();
1656 if (Value == "intel" || Value == "att") {
1657 CmdArgs.push_back("-mllvm");
1658 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1659 } else {
1660 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1661 << A->getOption().getName() << Value;
1662 }
1663 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001664}
1665
Tony Linthicum76329bf2011-12-12 21:14:55 +00001666void Clang::AddHexagonTargetArgs(const ArgList &Args,
1667 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00001668 CmdArgs.push_back("-mqdsp6-compat");
1669 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001670
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001671 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
1672 std::string SmallDataThreshold="-hexagon-small-data-threshold=";
1673 SmallDataThreshold += v;
Tony Linthicum76329bf2011-12-12 21:14:55 +00001674 CmdArgs.push_back ("-mllvm");
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001675 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001676 }
1677
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001678 if (!Args.hasArg(options::OPT_fno_short_enums))
1679 CmdArgs.push_back("-fshort-enums");
1680 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1681 CmdArgs.push_back ("-mllvm");
1682 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1683 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001684 CmdArgs.push_back ("-mllvm");
1685 CmdArgs.push_back ("-machine-sink-split=0");
1686}
1687
Kevin Qin110db6f2014-07-18 07:03:22 +00001688// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001689static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001690 std::vector<const char *> &Features) {
1691 SmallVector<StringRef, 8> Split;
1692 text.split(Split, StringRef("+"), -1, false);
1693
1694 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1695 const char *result = llvm::StringSwitch<const char *>(Split[I])
1696 .Case("fp", "+fp-armv8")
1697 .Case("simd", "+neon")
1698 .Case("crc", "+crc")
1699 .Case("crypto", "+crypto")
1700 .Case("nofp", "-fp-armv8")
1701 .Case("nosimd", "-neon")
1702 .Case("nocrc", "-crc")
1703 .Case("nocrypto", "-crypto")
1704 .Default(nullptr);
1705 if (result)
1706 Features.push_back(result);
1707 else if (Split[I] == "neon" || Split[I] == "noneon")
1708 D.Diag(diag::err_drv_no_neon_modifier);
1709 else
1710 return false;
1711 }
1712 return true;
1713}
1714
1715// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1716// decode CPU and feature.
1717static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1718 std::vector<const char *> &Features) {
1719 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1720 CPU = Split.first;
Renato Golin84545d72015-02-04 13:31:56 +00001721 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001722 Features.push_back("+neon");
1723 Features.push_back("+crc");
1724 Features.push_back("+crypto");
1725 } else if (CPU == "generic") {
1726 Features.push_back("+neon");
1727 } else {
1728 return false;
1729 }
1730
1731 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1732 return false;
1733
1734 return true;
1735}
1736
1737static bool
1738getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1739 const ArgList &Args,
1740 std::vector<const char *> &Features) {
1741 std::pair<StringRef, StringRef> Split = March.split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001742
1743 if (Split.first == "armv8-a" ||
1744 Split.first == "armv8a") {
1745 // ok, no additional features.
1746 } else if (
1747 Split.first == "armv8.1-a" ||
1748 Split.first == "armv8.1a" ) {
1749 Features.push_back("+v8.1a");
1750 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00001751 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001752 }
Kevin Qin110db6f2014-07-18 07:03:22 +00001753
1754 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1755 return false;
1756
1757 return true;
1758}
1759
1760static bool
1761getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1762 const ArgList &Args,
1763 std::vector<const char *> &Features) {
1764 StringRef CPU;
1765 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1766 return false;
1767
1768 return true;
1769}
1770
1771static bool
1772getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1773 const ArgList &Args,
1774 std::vector<const char *> &Features) {
1775 // Handle CPU name is 'native'.
1776 if (Mtune == "native")
1777 Mtune = llvm::sys::getHostCPUName();
1778 if (Mtune == "cyclone") {
1779 Features.push_back("+zcm");
1780 Features.push_back("+zcz");
1781 }
1782 return true;
1783}
1784
1785static bool
1786getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1787 const ArgList &Args,
1788 std::vector<const char *> &Features) {
1789 StringRef CPU;
1790 std::vector<const char *> DecodedFeature;
1791 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1792 return false;
1793
1794 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1795}
1796
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001797static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1798 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001799 Arg *A;
1800 bool success = true;
1801 // Enable NEON by default.
1802 Features.push_back("+neon");
1803 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1804 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1805 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1806 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001807 else if (Args.hasArg(options::OPT_arch))
1808 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1809 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001810
1811 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1812 success =
1813 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1814 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1815 success =
1816 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001817 else if (Args.hasArg(options::OPT_arch))
1818 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1819 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001820
1821 if (!success)
1822 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001823
1824 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1825 Features.push_back("-fp-armv8");
1826 Features.push_back("-crypto");
1827 Features.push_back("-neon");
1828 }
Bradley Smith418c5932014-05-02 15:17:51 +00001829
1830 // En/disable crc
1831 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1832 options::OPT_mnocrc)) {
1833 if (A->getOption().matches(options::OPT_mcrc))
1834 Features.push_back("+crc");
1835 else
1836 Features.push_back("-crc");
1837 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001838}
1839
1840static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001841 const ArgList &Args, ArgStringList &CmdArgs,
1842 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001843 std::vector<const char *> Features;
1844 switch (Triple.getArch()) {
1845 default:
1846 break;
1847 case llvm::Triple::mips:
1848 case llvm::Triple::mipsel:
1849 case llvm::Triple::mips64:
1850 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001851 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001852 break;
1853
1854 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001855 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001856 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001857 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001858 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001859 break;
1860
1861 case llvm::Triple::ppc:
1862 case llvm::Triple::ppc64:
1863 case llvm::Triple::ppc64le:
1864 getPPCTargetFeatures(Args, Features);
1865 break;
1866 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001867 case llvm::Triple::sparcel:
Brad Smithf436e9e2014-08-19 21:50:15 +00001868 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001869 getSparcTargetFeatures(Args, Features);
1870 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001871 case llvm::Triple::systemz:
1872 getSystemZTargetFeatures(Args, Features);
1873 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001874 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001875 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001876 getAArch64TargetFeatures(D, Args, Features);
1877 break;
1878 case llvm::Triple::x86:
1879 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001880 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001881 break;
1882 }
Rafael Espindola43964802013-08-21 17:34:32 +00001883
1884 // Find the last of each feature.
1885 llvm::StringMap<unsigned> LastOpt;
1886 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1887 const char *Name = Features[I];
1888 assert(Name[0] == '-' || Name[0] == '+');
1889 LastOpt[Name + 1] = I;
1890 }
1891
1892 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1893 // If this feature was overridden, ignore it.
1894 const char *Name = Features[I];
1895 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1896 assert(LastI != LastOpt.end());
1897 unsigned Last = LastI->second;
1898 if (Last != I)
1899 continue;
1900
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001901 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001902 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001903 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001904}
1905
David Majnemerae394812014-12-09 00:12:30 +00001906static bool
1907shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1908 const llvm::Triple &Triple) {
1909 // We use the zero-cost exception tables for Objective-C if the non-fragile
1910 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1911 // later.
1912 if (runtime.isNonFragile())
1913 return true;
1914
1915 if (!Triple.isMacOSX())
1916 return false;
1917
1918 return (!Triple.isMacOSXVersionLT(10,5) &&
1919 (Triple.getArch() == llvm::Triple::x86_64 ||
1920 Triple.getArch() == llvm::Triple::arm));
1921}
1922
Nico Webere8e53112014-05-11 01:04:02 +00001923// exceptionSettings() exists to share the logic between -cc1 and linker
1924// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00001925static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001926 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001927 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001928 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00001929 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001930
David Majnemer8de68642014-12-05 08:11:58 +00001931 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001932}
1933
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001934/// Adds exception related arguments to the driver command arguments. There's a
1935/// master flag, -fexceptions and also language specific flags to enable/disable
1936/// C++ and Objective-C exceptions. This makes it possible to for example
1937/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00001938static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001939 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001940 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001941 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001942 const Driver &D = TC.getDriver();
1943 const llvm::Triple &Triple = TC.getTriple();
1944
Chad Rosier4fab82c2012-03-26 22:04:46 +00001945 if (KernelOrKext) {
1946 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1947 // arguments now to avoid warnings about unused arguments.
1948 Args.ClaimAllArgs(options::OPT_fexceptions);
1949 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1950 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1951 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1952 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1953 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001954 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001955 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001956
David Majnemer8de68642014-12-05 08:11:58 +00001957 // Gather the exception settings from the command line arguments.
1958 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001959
David Majnemerae394812014-12-09 00:12:30 +00001960 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1961 // is not necessarily sensible, but follows GCC.
1962 if (types::isObjC(InputType) &&
1963 Args.hasFlag(options::OPT_fobjc_exceptions,
1964 options::OPT_fno_objc_exceptions,
1965 true)) {
1966 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001967
David Majnemerae394812014-12-09 00:12:30 +00001968 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001969 }
1970
1971 if (types::isCXX(InputType)) {
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001972 bool CXXExceptionsEnabled =
1973 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001974 Arg *ExceptionArg = Args.getLastArg(
1975 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
1976 options::OPT_fexceptions, options::OPT_fno_exceptions);
1977 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00001978 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001979 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
1980 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001981
1982 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001983 if (Triple.isPS4CPU()) {
1984 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
1985 assert(ExceptionArg &&
1986 "On the PS4 exceptions should only be enabled if passing "
1987 "an argument");
1988 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
1989 const Arg *RTTIArg = TC.getRTTIArg();
1990 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
1991 D.Diag(diag::err_drv_argument_not_allowed_with)
1992 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
1993 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
1994 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
1995 } else
1996 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
1997
Anders Carlssone96ab552011-02-28 02:27:16 +00001998 CmdArgs.push_back("-fcxx-exceptions");
1999
David Majnemer8de68642014-12-05 08:11:58 +00002000 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002001 }
2002 }
2003
David Majnemer8de68642014-12-05 08:11:58 +00002004 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002005 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002006}
2007
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002008static bool ShouldDisableAutolink(const ArgList &Args,
2009 const ToolChain &TC) {
2010 bool Default = true;
2011 if (TC.getTriple().isOSDarwin()) {
2012 // The native darwin assembler doesn't support the linker_option directives,
2013 // so we disable them if we think the .s file will be passed to it.
2014 Default = TC.useIntegratedAs();
2015 }
2016 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2017 Default);
2018}
2019
Ted Kremenek62093662013-03-12 17:02:12 +00002020static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2021 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002022 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
2023 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002024 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002025 return !UseDwarfDirectory;
2026}
2027
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002028/// \brief Check whether the given input tree contains any compilation actions.
2029static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002030 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002031 return true;
2032
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002033 for (const auto &Act : *A)
2034 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002035 return true;
2036
2037 return false;
2038}
2039
2040/// \brief Check if -relax-all should be passed to the internal assembler.
2041/// This is done by default when compiling non-assembler source with -O0.
2042static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2043 bool RelaxDefault = true;
2044
2045 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2046 RelaxDefault = A->getOption().matches(options::OPT_O0);
2047
2048 if (RelaxDefault) {
2049 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002050 for (const auto &Act : C.getActions()) {
2051 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002052 RelaxDefault = true;
2053 break;
2054 }
2055 }
2056 }
2057
2058 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2059 RelaxDefault);
2060}
2061
David Blaikie9260ed62013-07-25 21:19:01 +00002062static void CollectArgsForIntegratedAssembler(Compilation &C,
2063 const ArgList &Args,
2064 ArgStringList &CmdArgs,
2065 const Driver &D) {
2066 if (UseRelaxAll(C, Args))
2067 CmdArgs.push_back("-mrelax-all");
2068
David Peixottodfb66142013-11-14 22:52:58 +00002069 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002070 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002071 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2072 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2073 // arg after parsing the '-I' arg.
2074 bool TakeNextArg = false;
2075
David Blaikie9260ed62013-07-25 21:19:01 +00002076 // When using an integrated assembler, translate -Wa, and -Xassembler
2077 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002078 bool CompressDebugSections = false;
Sean Silva14facf32015-06-09 01:57:17 +00002079 for (const Arg *A :
2080 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
David Blaikie9260ed62013-07-25 21:19:01 +00002081 A->claim();
2082
2083 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2084 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002085 if (TakeNextArg) {
2086 CmdArgs.push_back(Value.data());
2087 TakeNextArg = false;
2088 continue;
2089 }
David Blaikie9260ed62013-07-25 21:19:01 +00002090
2091 if (Value == "-force_cpusubtype_ALL") {
2092 // Do nothing, this is the default and we don't support anything else.
2093 } else if (Value == "-L") {
2094 CmdArgs.push_back("-msave-temp-labels");
2095 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002096 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002097 } else if (Value == "--noexecstack") {
2098 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002099 } else if (Value == "-compress-debug-sections" ||
2100 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002101 CompressDebugSections = true;
2102 } else if (Value == "-nocompress-debug-sections" ||
2103 Value == "--nocompress-debug-sections") {
2104 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002105 } else if (Value.startswith("-I")) {
2106 CmdArgs.push_back(Value.data());
2107 // We need to consume the next argument if the current arg is a plain
2108 // -I. The next arg will be the include directory.
2109 if (Value == "-I")
2110 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002111 } else if (Value.startswith("-gdwarf-")) {
2112 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002113 } else {
2114 D.Diag(diag::err_drv_unsupported_option_argument)
2115 << A->getOption().getName() << Value;
2116 }
2117 }
2118 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002119 if (CompressDebugSections) {
2120 if (llvm::zlib::isAvailable())
2121 CmdArgs.push_back("-compress-debug-sections");
2122 else
2123 D.Diag(diag::warn_debug_compression_unavailable);
2124 }
David Blaikie9260ed62013-07-25 21:19:01 +00002125}
2126
Renato Goline807c122014-01-31 11:47:28 +00002127// Until ARM libraries are build separately, we have them all in one library
2128static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool61770ab2015-01-02 21:47:33 +00002129 // FIXME: handle 64-bit
2130 if (TC.getTriple().isOSWindows() &&
2131 !TC.getTriple().isWindowsItaniumEnvironment())
2132 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002133 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002134 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002135 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002136}
2137
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002138static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2139 // The runtimes are located in the OS-specific resource directory.
2140 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002141 const llvm::Triple &Triple = TC.getTriple();
2142 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002143 StringRef OSLibName =
2144 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002145 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002146 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002147}
2148
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002149static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
Dan Albert6f2875d2015-01-28 23:23:36 +00002150 bool Shared = false) {
2151 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2152 ? "-android"
2153 : "";
2154
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002155 bool IsOSWindows = TC.getTriple().isOSWindows();
2156 StringRef Arch = getArchNameForCompilerRTLib(TC);
2157 const char *Prefix = IsOSWindows ? "" : "lib";
2158 const char *Suffix =
2159 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2160
2161 SmallString<128> Path = getCompilerRTLibDir(TC);
2162 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2163 Arch + Env + Suffix);
2164
2165 return Path;
2166}
2167
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002168// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002169// FIXME: Make sure we can also emit shared objects if they're requested
2170// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002171static void addClangRT(const ToolChain &TC, const ArgList &Args,
2172 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002173 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002174
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002175 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002176 // FIXME: why do we link against gcc when we are using compiler-rt?
2177 CmdArgs.push_back("-lgcc_s");
2178 if (TC.getDriver().CCCIsCXX())
2179 CmdArgs.push_back("-lgcc_eh");
2180 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002181}
2182
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002183static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2184 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002185 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2186 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002187 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002188 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Justin Bognera71e6812015-04-30 23:49:42 +00002189 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002190 Args.hasArg(options::OPT_fcreate_profile) ||
2191 Args.hasArg(options::OPT_coverage)))
2192 return;
2193
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002194 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002195}
2196
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002197namespace {
2198enum OpenMPRuntimeKind {
2199 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2200 /// without knowing what runtime to target.
2201 OMPRT_Unknown,
2202
2203 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2204 /// the default for Clang.
2205 OMPRT_OMP,
2206
2207 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2208 /// this runtime but can swallow the pragmas, and find and link against the
2209 /// runtime library itself.
2210 OMPRT_GOMP,
2211
Chandler Carruthc6625c62015-05-28 21:10:31 +00002212 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002213 /// OpenMP runtime. We support this mode for users with existing dependencies
2214 /// on this runtime library name.
2215 OMPRT_IOMP5
2216};
2217}
2218
2219/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002220static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2221 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002222 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2223
2224 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2225 if (A)
2226 RuntimeName = A->getValue();
2227
2228 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2229 .Case("libomp", OMPRT_OMP)
2230 .Case("libgomp", OMPRT_GOMP)
2231 .Case("libiomp5", OMPRT_IOMP5)
2232 .Default(OMPRT_Unknown);
2233
2234 if (RT == OMPRT_Unknown) {
2235 if (A)
2236 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
2237 << A->getOption().getName() << A->getValue();
2238 else
2239 // FIXME: We could use a nicer diagnostic here.
2240 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2241 }
2242
2243 return RT;
2244}
2245
Alexey Samsonov52550342014-09-15 19:58:40 +00002246static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2247 ArgStringList &CmdArgs, StringRef Sanitizer,
2248 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002249 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002250 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002251 if (!IsShared)
2252 CmdArgs.push_back("-whole-archive");
Dan Albert6f2875d2015-01-28 23:23:36 +00002253 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002254 if (!IsShared)
2255 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002256}
2257
Alexey Samsonov52550342014-09-15 19:58:40 +00002258// Tries to use a file with the list of dynamic symbols that need to be exported
2259// from the runtime library. Returns true if the file was found.
2260static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2261 ArgStringList &CmdArgs,
2262 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002263 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2264 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2265 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002266 return true;
2267 }
2268 return false;
2269}
2270
2271static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2272 ArgStringList &CmdArgs) {
2273 // Force linking against the system libraries sanitizers depends on
2274 // (see PR15823 why this is necessary).
2275 CmdArgs.push_back("--no-as-needed");
2276 CmdArgs.push_back("-lpthread");
2277 CmdArgs.push_back("-lrt");
2278 CmdArgs.push_back("-lm");
2279 // There's no libdl on FreeBSD.
2280 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2281 CmdArgs.push_back("-ldl");
2282}
2283
2284static void
2285collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2286 SmallVectorImpl<StringRef> &SharedRuntimes,
2287 SmallVectorImpl<StringRef> &StaticRuntimes,
2288 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2289 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2290 // Collect shared runtimes.
2291 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2292 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002293 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002294
Alexey Samsonov52550342014-09-15 19:58:40 +00002295 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002296 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002297 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2298 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002299 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002300 }
2301 if (SanArgs.needsAsanRt()) {
2302 if (SanArgs.needsSharedAsanRt()) {
2303 HelperStaticRuntimes.push_back("asan-preinit");
2304 } else {
2305 StaticRuntimes.push_back("asan");
2306 if (SanArgs.linkCXXRuntimes())
2307 StaticRuntimes.push_back("asan_cxx");
2308 }
2309 }
2310 if (SanArgs.needsDfsanRt())
2311 StaticRuntimes.push_back("dfsan");
2312 if (SanArgs.needsLsanRt())
2313 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002314 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002315 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002316 if (SanArgs.linkCXXRuntimes())
2317 StaticRuntimes.push_back("msan_cxx");
2318 }
2319 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002320 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002321 if (SanArgs.linkCXXRuntimes())
2322 StaticRuntimes.push_back("tsan_cxx");
2323 }
Alexey Samsonov52550342014-09-15 19:58:40 +00002324 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002325 StaticRuntimes.push_back("ubsan_standalone");
2326 if (SanArgs.linkCXXRuntimes())
2327 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002328 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002329}
2330
Alexey Samsonov52550342014-09-15 19:58:40 +00002331// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2332// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2333static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002334 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002335 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2336 HelperStaticRuntimes;
2337 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2338 HelperStaticRuntimes);
2339 for (auto RT : SharedRuntimes)
2340 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2341 for (auto RT : HelperStaticRuntimes)
2342 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2343 bool AddExportDynamic = false;
2344 for (auto RT : StaticRuntimes) {
2345 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2346 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2347 }
2348 // If there is a static runtime with no dynamic list, force all the symbols
2349 // to be dynamic to be sure we export sanitizer interface functions.
2350 if (AddExportDynamic)
2351 CmdArgs.push_back("-export-dynamic");
2352 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002353}
2354
Reid Kleckner86ea7702015-02-04 23:45:07 +00002355static bool areOptimizationsEnabled(const ArgList &Args) {
2356 // Find the last -O arg and see if it is non-zero.
2357 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2358 return !A->getOption().matches(options::OPT_O0);
2359 // Defaults to -O0.
2360 return false;
2361}
2362
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002363static bool shouldUseFramePointerForTarget(const ArgList &Args,
2364 const llvm::Triple &Triple) {
Reid Kleckner86ea7702015-02-04 23:45:07 +00002365 // XCore never wants frame pointers, regardless of OS.
2366 if (Triple.getArch() == llvm::Triple::xcore) {
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002367 return false;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002368 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002369
2370 if (Triple.isOSLinux()) {
2371 switch (Triple.getArch()) {
2372 // Don't use a frame pointer on linux if optimizing for certain targets.
2373 case llvm::Triple::mips64:
2374 case llvm::Triple::mips64el:
2375 case llvm::Triple::mips:
2376 case llvm::Triple::mipsel:
2377 case llvm::Triple::systemz:
2378 case llvm::Triple::x86:
2379 case llvm::Triple::x86_64:
2380 return !areOptimizationsEnabled(Args);
2381 default:
2382 return true;
2383 }
2384 }
2385
2386 if (Triple.isOSWindows()) {
2387 switch (Triple.getArch()) {
2388 case llvm::Triple::x86:
2389 return !areOptimizationsEnabled(Args);
2390 default:
2391 // All other supported Windows ISAs use xdata unwind information, so frame
2392 // pointers are not generally useful.
2393 return false;
2394 }
2395 }
2396
2397 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002398}
2399
Rafael Espindola224dd632011-12-14 21:02:23 +00002400static bool shouldUseFramePointer(const ArgList &Args,
2401 const llvm::Triple &Triple) {
2402 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2403 options::OPT_fomit_frame_pointer))
2404 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2405
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002406 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002407}
2408
Eric Christopherb7d97e92013-04-03 01:58:53 +00002409static bool shouldUseLeafFramePointer(const ArgList &Args,
2410 const llvm::Triple &Triple) {
2411 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2412 options::OPT_momit_leaf_frame_pointer))
2413 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2414
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002415 if (Triple.isPS4CPU())
2416 return false;
2417
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002418 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002419}
2420
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002421/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002422static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002423 SmallString<128> cwd;
2424 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002425 CmdArgs.push_back("-fdebug-compilation-dir");
2426 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002427 }
2428}
2429
Eric Christopherd3804002013-02-22 20:12:52 +00002430static const char *SplitDebugName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00002431 const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00002432 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2433 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2434 SmallString<128> T(FinalOutput->getValue());
2435 llvm::sys::path::replace_extension(T, "dwo");
2436 return Args.MakeArgString(T);
2437 } else {
2438 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002439 SmallString<128> T(
2440 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00002441 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00002442 llvm::sys::path::replace_extension(F, "dwo");
2443 T += F;
2444 return Args.MakeArgString(F);
2445 }
2446}
2447
2448static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2449 const Tool &T, const JobAction &JA,
2450 const ArgList &Args, const InputInfo &Output,
2451 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002452 ArgStringList ExtractArgs;
2453 ExtractArgs.push_back("--extract-dwo");
2454
2455 ArgStringList StripArgs;
2456 StripArgs.push_back("--strip-dwo");
2457
2458 // Grabbing the output of the earlier compile step.
2459 StripArgs.push_back(Output.getFilename());
2460 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002461 ExtractArgs.push_back(OutFile);
2462
2463 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002464 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002465
2466 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002467 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002468
2469 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002470 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002471}
2472
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002473/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002474/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2475static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002476 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002477 if (A->getOption().matches(options::OPT_O4) ||
2478 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002479 return true;
2480
2481 if (A->getOption().matches(options::OPT_O0))
2482 return false;
2483
2484 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2485
Rafael Espindola91780de2013-08-26 14:05:41 +00002486 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002487 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002488 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002489 return true;
2490
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002491 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002492 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002493 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002494
2495 unsigned OptLevel = 0;
2496 if (S.getAsInteger(10, OptLevel))
2497 return false;
2498
2499 return OptLevel > 1;
2500 }
2501
2502 return false;
2503}
2504
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002505/// Add -x lang to \p CmdArgs for \p Input.
2506static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2507 ArgStringList &CmdArgs) {
2508 // When using -verify-pch, we don't want to provide the type
2509 // 'precompiled-header' if it was inferred from the file extension
2510 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2511 return;
2512
2513 CmdArgs.push_back("-x");
2514 if (Args.hasArg(options::OPT_rewrite_objc))
2515 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2516 else
2517 CmdArgs.push_back(types::getTypeName(Input.getType()));
2518}
2519
David Majnemerc371ff02015-03-22 08:39:22 +00002520static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002521 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002522 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002523
2524 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002525 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002526
2527 unsigned Build = 0, Factor = 1;
2528 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2529 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002530 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002531}
2532
Rafael Espindola577637a2015-01-03 00:06:04 +00002533// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002534// options that build systems might add but are unused when assembling or only
2535// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002536static void claimNoWarnArgs(const ArgList &Args) {
2537 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002538 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002539 Args.ClaimAllArgs(options::OPT_flto);
2540 Args.ClaimAllArgs(options::OPT_fno_lto);
2541}
2542
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002543static void appendUserToPath(SmallVectorImpl<char> &Result) {
2544#ifdef LLVM_ON_UNIX
2545 const char *Username = getenv("LOGNAME");
2546#else
2547 const char *Username = getenv("USERNAME");
2548#endif
2549 if (Username) {
2550 // Validate that LoginName can be used in a path, and get its length.
2551 size_t Len = 0;
2552 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002553 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002554 Username = nullptr;
2555 break;
2556 }
2557 }
2558
2559 if (Username && Len > 0) {
2560 Result.append(Username, Username + Len);
2561 return;
2562 }
2563 }
2564
2565 // Fallback to user id.
2566#ifdef LLVM_ON_UNIX
2567 std::string UID = llvm::utostr(getuid());
2568#else
2569 // FIXME: Windows seems to have an 'SID' that might work.
2570 std::string UID = "9999";
2571#endif
2572 Result.append(UID.begin(), UID.end());
2573}
2574
David Majnemere11d3732015-06-08 00:22:46 +00002575VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2576 const llvm::Triple &Triple,
2577 const llvm::opt::ArgList &Args,
2578 bool IsWindowsMSVC) {
2579 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2580 IsWindowsMSVC) ||
2581 Args.hasArg(options::OPT_fmsc_version) ||
2582 Args.hasArg(options::OPT_fms_compatibility_version)) {
2583 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2584 const Arg *MSCompatibilityVersion =
2585 Args.getLastArg(options::OPT_fms_compatibility_version);
2586
2587 if (MSCVersion && MSCompatibilityVersion) {
2588 if (D)
2589 D->Diag(diag::err_drv_argument_not_allowed_with)
2590 << MSCVersion->getAsString(Args)
2591 << MSCompatibilityVersion->getAsString(Args);
2592 return VersionTuple();
2593 }
2594
2595 if (MSCompatibilityVersion) {
2596 VersionTuple MSVT;
2597 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2598 D->Diag(diag::err_drv_invalid_value)
2599 << MSCompatibilityVersion->getAsString(Args)
2600 << MSCompatibilityVersion->getValue();
2601 return MSVT;
2602 }
2603
2604 if (MSCVersion) {
2605 unsigned Version = 0;
2606 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2607 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2608 << MSCVersion->getValue();
2609 return getMSCompatibilityVersion(Version);
2610 }
2611
2612 unsigned Major, Minor, Micro;
2613 Triple.getEnvironmentVersion(Major, Minor, Micro);
2614 if (Major || Minor || Micro)
2615 return VersionTuple(Major, Minor, Micro);
2616
2617 return VersionTuple(18);
2618 }
2619 return VersionTuple();
2620}
2621
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002622void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002623 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002624 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002625 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002626 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002627 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2628 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002629 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002630 ArgStringList CmdArgs;
2631
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002632 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002633 bool IsWindowsCygnus =
2634 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002635 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2636
Daniel Dunbare521a892009-03-31 20:53:55 +00002637 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
Artem Belevichba558952015-05-06 18:20:23 +00002638 const InputInfo &Input = Inputs[0];
Daniel Dunbare521a892009-03-31 20:53:55 +00002639
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002640 // Invoke ourselves in -cc1 mode.
2641 //
2642 // FIXME: Implement custom jobs for internal actions.
2643 CmdArgs.push_back("-cc1");
2644
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002645 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002646 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002647 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002648 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002649
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002650 const llvm::Triple TT(TripleStr);
2651 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2652 TT.getArch() == llvm::Triple::thumb)) {
2653 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2654 unsigned Version;
2655 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2656 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002657 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2658 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002659 }
2660
Tim Northover336f1892014-03-29 13:16:12 +00002661 // Push all default warning arguments that are specific to
2662 // the given target. These come before user provided warning options
2663 // are provided.
2664 getToolChain().addClangWarningOptions(CmdArgs);
2665
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002666 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002667 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002668
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002669 if (isa<AnalyzeJobAction>(JA)) {
2670 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2671 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002672 } else if (isa<MigrateJobAction>(JA)) {
2673 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002674 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002675 if (Output.getType() == types::TY_Dependencies)
2676 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002677 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002678 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002679 if (Args.hasArg(options::OPT_rewrite_objc) &&
2680 !Args.hasArg(options::OPT_g_Group))
2681 CmdArgs.push_back("-P");
2682 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002683 } else if (isa<AssembleJobAction>(JA)) {
2684 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002685
David Blaikie9260ed62013-07-25 21:19:01 +00002686 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002687
2688 // Also ignore explicit -force_cpusubtype_ALL option.
2689 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002690 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002691 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002692 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002693
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002694 if (JA.getType() == types::TY_Nothing)
2695 CmdArgs.push_back("-fsyntax-only");
2696 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002697 CmdArgs.push_back("-emit-pch");
2698 else
2699 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002700 } else if (isa<VerifyPCHJobAction>(JA)) {
2701 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002702 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002703 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2704 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002705
Teresa Johnson88c3c672015-06-10 17:49:45 +00002706 if (JA.getType() == types::TY_LTO_IR ||
2707 JA.getType() == types::TY_LTO_BC) {
2708 CmdArgs.push_back("-flto");
2709 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002710 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002711 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002712 } else if (JA.getType() == types::TY_LLVM_IR ||
2713 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002714 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002715 } else if (JA.getType() == types::TY_LLVM_BC ||
2716 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002717 CmdArgs.push_back("-emit-llvm-bc");
2718 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002719 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002720 } else if (JA.getType() == types::TY_AST) {
2721 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002722 } else if (JA.getType() == types::TY_ModuleFile) {
2723 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002724 } else if (JA.getType() == types::TY_RewrittenObjC) {
2725 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002726 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002727 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2728 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002729 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002730 } else {
2731 assert(JA.getType() == types::TY_PP_Asm &&
2732 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002733 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00002734
2735 // Preserve use-list order by default when emitting bitcode, so that
2736 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
2737 // same result as running passes here. For LTO, we don't need to preserve
2738 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00002739 if (JA.getType() == types::TY_LLVM_BC)
2740 CmdArgs.push_back("-emit-llvm-uselists");
Daniel Dunbara3246a02009-03-18 08:07:30 +00002741 }
2742
Justin Bognera88f0122014-06-20 22:59:50 +00002743 // We normally speed up the clang process a bit by skipping destructors at
2744 // exit, but when we're generating diagnostics we can rely on some of the
2745 // cleanup.
2746 if (!C.isForDiagnostics())
2747 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002748
John McCallbb79b5f2010-02-13 03:50:24 +00002749 // Disable the verification pass in -asserts builds.
2750#ifdef NDEBUG
2751 CmdArgs.push_back("-disable-llvm-verifier");
2752#endif
2753
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002754 // Set the main file name, so that debug info works even with
2755 // -save-temps.
2756 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00002757 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002758
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002759 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002760 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002761 if (Args.hasArg(options::OPT_static))
2762 CmdArgs.push_back("-static-define");
2763
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002764 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002765 // Enable region store model by default.
2766 CmdArgs.push_back("-analyzer-store=region");
2767
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002768 // Treat blocks as analysis entry points.
2769 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2770
Ted Kremenek49c79792011-03-24 00:28:47 +00002771 CmdArgs.push_back("-analyzer-eagerly-assume");
2772
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002773 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002774 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002775 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002776
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002777 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002778 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002779
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002780 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002781 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002782
2783 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002784
Artem Belevichba558952015-05-06 18:20:23 +00002785 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00002786 CmdArgs.push_back("-analyzer-checker=cplusplus");
2787
Nico Webere8e53112014-05-11 01:04:02 +00002788 // Enable the following experimental checkers for testing.
2789 CmdArgs.push_back(
2790 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002791 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2792 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2793 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2794 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2795 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002796 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002797
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002798 // Set the output format. The default is plist, for (lame) historical
2799 // reasons.
2800 CmdArgs.push_back("-analyzer-output");
2801 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002802 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002803 else
2804 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002805
Ted Kremenekfe449a22010-03-22 22:32:05 +00002806 // Disable the presentation of standard compiler warnings when
2807 // using --analyze. We only want to show static analyzer diagnostics
2808 // or frontend errors.
2809 CmdArgs.push_back("-w");
2810
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002811 // Add -Xanalyzer arguments when running as analyzer.
2812 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002813 }
2814
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002815 CheckCodeGenerationOptions(D, Args);
2816
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002817 bool PIE = getToolChain().isPIEDefault();
2818 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002819 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002820
Alexey Bataev40e75222014-01-28 06:30:35 +00002821 // Android-specific defaults for PIC/PIE
2822 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002823 switch (getToolChain().getArch()) {
Alexey Bataev40e75222014-01-28 06:30:35 +00002824 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002825 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002826 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002827 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002828 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002829 case llvm::Triple::mips:
2830 case llvm::Triple::mipsel:
2831 case llvm::Triple::mips64:
2832 case llvm::Triple::mips64el:
2833 PIC = true; // "-fpic"
2834 break;
2835
2836 case llvm::Triple::x86:
2837 case llvm::Triple::x86_64:
2838 PIC = true; // "-fPIC"
2839 IsPICLevelTwo = true;
2840 break;
2841
2842 default:
2843 break;
2844 }
2845 }
2846
Brad Smith5b05db82014-06-24 19:51:29 +00002847 // OpenBSD-specific defaults for PIE
2848 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002849 switch (getToolChain().getArch()) {
Brad Smith5b05db82014-06-24 19:51:29 +00002850 case llvm::Triple::mips64:
2851 case llvm::Triple::mips64el:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00002852 case llvm::Triple::sparcel:
Brad Smith5b05db82014-06-24 19:51:29 +00002853 case llvm::Triple::x86:
2854 case llvm::Triple::x86_64:
2855 IsPICLevelTwo = false; // "-fpie"
2856 break;
2857
2858 case llvm::Triple::ppc:
Brad Smithb58159a2015-06-04 08:45:23 +00002859 case llvm::Triple::sparc:
Brad Smith5b05db82014-06-24 19:51:29 +00002860 case llvm::Triple::sparcv9:
2861 IsPICLevelTwo = true; // "-fPIE"
2862 break;
2863
2864 default:
2865 break;
2866 }
2867 }
2868
Alexey Samsonov090301e2013-04-09 12:28:19 +00002869 // For the PIC and PIE flag options, this logic is different from the
2870 // legacy logic in very old versions of GCC, as that logic was just
2871 // a bug no one had ever fixed. This logic is both more rational and
2872 // consistent with GCC's new logic now that the bugs are fixed. The last
2873 // argument relating to either PIC or PIE wins, and no other argument is
2874 // used. If the last argument is any flavor of the '-fno-...' arguments,
2875 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2876 // at the same level.
2877 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2878 options::OPT_fpic, options::OPT_fno_pic,
2879 options::OPT_fPIE, options::OPT_fno_PIE,
2880 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002881 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2882 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002883 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002884 if (LastPICArg) {
2885 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002886 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2887 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2888 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2889 PIC = PIE || O.matches(options::OPT_fPIC) ||
2890 O.matches(options::OPT_fpic);
2891 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2892 O.matches(options::OPT_fPIC);
2893 } else {
2894 PIE = PIC = false;
2895 }
2896 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002897 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002898
Nick Lewycky609dd662013-10-11 03:33:53 +00002899 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002900 // specified while enabling PIC enabled level 1 PIC, just force it back to
2901 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2902 // informal testing).
2903 if (PIC && getToolChain().getTriple().isOSDarwin())
2904 IsPICLevelTwo |= getToolChain().isPICDefault();
2905
Chandler Carruthc0c04552012-04-08 16:40:35 +00002906 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2907 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002908 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00002909 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002910 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002911 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002912 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002913
Chandler Carruth76a943b2012-11-19 03:52:03 +00002914 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2915 // This is a very special mode. It trumps the other modes, almost no one
2916 // uses it, and it isn't even valid on any OS but Darwin.
2917 if (!getToolChain().getTriple().isOSDarwin())
2918 D.Diag(diag::err_drv_unsupported_opt_for_target)
2919 << A->getSpelling() << getToolChain().getTriple().str();
2920
2921 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2922
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002923 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002924 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002925
Chandler Carruth76a943b2012-11-19 03:52:03 +00002926 // Only a forced PIC mode can cause the actual compile to have PIC defines
2927 // etc., no flags are sufficient. This behavior was selected to closely
2928 // match that of llvm-gcc and Apple GCC before that.
2929 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2930 CmdArgs.push_back("-pic-level");
2931 CmdArgs.push_back("2");
2932 }
2933 } else {
2934 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2935 // handled in Clang's IRGen by the -pie-level flag.
2936 CmdArgs.push_back("-mrelocation-model");
2937 CmdArgs.push_back(PIC ? "pic" : "static");
2938
2939 if (PIC) {
2940 CmdArgs.push_back("-pic-level");
2941 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2942 if (PIE) {
2943 CmdArgs.push_back("-pie-level");
2944 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2945 }
2946 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002947 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002948
Jonathan Roelofsb140a102014-10-03 21:57:44 +00002949 CmdArgs.push_back("-mthread-model");
2950 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2951 CmdArgs.push_back(A->getValue());
2952 else
2953 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2954
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00002955 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
2956
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002957 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2958 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002959 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002960
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002961 // LLVM Code Generator Options.
2962
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00002963 if (Args.hasArg(options::OPT_frewrite_map_file) ||
2964 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00002965 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
2966 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00002967 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00002968 CmdArgs.push_back(A->getValue());
2969 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00002970 }
2971 }
2972
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002973 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2974 StringRef v = A->getValue();
2975 CmdArgs.push_back("-mllvm");
2976 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2977 A->claim();
2978 }
2979
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002980 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2981 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002982 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002983 }
2984
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002985 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2986 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002987 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002988 D.Diag(diag::err_drv_unsupported_opt_for_target)
2989 << A->getSpelling() << getToolChain().getTriple().str();
2990 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2991 CmdArgs.push_back("-fpcc-struct-return");
2992 } else {
2993 assert(A->getOption().matches(options::OPT_freg_struct_return));
2994 CmdArgs.push_back("-freg-struct-return");
2995 }
2996 }
2997
Roman Divacky65b88cd2011-03-01 17:40:53 +00002998 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2999 CmdArgs.push_back("-mrtd");
3000
Rafael Espindola224dd632011-12-14 21:02:23 +00003001 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003002 CmdArgs.push_back("-mdisable-fp-elim");
3003 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3004 options::OPT_fno_zero_initialized_in_bss))
3005 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003006
3007 bool OFastEnabled = isOptimizationLevelFast(Args);
3008 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3009 // enabled. This alias option is being used to simplify the hasFlag logic.
3010 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
3011 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003012 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3013 // doesn't do any TBAA.
3014 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003015 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003016 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003017 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003018 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3019 options::OPT_fno_struct_path_tbaa))
3020 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003021 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3022 false))
3023 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00003024 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3025 options::OPT_fno_optimize_sibling_calls))
3026 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003027
Eric Christopher006208c2013-04-04 06:29:47 +00003028 // Handle segmented stacks.
3029 if (Args.hasArg(options::OPT_fsplit_stack))
3030 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003031
3032 // If -Ofast is the optimization level, then -ffast-math should be enabled.
3033 // This alias option is being used to simplify the getLastArg logic.
3034 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
3035 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00003036
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003037 // Handle various floating point optimization flags, mapping them to the
3038 // appropriate LLVM code generation flags. The pattern for all of these is to
3039 // default off the codegen optimizations, and if any flag enables them and no
3040 // flag disables them after the flag enabling them, enable the codegen
3041 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003042 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003043 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003044 options::OPT_ffinite_math_only,
3045 options::OPT_fno_finite_math_only,
3046 options::OPT_fhonor_infinities,
3047 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003048 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3049 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003050 A->getOption().getID() != options::OPT_fhonor_infinities)
3051 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003052 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003053 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003054 options::OPT_ffinite_math_only,
3055 options::OPT_fno_finite_math_only,
3056 options::OPT_fhonor_nans,
3057 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003058 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3059 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003060 A->getOption().getID() != options::OPT_fhonor_nans)
3061 CmdArgs.push_back("-menable-no-nans");
3062
Benjamin Kramerc242ef22012-05-02 14:55:48 +00003063 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3064 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003065 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003066 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003067 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00003068 options::OPT_fno_math_errno)) {
3069 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3070 // However, turning *off* -ffast_math merely restores the toolchain default
3071 // (which may be false).
3072 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3073 A->getOption().getID() == options::OPT_ffast_math ||
3074 A->getOption().getID() == options::OPT_Ofast)
3075 MathErrno = false;
3076 else if (A->getOption().getID() == options::OPT_fmath_errno)
3077 MathErrno = true;
3078 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003079 if (MathErrno)
3080 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003081
3082 // There are several flags which require disabling very specific
3083 // optimizations. Any of these being disabled forces us to turn off the
3084 // entire set of LLVM optimizations, so collect them through all the flag
3085 // madness.
3086 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003087 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003088 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003089 options::OPT_funsafe_math_optimizations,
3090 options::OPT_fno_unsafe_math_optimizations,
3091 options::OPT_fassociative_math,
3092 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003093 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3094 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003095 A->getOption().getID() != options::OPT_fno_associative_math)
3096 AssociativeMath = true;
3097 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003098 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003099 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003100 options::OPT_funsafe_math_optimizations,
3101 options::OPT_fno_unsafe_math_optimizations,
3102 options::OPT_freciprocal_math,
3103 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003104 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3105 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003106 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3107 ReciprocalMath = true;
3108 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003109 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003110 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003111 options::OPT_funsafe_math_optimizations,
3112 options::OPT_fno_unsafe_math_optimizations,
3113 options::OPT_fsigned_zeros,
3114 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003115 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3116 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003117 A->getOption().getID() != options::OPT_fsigned_zeros)
3118 SignedZeros = false;
3119 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003120 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003121 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003122 options::OPT_funsafe_math_optimizations,
3123 options::OPT_fno_unsafe_math_optimizations,
3124 options::OPT_ftrapping_math,
3125 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003126 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3127 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003128 A->getOption().getID() != options::OPT_ftrapping_math)
3129 TrappingMath = false;
3130 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3131 !TrappingMath)
3132 CmdArgs.push_back("-menable-unsafe-fp-math");
3133
Sanjay Patel76c9e092015-01-23 16:40:50 +00003134 if (!SignedZeros)
3135 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003136
Sanjay Patel359b1052015-04-09 15:03:23 +00003137 if (ReciprocalMath)
3138 CmdArgs.push_back("-freciprocal-math");
3139
Lang Hamesaa53b932012-07-06 00:59:19 +00003140 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003141 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003142 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003143 options::OPT_ffp_contract)) {
3144 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003145 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003146 if (Val == "fast" || Val == "on" || Val == "off") {
3147 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3148 } else {
3149 D.Diag(diag::err_drv_unsupported_option_argument)
3150 << A->getOption().getName() << Val;
3151 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003152 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3153 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003154 // If fast-math is set then set the fp-contract mode to fast.
3155 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3156 }
3157 }
3158
Bob Wilson6a039162012-07-19 03:52:53 +00003159 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3160 // and if we find them, tell the frontend to provide the appropriate
3161 // preprocessor macros. This is distinct from enabling any optimizations as
3162 // these options induce language changes which must survive serialization
3163 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003164 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3165 options::OPT_fno_fast_math))
3166 if (!A->getOption().matches(options::OPT_fno_fast_math))
3167 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003168 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3169 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003170 if (A->getOption().matches(options::OPT_ffinite_math_only))
3171 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003172
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003173 // Decide whether to use verbose asm. Verbose assembly is the default on
3174 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003175 bool IsIntegratedAssemblerDefault =
3176 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003177 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003178 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003179 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003180 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003181
Rafael Espindolab8a12932015-05-22 20:44:03 +00003182 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3183 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003184 CmdArgs.push_back("-no-integrated-as");
3185
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003186 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3187 CmdArgs.push_back("-mdebug-pass");
3188 CmdArgs.push_back("Structure");
3189 }
3190 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3191 CmdArgs.push_back("-mdebug-pass");
3192 CmdArgs.push_back("Arguments");
3193 }
3194
John McCall8517abc2010-02-19 02:45:38 +00003195 // Enable -mconstructor-aliases except on darwin, where we have to
3196 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003197 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003198 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003199
John McCall7ef5cb32011-03-18 02:56:14 +00003200 // Darwin's kernel doesn't support guard variables; just die if we
3201 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003202 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003203 CmdArgs.push_back("-fforbid-guard-variables");
3204
Douglas Gregordbe39272011-02-01 15:15:22 +00003205 if (Args.hasArg(options::OPT_mms_bitfields)) {
3206 CmdArgs.push_back("-mms-bitfields");
3207 }
John McCall8517abc2010-02-19 02:45:38 +00003208
Daniel Dunbar306945d2009-09-16 06:17:29 +00003209 // This is a coarse approximation of what llvm-gcc actually does, both
3210 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3211 // complicated ways.
3212 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003213 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3214 options::OPT_fno_asynchronous_unwind_tables,
3215 (getToolChain().IsUnwindTablesDefault() ||
3216 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3217 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003218 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3219 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003220 CmdArgs.push_back("-munwind-tables");
3221
Chandler Carruth05fb5852012-11-21 23:40:23 +00003222 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003223
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003224 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3225 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003226 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003227 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003228
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003229 // FIXME: Handle -mtune=.
3230 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003231
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003232 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003233 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003234 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003235 }
3236
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003237 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00003238 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003239 if (!CPU.empty()) {
3240 CmdArgs.push_back("-target-cpu");
3241 CmdArgs.push_back(Args.MakeArgString(CPU));
3242 }
3243
Rafael Espindolaeb265472013-08-21 21:59:03 +00003244 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3245 CmdArgs.push_back("-mfpmath");
3246 CmdArgs.push_back(A->getValue());
3247 }
3248
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003249 // Add the target features
John Brawn94fd9632015-05-21 12:19:49 +00003250 getTargetFeatures(D, Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003251
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003252 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003253 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003254 default:
3255 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003256
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003257 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003258 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003259 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003260 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003261 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003262 break;
3263
Tim Northover573cbee2014-05-24 12:52:07 +00003264 case llvm::Triple::aarch64:
3265 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003266 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003267 break;
3268
Eric Christopher0b26a612010-03-02 02:41:08 +00003269 case llvm::Triple::mips:
3270 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003271 case llvm::Triple::mips64:
3272 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003273 AddMIPSTargetArgs(Args, CmdArgs);
3274 break;
3275
Ulrich Weigand8afad612014-07-28 13:17:52 +00003276 case llvm::Triple::ppc:
3277 case llvm::Triple::ppc64:
3278 case llvm::Triple::ppc64le:
3279 AddPPCTargetArgs(Args, CmdArgs);
3280 break;
3281
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003282 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00003283 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00003284 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003285 AddSparcTargetArgs(Args, CmdArgs);
3286 break;
3287
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003288 case llvm::Triple::x86:
3289 case llvm::Triple::x86_64:
3290 AddX86TargetArgs(Args, CmdArgs);
3291 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003292
3293 case llvm::Triple::hexagon:
3294 AddHexagonTargetArgs(Args, CmdArgs);
3295 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003296 }
3297
Hans Wennborg75958c42013-08-08 00:17:41 +00003298 // Add clang-cl arguments.
3299 if (getToolChain().getDriver().IsCLMode())
3300 AddClangCLArgs(Args, CmdArgs);
3301
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003302 // Pass the linker version in use.
3303 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3304 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003305 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003306 }
3307
Eric Christopherb7d97e92013-04-03 01:58:53 +00003308 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003309 CmdArgs.push_back("-momit-leaf-frame-pointer");
3310
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003311 // Explicitly error on some things we know we don't support and can't just
3312 // ignore.
Artem Belevichba558952015-05-06 18:20:23 +00003313 types::ID InputType = Input.getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003314 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3315 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003316 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003317 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003318 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003319 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3320 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003321 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003322 << Unsupported->getOption().getName();
3323 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003324 }
3325
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003326 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003327 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003328 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003329 CmdArgs.push_back("-header-include-file");
3330 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3331 D.CCPrintHeadersFilename : "-");
3332 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003333 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003334 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003335
Chad Rosierbe10f982011-08-02 17:58:04 +00003336 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003337 CmdArgs.push_back("-diagnostic-log-file");
3338 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3339 D.CCLogDiagnosticsFilename : "-");
3340 }
3341
Manman Ren17bdb0f2013-11-20 20:22:14 +00003342 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3343 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003344 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003345 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003346 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3347 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003348 // FIXME: we should support specifying dwarf version with
3349 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003350 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003351 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003352 const llvm::Triple &Triple = getToolChain().getTriple();
3353 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003354 Triple.getOS() == llvm::Triple::FreeBSD ||
3355 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003356 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003357 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003358 CmdArgs.push_back("-gdwarf-2");
3359 else if (A->getOption().matches(options::OPT_gdwarf_3))
3360 CmdArgs.push_back("-gdwarf-3");
3361 else if (A->getOption().matches(options::OPT_gdwarf_4))
3362 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003363 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003364 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003365 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003366 const llvm::Triple &Triple = getToolChain().getTriple();
3367 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003368 Triple.getOS() == llvm::Triple::FreeBSD ||
3369 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003370 CmdArgs.push_back("-gdwarf-2");
3371 else
3372 CmdArgs.push_back("-g");
3373 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003374 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003375
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003376 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3377 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003378 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3379 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003380 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003381
Eric Christopher138c32b2013-09-13 22:37:55 +00003382 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003383 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3384 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003385 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003386 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003387 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003388 CmdArgs.push_back("-g");
3389 CmdArgs.push_back("-backend-option");
3390 CmdArgs.push_back("-split-dwarf=Enable");
3391 }
3392
Eric Christopher138c32b2013-09-13 22:37:55 +00003393 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3394 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3395 CmdArgs.push_back("-backend-option");
3396 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3397 }
Eric Christophereec89c22013-06-18 00:03:50 +00003398
Eric Christopher0d403d22014-02-14 01:27:03 +00003399 // -gdwarf-aranges turns on the emission of the aranges section in the
3400 // backend.
3401 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3402 CmdArgs.push_back("-backend-option");
3403 CmdArgs.push_back("-generate-arange-section");
3404 }
3405
David Blaikief36d9ba2014-01-27 18:52:43 +00003406 if (Args.hasFlag(options::OPT_fdebug_types_section,
3407 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003408 CmdArgs.push_back("-backend-option");
3409 CmdArgs.push_back("-generate-type-units");
3410 }
Eric Christophereec89c22013-06-18 00:03:50 +00003411
Ed Schouten6e576152015-03-26 17:50:28 +00003412 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3413 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3414
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003415 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003416 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003417 CmdArgs.push_back("-ffunction-sections");
3418 }
3419
3420 if (Args.hasFlag(options::OPT_fdata_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003421 options::OPT_fno_data_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003422 CmdArgs.push_back("-fdata-sections");
3423 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003424
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003425 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00003426 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003427 CmdArgs.push_back("-fno-unique-section-names");
3428
Chris Lattner3c77a352010-06-22 00:03:40 +00003429 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3430
Justin Bognera71e6812015-04-30 23:49:42 +00003431 if ((Args.hasArg(options::OPT_fprofile_instr_generate) ||
3432 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)) &&
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003433 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3434 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3435 D.Diag(diag::err_drv_argument_not_allowed_with)
3436 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3437
Justin Bognera71e6812015-04-30 23:49:42 +00003438 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_generate_EQ))
3439 A->render(Args, CmdArgs);
3440 else
3441 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003442
3443 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3444 A->render(Args, CmdArgs);
3445 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3446 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3447
Nick Lewycky207bce32011-04-21 23:44:07 +00003448 if (Args.hasArg(options::OPT_ftest_coverage) ||
3449 Args.hasArg(options::OPT_coverage))
3450 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003451 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3452 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003453 Args.hasArg(options::OPT_coverage))
3454 CmdArgs.push_back("-femit-coverage-data");
3455
Alex Lorenzee024992014-08-04 18:41:51 +00003456 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
Justin Bognera71e6812015-04-30 23:49:42 +00003457 !(Args.hasArg(options::OPT_fprofile_instr_generate) ||
3458 Args.hasArg(options::OPT_fprofile_instr_generate_EQ)))
Alex Lorenzee024992014-08-04 18:41:51 +00003459 D.Diag(diag::err_drv_argument_only_allowed_with)
3460 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3461
3462 if (Args.hasArg(options::OPT_fcoverage_mapping))
3463 CmdArgs.push_back("-fcoverage-mapping");
3464
Nick Lewycky480cb992011-05-04 20:46:58 +00003465 if (C.getArgs().hasArg(options::OPT_c) ||
3466 C.getArgs().hasArg(options::OPT_S)) {
3467 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003468 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003469 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003470 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003471 CoverageFilename = FinalOutput->getValue();
3472 } else {
3473 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3474 }
Yaron Keren92e1b622015-03-18 10:17:07 +00003475 if (llvm::sys::path::is_relative(CoverageFilename)) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003476 SmallString<128> Pwd;
3477 if (!llvm::sys::fs::current_path(Pwd)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00003478 llvm::sys::path::append(Pwd, CoverageFilename);
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003479 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003480 }
3481 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003482 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003483 }
3484 }
3485
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003486 // Pass options for controlling the default header search paths.
3487 if (Args.hasArg(options::OPT_nostdinc)) {
3488 CmdArgs.push_back("-nostdsysteminc");
3489 CmdArgs.push_back("-nobuiltininc");
3490 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003491 if (Args.hasArg(options::OPT_nostdlibinc))
3492 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003493 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3494 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3495 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003496
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003497 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003498 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003499 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003500
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003501 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3502
Ted Kremenekf7639e12012-03-06 20:06:33 +00003503 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003504 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003505 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003506 options::OPT_ccc_arcmt_modify,
3507 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003508 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003509 switch (A->getOption().getID()) {
3510 default:
3511 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003512 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003513 CmdArgs.push_back("-arcmt-check");
3514 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003515 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003516 CmdArgs.push_back("-arcmt-modify");
3517 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003518 case options::OPT_ccc_arcmt_migrate:
3519 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003520 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003521 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003522
3523 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3524 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003525 break;
John McCalld70fb982011-06-15 23:25:17 +00003526 }
3527 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003528 } else {
3529 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3530 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3531 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003532 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003533
Ted Kremenekf7639e12012-03-06 20:06:33 +00003534 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3535 if (ARCMTEnabled) {
3536 D.Diag(diag::err_drv_argument_not_allowed_with)
3537 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3538 }
3539 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003540 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003541
3542 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003543 options::OPT_objcmt_migrate_subscripting,
3544 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003545 // None specified, means enable them all.
3546 CmdArgs.push_back("-objcmt-migrate-literals");
3547 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003548 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003549 } else {
3550 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3551 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003552 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003553 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003554 } else {
3555 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3556 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3557 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3558 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3559 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3560 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00003561 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003562 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3563 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3564 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3565 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3566 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3567 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3568 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003569 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003570 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003571 }
3572
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003573 // Add preprocessing options like -I, -D, etc. if we are using the
3574 // preprocessor.
3575 //
3576 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003577 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003578 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003579
Rafael Espindolaa7431922011-07-21 23:40:37 +00003580 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3581 // that "The compiler can only warn and ignore the option if not recognized".
3582 // When building with ccache, it will pass -D options to clang even on
3583 // preprocessed inputs and configure concludes that -fPIC is not supported.
3584 Args.ClaimAllArgs(options::OPT_D);
3585
Alp Toker7874bdc2013-11-15 20:40:58 +00003586 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003587 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3588 if (A->getOption().matches(options::OPT_O4)) {
3589 CmdArgs.push_back("-O3");
3590 D.Diag(diag::warn_O4_is_O3);
3591 } else {
3592 A->render(Args, CmdArgs);
3593 }
3594 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003595
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003596 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00003597 for (const Arg *A :
3598 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3599 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003600 }
3601
Rafael Espindola577637a2015-01-03 00:06:04 +00003602 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003603
Richard Smith3be1cb22014-08-07 00:24:21 +00003604 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003605 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003606 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3607 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003608 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003609 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003610
3611 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003612 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003613 //
3614 // If a std is supplied, only add -trigraphs if it follows the
3615 // option.
David Majnemer8db91762015-05-18 04:49:30 +00003616 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003617 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3618 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003619 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003620 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003621 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003622 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003623 else
3624 Std->render(Args, CmdArgs);
3625
Nico Weber00721502014-12-23 22:32:37 +00003626 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003627 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003628 options::OPT_ftrigraphs,
3629 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003630 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003631 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003632 } else {
3633 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003634 //
3635 // FIXME: Clang doesn't correctly handle -std= when the input language
3636 // doesn't match. For the time being just ignore this for C++ inputs;
3637 // eventually we want to do all the standard defaulting here instead of
3638 // splitting it between the driver and clang -cc1.
3639 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003640 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3641 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003642 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00003643 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00003644
Nico Weber00721502014-12-23 22:32:37 +00003645 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3646 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003647 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003648
Richard Smith282b4492013-09-04 22:50:31 +00003649 // GCC's behavior for -Wwrite-strings is a bit strange:
3650 // * In C, this "warning flag" changes the types of string literals from
3651 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3652 // for the discarded qualifier.
3653 // * In C++, this is just a normal warning flag.
3654 //
3655 // Implementing this warning correctly in C is hard, so we follow GCC's
3656 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3657 // a non-const char* in C, rather than using this crude hack.
3658 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003659 // FIXME: This should behave just like a warning flag, and thus should also
3660 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3661 Arg *WriteStrings =
3662 Args.getLastArg(options::OPT_Wwrite_strings,
3663 options::OPT_Wno_write_strings, options::OPT_w);
3664 if (WriteStrings &&
3665 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003666 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003667 }
3668
Chandler Carruth61fbf622011-04-23 09:27:53 +00003669 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003670 // during C++ compilation, which it is by default. GCC keeps this define even
3671 // in the presence of '-w', match this behavior bug-for-bug.
3672 if (types::isCXX(InputType) &&
3673 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3674 true)) {
3675 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003676 }
3677
Chandler Carruthe0391482010-05-22 02:21:53 +00003678 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3679 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3680 if (Asm->getOption().matches(options::OPT_fasm))
3681 CmdArgs.push_back("-fgnu-keywords");
3682 else
3683 CmdArgs.push_back("-fno-gnu-keywords");
3684 }
3685
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003686 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3687 CmdArgs.push_back("-fno-dwarf-directory-asm");
3688
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003689 if (ShouldDisableAutolink(Args, getToolChain()))
3690 CmdArgs.push_back("-fno-autolink");
3691
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003692 // Add in -fdebug-compilation-dir if necessary.
3693 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003694
Richard Smith9a568822011-11-21 19:36:32 +00003695 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3696 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003697 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003698 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003699 }
3700
Richard Smith79c927b2013-11-06 19:31:51 +00003701 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3702 CmdArgs.push_back("-foperator-arrow-depth");
3703 CmdArgs.push_back(A->getValue());
3704 }
3705
Richard Smith9a568822011-11-21 19:36:32 +00003706 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3707 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003708 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003709 }
3710
Richard Smitha3d3bd22013-05-08 02:12:03 +00003711 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3712 CmdArgs.push_back("-fconstexpr-steps");
3713 CmdArgs.push_back(A->getValue());
3714 }
3715
Richard Smithb3a14522013-02-22 01:59:51 +00003716 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3717 CmdArgs.push_back("-fbracket-depth");
3718 CmdArgs.push_back(A->getValue());
3719 }
3720
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003721 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3722 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003723 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003724 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003725 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3726 } else
3727 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003728 }
3729
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003730
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003731 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003732 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003733
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003734 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3735 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003736 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003737 }
David Chisnall5778fce2009-08-31 16:41:57 +00003738
Chris Lattnere23003d2010-01-09 21:54:33 +00003739 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3740 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003741 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003742 }
3743
Chris Lattnerb35583d2010-04-07 20:49:23 +00003744 CmdArgs.push_back("-ferror-limit");
3745 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003746 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003747 else
3748 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003749
Chandler Carrutha77a7272010-05-06 04:55:18 +00003750 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3751 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003752 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003753 }
3754
3755 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3756 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003757 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003758 }
3759
Richard Smithf6f003a2011-12-16 19:06:07 +00003760 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3761 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003762 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003763 }
3764
Nick Lewycky24653262014-12-16 21:39:02 +00003765 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3766 CmdArgs.push_back("-fspell-checking-limit");
3767 CmdArgs.push_back(A->getValue());
3768 }
3769
Daniel Dunbar2c978472009-11-04 06:24:47 +00003770 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003771 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003772 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003773 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003774 } else {
3775 // If -fmessage-length=N was not specified, determine whether this is a
3776 // terminal and, if so, implicitly define -fmessage-length appropriately.
3777 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003778 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003779 }
3780
John McCallb4a99d32013-02-19 01:57:35 +00003781 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3782 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3783 options::OPT_fvisibility_ms_compat)) {
3784 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3785 CmdArgs.push_back("-fvisibility");
3786 CmdArgs.push_back(A->getValue());
3787 } else {
3788 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3789 CmdArgs.push_back("-fvisibility");
3790 CmdArgs.push_back("hidden");
3791 CmdArgs.push_back("-ftype-visibility");
3792 CmdArgs.push_back("default");
3793 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003794 }
3795
Douglas Gregor08329632010-06-15 17:05:35 +00003796 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003797
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003798 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3799
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003800 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003801 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3802 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003803 CmdArgs.push_back("-ffreestanding");
3804
Daniel Dunbare357d562009-12-03 18:42:11 +00003805 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003806 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003807 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003808 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3809 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003810 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003811 // AltiVec language extensions aren't relevant for assembling.
3812 if (!isa<PreprocessJobAction>(JA) ||
3813 Output.getType() != types::TY_PP_Asm)
3814 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003815 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3816 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003817
Alexey Bataevdb390212015-05-20 04:24:19 +00003818 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00003819 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3820 options::OPT_fno_openmp, false))
3821 switch (getOpenMPRuntime(getToolChain(), Args)) {
3822 case OMPRT_OMP:
3823 case OMPRT_IOMP5:
3824 // Clang can generate useful OpenMP code for these two runtime libraries.
3825 CmdArgs.push_back("-fopenmp");
3826 break;
3827 default:
3828 // By default, if Clang doesn't know how to generate useful OpenMP code
3829 // for a specific runtime library, we just don't pass the '-fopenmp' flag
3830 // down to the actual compilation.
3831 // FIXME: It would be better to have a mode which *only* omits IR
3832 // generation based on the OpenMP support so that we get consistent
3833 // semantic analysis, etc.
3834 break;
3835 }
Alexey Bataevdb390212015-05-20 04:24:19 +00003836
Peter Collingbourne32701642013-11-01 18:16:25 +00003837 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3838 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003839
Eric Christopher459d2712013-02-19 06:16:53 +00003840 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00003841 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
3842 const llvm::Triple::ArchType Arch = getToolChain().getArch();
3843 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
3844 Arch == llvm::Triple::ppc64le))
3845 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3846 << "ppc/ppc64/ppc64le";
3847 }
Chad Rosier864dfe12012-03-13 23:45:51 +00003848
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003849 if (getToolChain().SupportsProfiling())
3850 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003851
3852 // -flax-vector-conversions is default.
3853 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3854 options::OPT_fno_lax_vector_conversions))
3855 CmdArgs.push_back("-fno-lax-vector-conversions");
3856
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003857 if (Args.getLastArg(options::OPT_fapple_kext))
3858 CmdArgs.push_back("-fapple-kext");
3859
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003860 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003861 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003862 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003863 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3864 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003865
3866 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3867 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003868 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003869 }
3870
Bob Wilson14adb362012-02-03 06:27:22 +00003871 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003872
Chandler Carruth6e501032011-03-27 00:04:55 +00003873 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3874 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3875 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3876 options::OPT_fno_wrapv)) {
3877 if (A->getOption().matches(options::OPT_fwrapv))
3878 CmdArgs.push_back("-fwrapv");
3879 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3880 options::OPT_fno_strict_overflow)) {
3881 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3882 CmdArgs.push_back("-fwrapv");
3883 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003884
3885 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3886 options::OPT_fno_reroll_loops))
3887 if (A->getOption().matches(options::OPT_freroll_loops))
3888 CmdArgs.push_back("-freroll-loops");
3889
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003890 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003891 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3892 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003893
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003894 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3895
Mahesha S6a682be42012-10-27 07:47:56 +00003896
Daniel Dunbar4930e332009-11-17 08:07:36 +00003897 // -stack-protector=0 is default.
3898 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003899 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3900 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003901 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003902 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003903 if (A->getOption().matches(options::OPT_fstack_protector)) {
3904 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3905 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3906 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003907 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003908 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003909 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003910 } else {
3911 StackProtectorLevel =
3912 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3913 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003914 if (StackProtectorLevel) {
3915 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003916 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003917 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003918
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003919 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00003920 for (const Arg *A : Args.filtered(options::OPT__param)) {
3921 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003922 if (Str.startswith("ssp-buffer-size=")) {
3923 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003924 CmdArgs.push_back("-stack-protector-buffer-size");
3925 // FIXME: Verify the argument is a valid integer.
3926 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003927 }
Sean Silva14facf32015-06-09 01:57:17 +00003928 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003929 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003930 }
3931
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003932 // Translate -mstackrealign
3933 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3934 false)) {
3935 CmdArgs.push_back("-backend-option");
3936 CmdArgs.push_back("-force-align-stack");
3937 }
3938 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3939 false)) {
3940 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3941 }
3942
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003943 if (Args.hasArg(options::OPT_mstack_alignment)) {
3944 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3945 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003946 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003947
Hans Wennborg77dc2362015-01-20 19:45:50 +00003948 if (Args.hasArg(options::OPT_mstack_probe_size)) {
3949 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
3950
3951 if (!Size.empty())
3952 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
3953 else
3954 CmdArgs.push_back("-mstack-probe-size=0");
3955 }
3956
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00003957 if (getToolChain().getArch() == llvm::Triple::aarch64 ||
3958 getToolChain().getArch() == llvm::Triple::aarch64_be)
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003959 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3960
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003961 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3962 options::OPT_mno_restrict_it)) {
3963 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3964 CmdArgs.push_back("-backend-option");
3965 CmdArgs.push_back("-arm-restrict-it");
3966 } else {
3967 CmdArgs.push_back("-backend-option");
3968 CmdArgs.push_back("-arm-no-restrict-it");
3969 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003970 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3971 TT.getArch() == llvm::Triple::thumb)) {
3972 // Windows on ARM expects restricted IT blocks
3973 CmdArgs.push_back("-backend-option");
3974 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003975 }
3976
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003977 if (TT.getArch() == llvm::Triple::arm ||
3978 TT.getArch() == llvm::Triple::thumb) {
3979 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3980 options::OPT_mno_long_calls)) {
3981 if (A->getOption().matches(options::OPT_mlong_calls)) {
3982 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003983 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003984 }
3985 }
3986 }
3987
Daniel Dunbard18049a2009-04-07 21:16:11 +00003988 // Forward -f options with positive and negative forms; we translate
3989 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003990 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3991 StringRef fname = A->getValue();
3992 if (!llvm::sys::fs::exists(fname))
3993 D.Diag(diag::err_drv_no_such_file) << fname;
3994 else
3995 A->render(Args, CmdArgs);
3996 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003997
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003998 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003999 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004000 CmdArgs.push_back("-fapple-kext");
4001 if (!Args.hasArg(options::OPT_fbuiltin))
4002 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00004003 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004004 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004005 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004006 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00004007 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00004008
Nuno Lopes13c88c72009-12-16 16:59:22 +00004009 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4010 options::OPT_fno_assume_sane_operator_new))
4011 CmdArgs.push_back("-fno-assume-sane-operator-new");
4012
Daniel Dunbar4930e332009-11-17 08:07:36 +00004013 // -fblocks=0 is default.
4014 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00004015 getToolChain().IsBlocksDefault()) ||
4016 (Args.hasArg(options::OPT_fgnu_runtime) &&
4017 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4018 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00004019 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00004020
4021 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4022 !getToolChain().hasBlocksRuntime())
4023 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00004024 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004025
Richard Smithffb65082014-09-30 23:10:19 +00004026 // -fmodules enables modules (off by default).
4027 // Users can pass -fno-cxx-modules to turn off modules support for
4028 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00004029 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00004030 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
4031 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4032 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00004033 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00004034 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00004035 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00004036 HaveModules = true;
4037 }
4038 }
4039
Daniel Jasper07e6c402013-08-05 20:26:17 +00004040 // -fmodule-maps enables module map processing (off by default) for header
4041 // checking. It is implied by -fmodules.
4042 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
4043 false)) {
4044 CmdArgs.push_back("-fmodule-maps");
4045 }
4046
Daniel Jasperac42b752013-10-21 06:34:34 +00004047 // -fmodules-decluse checks that modules used are declared so (off by
4048 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004049 if (Args.hasFlag(options::OPT_fmodules_decluse,
4050 options::OPT_fno_modules_decluse,
4051 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00004052 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004053 }
4054
Daniel Jasper962b38e2014-04-11 11:47:45 +00004055 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4056 // all #included headers are part of modules.
4057 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4058 options::OPT_fno_modules_strict_decluse,
4059 false)) {
4060 CmdArgs.push_back("-fmodules-strict-decluse");
4061 }
4062
Manuel Klimekd2e8b042015-02-20 11:44:41 +00004063 // -fno-implicit-modules turns off implicitly compiling modules on demand.
4064 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4065 options::OPT_fno_implicit_modules)) {
4066 CmdArgs.push_back("-fno-implicit-modules");
4067 }
4068
Daniel Jasperac42b752013-10-21 06:34:34 +00004069 // -fmodule-name specifies the module that is currently being built (or
4070 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00004071 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00004072
Richard Smith9887d792014-10-17 01:42:53 +00004073 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00004074 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00004075 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00004076
Richard Smithe842a472014-10-22 02:05:46 +00004077 // -fmodule-file can be used to specify files containing precompiled modules.
4078 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4079
4080 // -fmodule-cache-path specifies where our implicitly-built module files
4081 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00004082 SmallString<128> ModuleCachePath;
4083 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4084 ModuleCachePath = A->getValue();
4085 if (HaveModules) {
4086 if (C.isForDiagnostics()) {
4087 // When generating crash reports, we want to emit the modules along with
4088 // the reproduction sources, so we ignore any provided module path.
4089 ModuleCachePath = Output.getFilename();
4090 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
4091 llvm::sys::path::append(ModuleCachePath, "modules");
4092 } else if (ModuleCachePath.empty()) {
4093 // No module path was provided: use the default.
4094 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
4095 ModuleCachePath);
Ben Langmuir3b7b5402015-02-03 19:28:37 +00004096 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang.");
4097 appendUserToPath(ModuleCachePath);
Justin Bognera88f0122014-06-20 22:59:50 +00004098 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
4099 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004100 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00004101 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
4102 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
4103 }
4104
4105 // When building modules and generating crashdumps, we need to dump a module
4106 // dependency VFS alongside the output.
4107 if (HaveModules && C.isForDiagnostics()) {
4108 SmallString<128> VFSDir(Output.getFilename());
4109 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004110 // Add the cache directory as a temp so the crash diagnostics pick it up.
4111 C.addTempFile(Args.MakeArgString(VFSDir));
4112
Justin Bognera88f0122014-06-20 22:59:50 +00004113 llvm::sys::path::append(VFSDir, "vfs");
4114 CmdArgs.push_back("-module-dependency-dir");
4115 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004116 }
4117
Richard Smith9887d792014-10-17 01:42:53 +00004118 if (HaveModules)
4119 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004120
Douglas Gregor35b04d62013-02-07 19:01:24 +00004121 // Pass through all -fmodules-ignore-macro arguments.
4122 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004123 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4124 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004125
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004126 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4127
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004128 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4129 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4130 D.Diag(diag::err_drv_argument_not_allowed_with)
4131 << A->getAsString(Args) << "-fbuild-session-timestamp";
4132
4133 llvm::sys::fs::file_status Status;
4134 if (llvm::sys::fs::status(A->getValue(), Status))
4135 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004136 CmdArgs.push_back(Args.MakeArgString(
4137 "-fbuild-session-timestamp=" +
4138 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004139 }
4140
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004141 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004142 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4143 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004144 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4145
4146 Args.AddLastArg(CmdArgs,
4147 options::OPT_fmodules_validate_once_per_build_session);
4148 }
4149
Ben Langmuirdcf73862014-03-12 00:06:17 +00004150 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4151
John McCalldfea9982010-04-09 19:12:06 +00004152 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004153 if (Args.hasFlag(options::OPT_fno_access_control,
4154 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00004155 false))
John McCall3155f572010-04-09 19:03:51 +00004156 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004157
Anders Carlssond470fef2010-11-21 00:09:52 +00004158 // -felide-constructors is the default.
4159 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4160 options::OPT_felide_constructors,
4161 false))
4162 CmdArgs.push_back("-fno-elide-constructors");
4163
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004164 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004165
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004166 if (KernelOrKext || (types::isCXX(InputType) &&
4167 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4168 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004169 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004170
Tony Linthicum76329bf2011-12-12 21:14:55 +00004171 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004172 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00004173 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004174 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00004175 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004176 CmdArgs.push_back("-fshort-enums");
4177
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004178 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00004179 if (Arg *A = Args.getLastArg(
4180 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4181 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4182 if (A->getOption().matches(options::OPT_funsigned_char) ||
4183 A->getOption().matches(options::OPT_fno_signed_char)) {
4184 CmdArgs.push_back("-fno-signed-char");
4185 }
4186 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004187 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00004188 }
Eli Friedman327f0b52009-06-05 07:21:14 +00004189
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004190 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004191 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4192 options::OPT_fno_use_cxa_atexit,
4193 !IsWindowsCygnus && !IsWindowsGNU &&
4194 getToolChain().getArch() != llvm::Triple::hexagon &&
4195 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004196 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004197 CmdArgs.push_back("-fno-use-cxa-atexit");
4198
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004199 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004200 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004201 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004202 CmdArgs.push_back("-fms-extensions");
4203
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004204 // -fno-use-line-directives is default.
4205 if (Args.hasFlag(options::OPT_fuse_line_directives,
4206 options::OPT_fno_use_line_directives, false))
4207 CmdArgs.push_back("-fuse-line-directives");
4208
Francois Pichet1b4f1632011-09-17 04:32:15 +00004209 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004210 if (Args.hasFlag(options::OPT_fms_compatibility,
4211 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004212 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
4213 options::OPT_fno_ms_extensions,
4214 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004215 CmdArgs.push_back("-fms-compatibility");
4216
David Majnemerc371ff02015-03-22 08:39:22 +00004217 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00004218 VersionTuple MSVT = visualstudio::getMSVCVersion(
4219 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4220 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00004221 CmdArgs.push_back(
4222 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004223
David Majnemer8db91762015-05-18 04:49:30 +00004224 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4225 if (ImplyVCPPCXXVer) {
4226 if (IsMSVC2015Compatible)
4227 CmdArgs.push_back("-std=c++14");
4228 else
4229 CmdArgs.push_back("-std=c++11");
4230 }
4231
Eric Christopher5ecce122013-02-18 00:38:31 +00004232 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004233 if (Args.hasFlag(options::OPT_fborland_extensions,
4234 options::OPT_fno_borland_extensions, false))
4235 CmdArgs.push_back("-fborland-extensions");
4236
David Majnemerc371ff02015-03-22 08:39:22 +00004237 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4238 // than 19.
4239 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4240 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00004241 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00004242 CmdArgs.push_back("-fno-threadsafe-statics");
4243
Francois Pichet02744872011-09-01 16:38:08 +00004244 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4245 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004246 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004247 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004248 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004249
Chandler Carruthe03aa552010-04-17 20:17:31 +00004250 // -fgnu-keywords default varies depending on language; only pass if
4251 // specified.
4252 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004253 options::OPT_fno_gnu_keywords))
4254 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004255
Rafael Espindola922a6242011-06-02 17:30:53 +00004256 if (Args.hasFlag(options::OPT_fgnu89_inline,
4257 options::OPT_fno_gnu89_inline,
4258 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004259 CmdArgs.push_back("-fgnu89-inline");
4260
Chad Rosier9c76d242012-03-15 22:31:42 +00004261 if (Args.hasArg(options::OPT_fno_inline))
4262 CmdArgs.push_back("-fno-inline");
4263
Chad Rosier64d6be92012-03-06 21:17:19 +00004264 if (Args.hasArg(options::OPT_fno_inline_functions))
4265 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004266
John McCall5fb5df92012-06-20 06:18:46 +00004267 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004268
John McCall5fb5df92012-06-20 06:18:46 +00004269 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004270 // legacy is the default. Except for deployment taget of 10.5,
4271 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4272 // gets ignored silently.
4273 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004274 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4275 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004276 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004277 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004278 if (getToolChain().UseObjCMixedDispatch())
4279 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4280 else
4281 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4282 }
4283 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004284
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004285 // When ObjectiveC legacy runtime is in effect on MacOSX,
4286 // turn on the option to do Array/Dictionary subscripting
4287 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004288 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004289 getToolChain().getTriple().isMacOSX() &&
4290 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4291 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004292 objcRuntime.isNeXTFamily())
4293 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4294
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004295 // -fencode-extended-block-signature=1 is default.
4296 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4297 CmdArgs.push_back("-fencode-extended-block-signature");
4298 }
4299
John McCall24fc0de2011-07-06 00:26:06 +00004300 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4301 // NOTE: This logic is duplicated in ToolChains.cpp.
4302 bool ARC = isObjCAutoRefCount(Args);
4303 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004304 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004305
John McCall24fc0de2011-07-06 00:26:06 +00004306 CmdArgs.push_back("-fobjc-arc");
4307
Chandler Carruth491db322011-11-04 07:34:47 +00004308 // FIXME: It seems like this entire block, and several around it should be
4309 // wrapped in isObjC, but for now we just use it here as this is where it
4310 // was being used previously.
4311 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4312 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4313 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4314 else
4315 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4316 }
4317
John McCall24fc0de2011-07-06 00:26:06 +00004318 // Allow the user to enable full exceptions code emission.
4319 // We define off for Objective-CC, on for Objective-C++.
4320 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4321 options::OPT_fno_objc_arc_exceptions,
4322 /*default*/ types::isCXX(InputType)))
4323 CmdArgs.push_back("-fobjc-arc-exceptions");
4324 }
4325
4326 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4327 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004328 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004329 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004330
John McCall24fc0de2011-07-06 00:26:06 +00004331 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4332 // takes precedence.
4333 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4334 if (!GCArg)
4335 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4336 if (GCArg) {
4337 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004338 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004339 << GCArg->getAsString(Args);
4340 } else if (getToolChain().SupportsObjCGC()) {
4341 GCArg->render(Args, CmdArgs);
4342 } else {
4343 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004344 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004345 << GCArg->getAsString(Args);
4346 }
4347 }
4348
Bob Wilsonb111ec92015-03-02 19:01:14 +00004349 if (Args.hasFlag(options::OPT_fapplication_extension,
4350 options::OPT_fno_application_extension, false))
4351 CmdArgs.push_back("-fapplication-extension");
4352
Reid Klecknerc542d372014-06-27 17:02:02 +00004353 // Handle GCC-style exception args.
4354 if (!C.getDriver().IsCLMode())
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004355 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext,
Reid Klecknerc542d372014-06-27 17:02:02 +00004356 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004357
4358 if (getToolChain().UseSjLjExceptions())
4359 CmdArgs.push_back("-fsjlj-exceptions");
4360
4361 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004362 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4363 options::OPT_fno_assume_sane_operator_new))
4364 CmdArgs.push_back("-fno-assume-sane-operator-new");
4365
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004366 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4367 // most platforms.
4368 if (Args.hasFlag(options::OPT_fsized_deallocation,
4369 options::OPT_fno_sized_deallocation, false))
4370 CmdArgs.push_back("-fsized-deallocation");
4371
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004372 // -fconstant-cfstrings is default, and may be subject to argument translation
4373 // on Darwin.
4374 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4375 options::OPT_fno_constant_cfstrings) ||
4376 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4377 options::OPT_mno_constant_cfstrings))
4378 CmdArgs.push_back("-fno-constant-cfstrings");
4379
John Thompsoned4e2952009-11-05 20:14:16 +00004380 // -fshort-wchar default varies depending on platform; only
4381 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004382 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4383 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004384 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004385
Hans Wennborg28c96312013-07-31 23:39:13 +00004386 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004387 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004388 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004389 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004390 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004391
Daniel Dunbar096ed292011-10-05 21:04:55 +00004392 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4393 // -fno-pack-struct doesn't apply to -fpack-struct=.
4394 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004395 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004396 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004397 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004398 } else if (Args.hasFlag(options::OPT_fpack_struct,
4399 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004400 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004401 }
4402
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004403 // Handle -fmax-type-align=N and -fno-type-align
4404 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4405 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4406 if (!SkipMaxTypeAlign) {
4407 std::string MaxTypeAlignStr = "-fmax-type-align=";
4408 MaxTypeAlignStr += A->getValue();
4409 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4410 }
4411 } else if (getToolChain().getTriple().isOSDarwin()) {
4412 if (!SkipMaxTypeAlign) {
4413 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4414 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4415 }
4416 }
4417
Robert Lytton0e076492013-08-13 09:43:10 +00004418 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004419 if (!Args.hasArg(options::OPT_fcommon))
4420 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004421 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004422 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004423
Daniel Dunbard18049a2009-04-07 21:16:11 +00004424 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004425 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004426 CmdArgs.push_back("-fno-common");
4427
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004428 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004429 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004430 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004431 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004432 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004433 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4434
Daniel Dunbar6358d682010-10-15 22:30:42 +00004435 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4436 if (!Args.hasFlag(options::OPT_ffor_scope,
4437 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004438 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004439 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4440
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004441 // -finput_charset=UTF-8 is default. Reject others
4442 if (Arg *inputCharset = Args.getLastArg(
4443 options::OPT_finput_charset_EQ)) {
4444 StringRef value = inputCharset->getValue();
4445 if (value != "UTF-8")
4446 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4447 }
4448
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004449 // -fexec_charset=UTF-8 is default. Reject others
4450 if (Arg *execCharset = Args.getLastArg(
4451 options::OPT_fexec_charset_EQ)) {
4452 StringRef value = execCharset->getValue();
4453 if (value != "UTF-8")
4454 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4455 }
4456
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004457 // -fcaret-diagnostics is default.
4458 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4459 options::OPT_fno_caret_diagnostics, true))
4460 CmdArgs.push_back("-fno-caret-diagnostics");
4461
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004462 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004463 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004464 options::OPT_fno_diagnostics_fixit_info))
4465 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004466
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004467 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004468 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004469 options::OPT_fno_diagnostics_show_option))
4470 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004471
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004472 if (const Arg *A =
4473 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4474 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004475 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004476 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004477
Douglas Gregor643c9222011-05-21 17:07:29 +00004478 if (const Arg *A =
4479 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4480 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004481 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004482 }
4483
Chandler Carruthb6766f02011-03-27 01:50:55 +00004484 if (Arg *A = Args.getLastArg(
4485 options::OPT_fdiagnostics_show_note_include_stack,
4486 options::OPT_fno_diagnostics_show_note_include_stack)) {
4487 if (A->getOption().matches(
4488 options::OPT_fdiagnostics_show_note_include_stack))
4489 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4490 else
4491 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4492 }
4493
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004494 // Color diagnostics are the default, unless the terminal doesn't support
4495 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004496 // Support both clang's -f[no-]color-diagnostics and gcc's
4497 // -f[no-]diagnostics-colors[=never|always|auto].
4498 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004499 for (const auto &Arg : Args) {
4500 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004501 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4502 !O.matches(options::OPT_fdiagnostics_color) &&
4503 !O.matches(options::OPT_fno_color_diagnostics) &&
4504 !O.matches(options::OPT_fno_diagnostics_color) &&
4505 !O.matches(options::OPT_fdiagnostics_color_EQ))
4506 continue;
4507
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004508 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004509 if (O.matches(options::OPT_fcolor_diagnostics) ||
4510 O.matches(options::OPT_fdiagnostics_color)) {
4511 ShowColors = Colors_On;
4512 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4513 O.matches(options::OPT_fno_diagnostics_color)) {
4514 ShowColors = Colors_Off;
4515 } else {
4516 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004517 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004518 if (value == "always")
4519 ShowColors = Colors_On;
4520 else if (value == "never")
4521 ShowColors = Colors_Off;
4522 else if (value == "auto")
4523 ShowColors = Colors_Auto;
4524 else
4525 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4526 << ("-fdiagnostics-color=" + value).str();
4527 }
4528 }
4529 if (ShowColors == Colors_On ||
4530 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004531 CmdArgs.push_back("-fcolor-diagnostics");
4532
Nico Rieck7857d462013-09-11 00:38:02 +00004533 if (Args.hasArg(options::OPT_fansi_escape_codes))
4534 CmdArgs.push_back("-fansi-escape-codes");
4535
Daniel Dunbardb097022009-06-08 21:13:54 +00004536 if (!Args.hasFlag(options::OPT_fshow_source_location,
4537 options::OPT_fno_show_source_location))
4538 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004539
Douglas Gregor643c9222011-05-21 17:07:29 +00004540 if (!Args.hasFlag(options::OPT_fshow_column,
4541 options::OPT_fno_show_column,
4542 true))
4543 CmdArgs.push_back("-fno-show-column");
4544
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004545 if (!Args.hasFlag(options::OPT_fspell_checking,
4546 options::OPT_fno_spell_checking))
4547 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004548
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004549
Chad Rosierc8e56e82012-12-05 21:08:21 +00004550 // -fno-asm-blocks is default.
4551 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4552 false))
4553 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004554
Steven Wucb0d13f2015-01-16 23:05:28 +00004555 // -fgnu-inline-asm is default.
4556 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4557 options::OPT_fno_gnu_inline_asm, true))
4558 CmdArgs.push_back("-fno-gnu-inline-asm");
4559
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004560 // Enable vectorization per default according to the optimization level
4561 // selected. For optimization levels that want vectorization we use the alias
4562 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004563 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004564 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004565 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004566 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004567 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004568 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004569
Chad Rosier136d67d2014-04-28 19:30:57 +00004570 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004571 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4572 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004573 options::OPT_fslp_vectorize;
4574 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004575 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004576 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004577
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004578 // -fno-slp-vectorize-aggressive is default.
4579 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004580 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004581 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004582
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004583 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4584 A->render(Args, CmdArgs);
4585
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004586 // -fdollars-in-identifiers default varies depending on platform and
4587 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004588 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004589 options::OPT_fno_dollars_in_identifiers)) {
4590 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004591 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004592 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004593 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004594 }
4595
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004596 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4597 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004598 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004599 options::OPT_fno_unit_at_a_time)) {
4600 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004601 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004602 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004603
Eli Friedman055c9702011-11-02 01:53:16 +00004604 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4605 options::OPT_fno_apple_pragma_pack, false))
4606 CmdArgs.push_back("-fapple-pragma-pack");
4607
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004608 // le32-specific flags:
4609 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4610 // by default.
4611 if (getToolChain().getArch() == llvm::Triple::le32) {
4612 CmdArgs.push_back("-fno-math-builtin");
4613 }
4614
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004615 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004616 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004617 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004618#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004619 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004620 (getToolChain().getArch() == llvm::Triple::arm ||
4621 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004622 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4623 CmdArgs.push_back("-fno-builtin-strcat");
4624 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4625 CmdArgs.push_back("-fno-builtin-strcpy");
4626 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004627#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004628
Justin Bognera88f0122014-06-20 22:59:50 +00004629 // Enable rewrite includes if the user's asked for it or if we're generating
4630 // diagnostics.
4631 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4632 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004633 if (Args.hasFlag(options::OPT_frewrite_includes,
4634 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004635 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004636 CmdArgs.push_back("-frewrite-includes");
4637
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004638 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004639 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004640 options::OPT_traditional_cpp)) {
4641 if (isa<PreprocessJobAction>(JA))
4642 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004643 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004644 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004645 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004646
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004647 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004648 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004649
4650 // Handle serialized diagnostics.
4651 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4652 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004653 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004654 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004655
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004656 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4657 CmdArgs.push_back("-fretain-comments-from-system-headers");
4658
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004659 // Forward -fcomment-block-commands to -cc1.
4660 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004661 // Forward -fparse-all-comments to -cc1.
4662 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004663
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004664 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4665 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004666 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004667 bool OptDisabled = false;
Sean Silva14facf32015-06-09 01:57:17 +00004668 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
4669 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004670
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004671 // We translate this by hand to the -cc1 argument, since nightly test uses
4672 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00004673 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004674 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004675 OptDisabled = true;
4676 } else
Sean Silva14facf32015-06-09 01:57:17 +00004677 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004678 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004679
Bob Wilson23a55f12014-12-21 07:00:00 +00004680 // With -save-temps, we want to save the unoptimized bitcode output from the
4681 // CompileJobAction, so disable optimizations if they are not already
4682 // disabled.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00004683 if (C.getDriver().isSaveTempsEnabled() && !OptDisabled &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004684 isa<CompileJobAction>(JA))
4685 CmdArgs.push_back("-disable-llvm-optzns");
4686
Daniel Dunbard67a3222009-03-30 06:36:42 +00004687 if (Output.getType() == types::TY_Dependencies) {
4688 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004689 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004690 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004691 CmdArgs.push_back(Output.getFilename());
4692 } else {
4693 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004694 }
4695
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004696 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004697 addDashXForInput(Args, II, CmdArgs);
4698
Daniel Dunbarb440f562010-08-02 02:38:21 +00004699 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004700 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004701 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004702 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004703 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004704
Chris Lattnere9d7d782009-11-03 19:50:27 +00004705 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4706
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004707 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004708
4709 // Optionally embed the -cc1 level arguments into the debug info, for build
4710 // analysis.
4711 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004712 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004713 for (const auto &Arg : Args)
4714 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004715
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004716 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004717 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004718 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004719 SmallString<128> EscapedArg;
4720 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004721 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004722 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004723 }
4724 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00004725 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004726 }
4727
Eric Christopherd3804002013-02-22 20:12:52 +00004728 // Add the split debug info name to the command lines here so we
4729 // can propagate it to the backend.
4730 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004731 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004732 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4733 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004734 const char *SplitDwarfOut;
4735 if (SplitDwarf) {
4736 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00004737 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00004738 CmdArgs.push_back(SplitDwarfOut);
4739 }
4740
4741 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004742 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004743 Output.getType() == types::TY_Object &&
4744 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004745 auto CLCommand =
4746 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4747 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4748 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004749 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004750 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004751 }
4752
Daniel Dunbar17731772009-03-23 19:03:36 +00004753
Eric Christopherf1545832013-02-22 23:50:16 +00004754 // Handle the debug info splitting at object creation time if we're
4755 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004756 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004757 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004758 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004759
Roman Divacky178e01602011-02-10 16:52:03 +00004760 if (Arg *A = Args.getLastArg(options::OPT_pg))
4761 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004762 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004763 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004764
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004765 // Claim some arguments which clang supports automatically.
4766
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004767 // -fpch-preprocess is used with gcc to add a special marker in the output to
4768 // include the PCH file. Clang's PTH solution is completely transparent, so we
4769 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004770 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004771
Daniel Dunbar17731772009-03-23 19:03:36 +00004772 // Claim some arguments which clang doesn't support, but we don't
4773 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004774 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4775 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004776
Rafael Espindolab0092d72013-09-04 19:37:35 +00004777 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004778 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004779}
4780
John McCall5fb5df92012-06-20 06:18:46 +00004781/// Add options related to the Objective-C runtime/ABI.
4782///
4783/// Returns true if the runtime is non-fragile.
4784ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4785 ArgStringList &cmdArgs,
4786 RewriteKind rewriteKind) const {
4787 // Look for the controlling runtime option.
4788 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4789 options::OPT_fgnu_runtime,
4790 options::OPT_fobjc_runtime_EQ);
4791
4792 // Just forward -fobjc-runtime= to the frontend. This supercedes
4793 // options about fragility.
4794 if (runtimeArg &&
4795 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4796 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004797 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004798 if (runtime.tryParse(value)) {
4799 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4800 << value;
4801 }
4802
4803 runtimeArg->render(args, cmdArgs);
4804 return runtime;
4805 }
4806
4807 // Otherwise, we'll need the ABI "version". Version numbers are
4808 // slightly confusing for historical reasons:
4809 // 1 - Traditional "fragile" ABI
4810 // 2 - Non-fragile ABI, version 1
4811 // 3 - Non-fragile ABI, version 2
4812 unsigned objcABIVersion = 1;
4813 // If -fobjc-abi-version= is present, use that to set the version.
4814 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004815 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004816 if (value == "1")
4817 objcABIVersion = 1;
4818 else if (value == "2")
4819 objcABIVersion = 2;
4820 else if (value == "3")
4821 objcABIVersion = 3;
4822 else
4823 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4824 << value;
4825 } else {
4826 // Otherwise, determine if we are using the non-fragile ABI.
4827 bool nonFragileABIIsDefault =
4828 (rewriteKind == RK_NonFragile ||
4829 (rewriteKind == RK_None &&
4830 getToolChain().IsObjCNonFragileABIDefault()));
4831 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4832 options::OPT_fno_objc_nonfragile_abi,
4833 nonFragileABIIsDefault)) {
4834 // Determine the non-fragile ABI version to use.
4835#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4836 unsigned nonFragileABIVersion = 1;
4837#else
4838 unsigned nonFragileABIVersion = 2;
4839#endif
4840
4841 if (Arg *abiArg = args.getLastArg(
4842 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004843 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004844 if (value == "1")
4845 nonFragileABIVersion = 1;
4846 else if (value == "2")
4847 nonFragileABIVersion = 2;
4848 else
4849 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4850 << value;
4851 }
4852
4853 objcABIVersion = 1 + nonFragileABIVersion;
4854 } else {
4855 objcABIVersion = 1;
4856 }
4857 }
4858
4859 // We don't actually care about the ABI version other than whether
4860 // it's non-fragile.
4861 bool isNonFragile = objcABIVersion != 1;
4862
4863 // If we have no runtime argument, ask the toolchain for its default runtime.
4864 // However, the rewriter only really supports the Mac runtime, so assume that.
4865 ObjCRuntime runtime;
4866 if (!runtimeArg) {
4867 switch (rewriteKind) {
4868 case RK_None:
4869 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4870 break;
4871 case RK_Fragile:
4872 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4873 break;
4874 case RK_NonFragile:
4875 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4876 break;
4877 }
4878
4879 // -fnext-runtime
4880 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4881 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004882 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004883 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4884
4885 // Otherwise, build for a generic macosx port.
4886 } else {
4887 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4888 }
4889
4890 // -fgnu-runtime
4891 } else {
4892 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004893 // Legacy behaviour is to target the gnustep runtime if we are i
4894 // non-fragile mode or the GCC runtime in fragile mode.
4895 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004896 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004897 else
4898 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004899 }
4900
4901 cmdArgs.push_back(args.MakeArgString(
4902 "-fobjc-runtime=" + runtime.getAsString()));
4903 return runtime;
4904}
4905
Reid Klecknerc542d372014-06-27 17:02:02 +00004906static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4907 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4908 I += HaveDash;
4909 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004910}
Reid Klecknerc542d372014-06-27 17:02:02 +00004911
4912struct EHFlags {
4913 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4914 bool Synch;
4915 bool Asynch;
4916 bool NoExceptC;
4917};
4918
4919/// /EH controls whether to run destructor cleanups when exceptions are
4920/// thrown. There are three modifiers:
4921/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4922/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4923/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4924/// - c: Assume that extern "C" functions are implicitly noexcept. This
4925/// modifier is an optimization, so we ignore it for now.
4926/// The default is /EHs-c-, meaning cleanups are disabled.
4927static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4928 EHFlags EH;
4929 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4930 for (auto EHVal : EHArgs) {
4931 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4932 switch (EHVal[I]) {
4933 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4934 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4935 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4936 default: break;
4937 }
4938 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4939 break;
4940 }
4941 }
4942 return EH;
4943}
4944
Hans Wennborg75958c42013-08-08 00:17:41 +00004945void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4946 unsigned RTOptionID = options::OPT__SLASH_MT;
4947
Hans Wennborgf1a74252013-09-10 20:18:04 +00004948 if (Args.hasArg(options::OPT__SLASH_LDd))
4949 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4950 // but defining _DEBUG is sticky.
4951 RTOptionID = options::OPT__SLASH_MTd;
4952
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004953 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004954 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004955
Hans Wennborg75958c42013-08-08 00:17:41 +00004956 switch(RTOptionID) {
4957 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004958 if (Args.hasArg(options::OPT__SLASH_LDd))
4959 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004960 CmdArgs.push_back("-D_MT");
4961 CmdArgs.push_back("-D_DLL");
4962 CmdArgs.push_back("--dependent-lib=msvcrt");
4963 break;
4964 case options::OPT__SLASH_MDd:
4965 CmdArgs.push_back("-D_DEBUG");
4966 CmdArgs.push_back("-D_MT");
4967 CmdArgs.push_back("-D_DLL");
4968 CmdArgs.push_back("--dependent-lib=msvcrtd");
4969 break;
4970 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004971 if (Args.hasArg(options::OPT__SLASH_LDd))
4972 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004973 CmdArgs.push_back("-D_MT");
4974 CmdArgs.push_back("--dependent-lib=libcmt");
4975 break;
4976 case options::OPT__SLASH_MTd:
4977 CmdArgs.push_back("-D_DEBUG");
4978 CmdArgs.push_back("-D_MT");
4979 CmdArgs.push_back("--dependent-lib=libcmtd");
4980 break;
4981 default:
4982 llvm_unreachable("Unexpected option ID.");
4983 }
4984
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004985 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4986 // users want. The /Za flag to cl.exe turns this off, but it's not
4987 // implemented in clang.
4988 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004989
Hans Wennborg8858a032014-07-21 23:42:07 +00004990 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4991 // would produce interleaved output, so ignore /showIncludes in such cases.
4992 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4993 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4994 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004995
David Majnemerf6072342014-07-01 22:24:56 +00004996 // This controls whether or not we emit RTTI data for polymorphic types.
4997 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4998 /*default=*/false))
4999 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00005000
Reid Klecknerc542d372014-06-27 17:02:02 +00005001 const Driver &D = getToolChain().getDriver();
5002 EHFlags EH = parseClangCLEHFlags(D, Args);
5003 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005004 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00005005 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005006 CmdArgs.push_back("-fexceptions");
5007 }
Reid Klecknerc542d372014-06-27 17:02:02 +00005008
Hans Wennborge50cec32014-06-13 20:59:54 +00005009 // /EP should expand to -E -P.
5010 if (Args.hasArg(options::OPT__SLASH_EP)) {
5011 CmdArgs.push_back("-E");
5012 CmdArgs.push_back("-P");
5013 }
5014
David Majnemera5b195a2015-02-14 01:35:12 +00005015 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005016 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5017 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00005018 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5019 else
5020 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5021
5022 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5023 VolatileOptionID = A->getOption().getID();
5024
5025 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5026 CmdArgs.push_back("-fms-volatile");
5027
David Majnemer86c318f2014-02-11 21:05:00 +00005028 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5029 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5030 if (MostGeneralArg && BestCaseArg)
5031 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5032 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5033
5034 if (MostGeneralArg) {
5035 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5036 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5037 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5038
5039 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5040 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5041 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5042 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5043 << FirstConflict->getAsString(Args)
5044 << SecondConflict->getAsString(Args);
5045
5046 if (SingleArg)
5047 CmdArgs.push_back("-fms-memptr-rep=single");
5048 else if (MultipleArg)
5049 CmdArgs.push_back("-fms-memptr-rep=multiple");
5050 else
5051 CmdArgs.push_back("-fms-memptr-rep=virtual");
5052 }
5053
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00005054 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5055 A->render(Args, CmdArgs);
5056
Hans Wennborg81f74482013-09-10 01:07:07 +00005057 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5058 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00005059 if (Args.hasArg(options::OPT__SLASH_fallback))
5060 CmdArgs.push_back("msvc-fallback");
5061 else
5062 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00005063 }
Hans Wennborg75958c42013-08-08 00:17:41 +00005064}
5065
Hans Wennborg1da044a2014-06-26 19:59:02 +00005066visualstudio::Compile *Clang::getCLFallback() const {
5067 if (!CLFallback)
5068 CLFallback.reset(new visualstudio::Compile(getToolChain()));
5069 return CLFallback.get();
5070}
5071
Daniel Sanders7f933f42015-01-30 17:35:23 +00005072void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5073 ArgStringList &CmdArgs) const {
5074 StringRef CPUName;
5075 StringRef ABIName;
5076 const llvm::Triple &Triple = getToolChain().getTriple();
5077 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5078
5079 CmdArgs.push_back("-target-abi");
5080 CmdArgs.push_back(ABIName.data());
5081}
5082
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005083void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005084 const InputInfo &Output,
5085 const InputInfoList &Inputs,
5086 const ArgList &Args,
5087 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005088 ArgStringList CmdArgs;
5089
5090 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5091 const InputInfo &Input = Inputs[0];
5092
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005093 // Don't warn about "clang -w -c foo.s"
5094 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005095 // and "clang -emit-llvm -c foo.s"
5096 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005097
Rafael Espindola577637a2015-01-03 00:06:04 +00005098 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005099
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005100 // Invoke ourselves in -cc1as mode.
5101 //
5102 // FIXME: Implement custom jobs for internal actions.
5103 CmdArgs.push_back("-cc1as");
5104
5105 // Add the "effective" target triple.
5106 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00005107 std::string TripleStr =
5108 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005109 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5110
5111 // Set the output mode, we currently only expect to be used as a real
5112 // assembler.
5113 CmdArgs.push_back("-filetype");
5114 CmdArgs.push_back("obj");
5115
Eric Christopher45f2e712012-12-18 00:31:10 +00005116 // Set the main file name, so that debug info works even with
5117 // -save-temps or preprocessed assembly.
5118 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00005119 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00005120
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005121 // Add the target cpu
John Brawn94fd9632015-05-21 12:19:49 +00005122 const llvm::Triple Triple(TripleStr);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005123 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005124 if (!CPU.empty()) {
5125 CmdArgs.push_back("-target-cpu");
5126 CmdArgs.push_back(Args.MakeArgString(CPU));
5127 }
5128
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005129 // Add the target features
5130 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00005131 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005132
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005133 // Ignore explicit -force_cpusubtype_ALL option.
5134 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005135
Eric Christopherfc3ee562012-01-10 00:38:01 +00005136 // Determine the original source input.
5137 const Action *SourceAction = &JA;
5138 while (SourceAction->getKind() != Action::InputClass) {
5139 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5140 SourceAction = SourceAction->getInputs()[0];
5141 }
5142
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005143 // Forward -g and handle debug info related flags, assuming we are dealing
5144 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005145 if (SourceAction->getType() == types::TY_Asm ||
5146 SourceAction->getType() == types::TY_PP_Asm) {
5147 Args.ClaimAllArgs(options::OPT_g_Group);
5148 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5149 if (!A->getOption().matches(options::OPT_g0))
5150 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005151
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005152 if (Args.hasArg(options::OPT_gdwarf_2))
5153 CmdArgs.push_back("-gdwarf-2");
5154 if (Args.hasArg(options::OPT_gdwarf_3))
5155 CmdArgs.push_back("-gdwarf-3");
5156 if (Args.hasArg(options::OPT_gdwarf_4))
5157 CmdArgs.push_back("-gdwarf-4");
5158
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005159 // Add the -fdebug-compilation-dir flag if needed.
5160 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005161
5162 // Set the AT_producer to the clang version when using the integrated
5163 // assembler on assembly source files.
5164 CmdArgs.push_back("-dwarf-debug-producer");
5165 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00005166 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005167
5168 // Optionally embed the -cc1as level arguments into the debug info, for build
5169 // analysis.
5170 if (getToolChain().UseDwarfDebugFlags()) {
5171 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005172 for (const auto &Arg : Args)
5173 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005174
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005175 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005176 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5177 Flags += Exec;
5178 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005179 SmallString<128> EscapedArg;
5180 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005181 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005182 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005183 }
5184 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005185 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005186 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005187
5188 // FIXME: Add -static support, once we have it.
5189
Daniel Sanders7f933f42015-01-30 17:35:23 +00005190 // Add target specific flags.
5191 switch(getToolChain().getArch()) {
5192 default:
5193 break;
5194
5195 case llvm::Triple::mips:
5196 case llvm::Triple::mipsel:
5197 case llvm::Triple::mips64:
5198 case llvm::Triple::mips64el:
5199 AddMIPSTargetArgs(Args, CmdArgs);
5200 break;
5201 }
5202
David Blaikie372d9502014-01-17 03:17:40 +00005203 // Consume all the warning flags. Usually this would be handled more
5204 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5205 // doesn't handle that so rather than warning about unused flags that are
5206 // actually used, we'll lie by omission instead.
5207 // FIXME: Stop lying and consume only the appropriate driver flags
Sean Silva14facf32015-06-09 01:57:17 +00005208 for (const Arg *A : Args.filtered(options::OPT_W_Group))
5209 A->claim();
David Blaikie372d9502014-01-17 03:17:40 +00005210
David Blaikie9260ed62013-07-25 21:19:01 +00005211 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5212 getToolChain().getDriver());
5213
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005214 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005215
5216 assert(Output.isFilename() && "Unexpected lipo output.");
5217 CmdArgs.push_back("-o");
5218 CmdArgs.push_back(Output.getFilename());
5219
Daniel Dunbarb440f562010-08-02 02:38:21 +00005220 assert(Input.isFilename() && "Invalid input.");
5221 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005222
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005223 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00005224 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00005225
5226 // Handle the debug info splitting at object creation time if we're
5227 // creating an object.
5228 // TODO: Currently only works on linux with newer objcopy.
5229 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005230 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005231 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00005232 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005233}
5234
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005235void GnuTool::anchor() {}
5236
Daniel Dunbara3246a02009-03-18 08:07:30 +00005237void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005238 const InputInfo &Output,
5239 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005240 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005241 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005242 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005243 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005244
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005245 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005246 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005247 // Don't forward any -g arguments to assembly steps.
5248 if (isa<AssembleJobAction>(JA) &&
5249 A->getOption().matches(options::OPT_g_Group))
5250 continue;
5251
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005252 // Don't forward any -W arguments to assembly and link steps.
5253 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5254 A->getOption().matches(options::OPT_W_Group))
5255 continue;
5256
Daniel Dunbar2da02722009-03-19 07:55:12 +00005257 // It is unfortunate that we have to claim here, as this means
5258 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005259 // platforms using a generic gcc, even if we are just using gcc
5260 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005261 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005262 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005263 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005264 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005265
Daniel Dunbar4e295052010-01-25 22:35:08 +00005266 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005267
5268 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005269 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005270 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005271 CmdArgs.push_back(
5272 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005273 }
5274
Daniel Dunbar5716d872009-05-02 21:41:52 +00005275 // Try to force gcc to match the tool chain we want, if we recognize
5276 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005277 //
5278 // FIXME: The triple class should directly provide the information we want
5279 // here.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005280 const llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005281 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005282 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00005283 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5284 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005285 CmdArgs.push_back("-m64");
5286
Daniel Dunbarb440f562010-08-02 02:38:21 +00005287 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005288 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005289 CmdArgs.push_back(Output.getFilename());
5290 } else {
5291 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005292 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005293 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005294
Tony Linthicum76329bf2011-12-12 21:14:55 +00005295 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5296 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005297
5298 // Only pass -x if gcc will understand it; otherwise hope gcc
5299 // understands the suffix correctly. The main use case this would go
5300 // wrong in is for linker inputs if they happened to have an odd
5301 // suffix; really the only way to get this to happen is a command
5302 // like '-x foobar a.c' which will treat a.c like a linker input.
5303 //
5304 // FIXME: For the linker case specifically, can we safely convert
5305 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005306 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005307 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005308 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5309 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005310 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005311 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005312 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005313 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005314 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005315 else if (II.getType() == types::TY_ModuleFile)
5316 D.Diag(diag::err_drv_no_module_support)
5317 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005318
Daniel Dunbara3246a02009-03-18 08:07:30 +00005319 if (types::canTypeBeUserSpecified(II.getType())) {
5320 CmdArgs.push_back("-x");
5321 CmdArgs.push_back(types::getTypeName(II.getType()));
5322 }
5323
Daniel Dunbarb440f562010-08-02 02:38:21 +00005324 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005325 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005326 else {
5327 const Arg &A = II.getInputArg();
5328
5329 // Reverse translate some rewritten options.
5330 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5331 CmdArgs.push_back("-lstdc++");
5332 continue;
5333 }
5334
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005335 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005336 A.render(Args, CmdArgs);
5337 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005338 }
5339
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005340 const std::string customGCCName = D.getCCCGenericGCCName();
5341 const char *GCCName;
5342 if (!customGCCName.empty())
5343 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005344 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005345 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005346 } else
5347 GCCName = "gcc";
5348
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005349 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005350 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005351 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005352}
5353
Daniel Dunbar4e295052010-01-25 22:35:08 +00005354void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5355 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005356 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005357}
5358
Daniel Dunbar4e295052010-01-25 22:35:08 +00005359void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5360 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005361 const Driver &D = getToolChain().getDriver();
5362
Eric Christophercc7ff502015-01-29 00:56:17 +00005363 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005364 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005365 case types::TY_LLVM_IR:
5366 case types::TY_LTO_IR:
5367 case types::TY_LLVM_BC:
5368 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005369 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005370 break;
5371 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005372 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005373 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005374 case types::TY_Nothing:
5375 CmdArgs.push_back("-fsyntax-only");
5376 break;
5377 default:
5378 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005379 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005380}
5381
Daniel Dunbar4e295052010-01-25 22:35:08 +00005382void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5383 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005384 // The types are (hopefully) good enough.
5385}
5386
Tony Linthicum76329bf2011-12-12 21:14:55 +00005387// Hexagon tools start.
5388void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5389 ArgStringList &CmdArgs) const {
5390
5391}
5392void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5393 const InputInfo &Output,
5394 const InputInfoList &Inputs,
5395 const ArgList &Args,
5396 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005397 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005398
5399 const Driver &D = getToolChain().getDriver();
5400 ArgStringList CmdArgs;
5401
5402 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005403 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005404 CmdArgs.push_back(Args.MakeArgString(MarchString));
5405
5406 RenderExtraToolArgs(JA, CmdArgs);
5407
5408 if (Output.isFilename()) {
5409 CmdArgs.push_back("-o");
5410 CmdArgs.push_back(Output.getFilename());
5411 } else {
5412 assert(Output.isNothing() && "Unexpected output");
5413 CmdArgs.push_back("-fsyntax-only");
5414 }
5415
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005416 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args))
5417 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005418
Matthew Curtise5df3812012-12-07 17:23:04 +00005419 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5420 options::OPT_Xassembler);
5421
Tony Linthicum76329bf2011-12-12 21:14:55 +00005422 // Only pass -x if gcc will understand it; otherwise hope gcc
5423 // understands the suffix correctly. The main use case this would go
5424 // wrong in is for linker inputs if they happened to have an odd
5425 // suffix; really the only way to get this to happen is a command
5426 // like '-x foobar a.c' which will treat a.c like a linker input.
5427 //
5428 // FIXME: For the linker case specifically, can we safely convert
5429 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005430 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005431 // Don't try to pass LLVM or AST inputs to a generic gcc.
5432 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5433 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5434 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5435 << getToolChain().getTripleString();
5436 else if (II.getType() == types::TY_AST)
5437 D.Diag(clang::diag::err_drv_no_ast_support)
5438 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005439 else if (II.getType() == types::TY_ModuleFile)
5440 D.Diag(diag::err_drv_no_module_support)
5441 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005442
5443 if (II.isFilename())
5444 CmdArgs.push_back(II.getFilename());
5445 else
5446 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5447 II.getInputArg().render(Args, CmdArgs);
5448 }
5449
5450 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005451 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005452 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005453}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005454
Tony Linthicum76329bf2011-12-12 21:14:55 +00005455void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5456 ArgStringList &CmdArgs) const {
5457 // The types are (hopefully) good enough.
5458}
5459
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005460static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
5461 const toolchains::Hexagon_TC& ToolChain,
5462 const InputInfo &Output,
5463 const InputInfoList &Inputs,
5464 const ArgList &Args,
5465 ArgStringList &CmdArgs,
5466 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005467
Matthew Curtise689b052012-12-06 15:46:07 +00005468 const Driver &D = ToolChain.getDriver();
5469
Tony Linthicum76329bf2011-12-12 21:14:55 +00005470
Matthew Curtise689b052012-12-06 15:46:07 +00005471 //----------------------------------------------------------------------------
5472 //
5473 //----------------------------------------------------------------------------
5474 bool hasStaticArg = Args.hasArg(options::OPT_static);
5475 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005476 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005477 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5478 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5479 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005480 bool useG0 = false;
Matthew Curtise689b052012-12-06 15:46:07 +00005481 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005482
Matthew Curtise689b052012-12-06 15:46:07 +00005483 //----------------------------------------------------------------------------
5484 // Silence warnings for various options
5485 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005486
Matthew Curtise689b052012-12-06 15:46:07 +00005487 Args.ClaimAllArgs(options::OPT_g_Group);
5488 Args.ClaimAllArgs(options::OPT_emit_llvm);
5489 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5490 // handled somewhere else.
5491 Args.ClaimAllArgs(options::OPT_static_libgcc);
5492
5493 //----------------------------------------------------------------------------
5494 //
5495 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005496 for (const auto &Opt : ToolChain.ExtraOpts)
5497 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005498
Matthew Curtisf10a5952012-12-06 14:16:43 +00005499 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5500 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005501
Matthew Curtise689b052012-12-06 15:46:07 +00005502 if (buildingLib) {
5503 CmdArgs.push_back("-shared");
5504 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5505 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005506 }
5507
Matthew Curtise689b052012-12-06 15:46:07 +00005508 if (hasStaticArg)
5509 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005510
Matthew Curtise8f80a12012-12-06 17:49:03 +00005511 if (buildPIE && !buildingLib)
5512 CmdArgs.push_back("-pie");
5513
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005514 if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
5515 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
5516 useG0 = toolchains::Hexagon_TC::UsesG0(v);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005517 }
5518
Matthew Curtise689b052012-12-06 15:46:07 +00005519 //----------------------------------------------------------------------------
5520 //
5521 //----------------------------------------------------------------------------
5522 CmdArgs.push_back("-o");
5523 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005524
Matthew Curtise689b052012-12-06 15:46:07 +00005525 const std::string MarchSuffix = "/" + MarchString;
5526 const std::string G0Suffix = "/G0";
5527 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005528 const std::string RootDir =
5529 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005530 const std::string StartFilesDir = RootDir
5531 + "hexagon/lib"
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005532 + (useG0 ? MarchG0Suffix : MarchSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00005533
5534 //----------------------------------------------------------------------------
5535 // moslib
5536 //----------------------------------------------------------------------------
5537 std::vector<std::string> oslibs;
5538 bool hasStandalone= false;
5539
Sean Silva14facf32015-06-09 01:57:17 +00005540 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5541 A->claim();
5542 oslibs.emplace_back(A->getValue());
Matthew Curtise689b052012-12-06 15:46:07 +00005543 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005544 }
Matthew Curtise689b052012-12-06 15:46:07 +00005545 if (oslibs.empty()) {
5546 oslibs.push_back("standalone");
5547 hasStandalone = true;
5548 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005549
Matthew Curtise689b052012-12-06 15:46:07 +00005550 //----------------------------------------------------------------------------
5551 // Start Files
5552 //----------------------------------------------------------------------------
5553 if (incStdLib && incStartFiles) {
5554
5555 if (!buildingLib) {
5556 if (hasStandalone) {
5557 CmdArgs.push_back(
5558 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5559 }
5560 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5561 }
5562 std::string initObj = useShared ? "/initS.o" : "/init.o";
5563 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5564 }
5565
5566 //----------------------------------------------------------------------------
5567 // Library Search Paths
5568 //----------------------------------------------------------------------------
5569 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005570 for (const auto &LibPath : LibPaths)
5571 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005572
5573 //----------------------------------------------------------------------------
5574 //
5575 //----------------------------------------------------------------------------
5576 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5577 Args.AddAllArgs(CmdArgs, options::OPT_e);
5578 Args.AddAllArgs(CmdArgs, options::OPT_s);
5579 Args.AddAllArgs(CmdArgs, options::OPT_t);
5580 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5581
5582 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5583
5584 //----------------------------------------------------------------------------
5585 // Libraries
5586 //----------------------------------------------------------------------------
5587 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005588 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005589 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5590 CmdArgs.push_back("-lm");
5591 }
5592
5593 CmdArgs.push_back("--start-group");
5594
5595 if (!buildingLib) {
5596 for(std::vector<std::string>::iterator i = oslibs.begin(),
5597 e = oslibs.end(); i != e; ++i)
5598 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5599 CmdArgs.push_back("-lc");
5600 }
5601 CmdArgs.push_back("-lgcc");
5602
5603 CmdArgs.push_back("--end-group");
5604 }
5605
5606 //----------------------------------------------------------------------------
5607 // End files
5608 //----------------------------------------------------------------------------
5609 if (incStdLib && incStartFiles) {
5610 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5611 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5612 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005613}
5614
5615void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5616 const InputInfo &Output,
5617 const InputInfoList &Inputs,
5618 const ArgList &Args,
5619 const char *LinkingOutput) const {
5620
5621 const toolchains::Hexagon_TC& ToolChain =
5622 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5623
5624 ArgStringList CmdArgs;
5625 constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
5626 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00005627
5628 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005629 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5630 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005631}
5632// Hexagon tools end.
5633
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005634const StringRef arm::getARMArch(const ArgList &Args,
5635 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005636 StringRef MArch;
5637 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5638 // Otherwise, if we have -march= choose the base CPU for that arch.
5639 MArch = A->getValue();
5640 } else {
5641 // Otherwise, use the Arch from the triple.
5642 MArch = Triple.getArchName();
5643 }
John Brawn94fd9632015-05-21 12:19:49 +00005644
5645 // Handle -march=native.
5646 if (MArch == "native") {
5647 std::string CPU = llvm::sys::getHostCPUName();
5648 if (CPU != "generic") {
5649 // Translate the native cpu into the architecture suffix for that CPU.
5650 const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch);
5651 // If there is no valid architecture suffix for this CPU we don't know how
5652 // to handle it, so return no architecture.
5653 if (strcmp(Suffix,"") == 0)
5654 MArch = "";
5655 else
5656 MArch = std::string("arm") + Suffix;
5657 }
5658 }
5659
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005660 return MArch;
5661}
5662/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
5663const char *arm::getARMCPUForMArch(const ArgList &Args,
5664 const llvm::Triple &Triple) {
5665 StringRef MArch = getARMArch(Args, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00005666 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
5667 // here means an -march=native that we can't handle, so instead return no CPU.
5668 if (MArch.empty())
5669 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005670
John Brawna95c1a82015-05-08 12:52:18 +00005671 // We need to return an empty string here on invalid MArch values as the
5672 // various places that call this function can't cope with a null result.
5673 const char *result = Triple.getARMCPUForArch(MArch);
5674 if (result)
5675 return result;
5676 else
5677 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00005678}
5679
5680/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Gabor Ballabas208826c2015-06-04 17:56:32 +00005681std::string arm::getARMTargetCPU(const ArgList &Args,
Rafael Espindola80d333b2013-12-12 15:48:19 +00005682 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005683 // FIXME: Warn on inconsistent use of -mcpu and -march.
5684 // If we have -mcpu=, use that.
5685 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Gabor Ballabas208826c2015-06-04 17:56:32 +00005686 std::string MCPU = StringRef(A->getValue()).lower();
Bernard Ogden31561762013-12-12 13:27:11 +00005687 // Handle -mcpu=native.
5688 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005689 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005690 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005691 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005692 }
5693
5694 return getARMCPUForMArch(Args, Triple);
5695}
5696
5697/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005698/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00005699// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005700const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) {
Artyom Skrobov902ac2d2015-06-04 21:31:41 +00005701 if (CPU == "generic" &&
5702 llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_ARMV8_1A)
5703 return "v8.1a";
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005704
Renato Golin3c007252015-05-28 15:05:53 +00005705 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
5706 if (ArchKind == llvm::ARM::AK_INVALID)
5707 return "";
5708 return llvm::ARMTargetParser::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00005709}
5710
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00005711void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
5712 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005713 if (Args.hasArg(options::OPT_r))
5714 return;
5715
John Brawn94fd9632015-05-21 12:19:49 +00005716 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
5717 // to generate BE-8 executables.
5718 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
5719 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005720}
5721
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00005722mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
5723 return (NanEncoding)llvm::StringSwitch<int>(CPU)
5724 .Case("mips1", NanLegacy)
5725 .Case("mips2", NanLegacy)
5726 .Case("mips3", NanLegacy)
5727 .Case("mips4", NanLegacy)
5728 .Case("mips5", NanLegacy)
5729 .Case("mips32", NanLegacy)
5730 .Case("mips32r2", NanLegacy)
5731 .Case("mips32r3", NanLegacy | Nan2008)
5732 .Case("mips32r5", NanLegacy | Nan2008)
5733 .Case("mips32r6", Nan2008)
5734 .Case("mips64", NanLegacy)
5735 .Case("mips64r2", NanLegacy)
5736 .Case("mips64r3", NanLegacy | Nan2008)
5737 .Case("mips64r5", NanLegacy | Nan2008)
5738 .Case("mips64r6", Nan2008)
5739 .Default(NanLegacy);
5740}
5741
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005742bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5743 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5744 return A && (A->getValue() == StringRef(Value));
5745}
5746
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005747bool mips::isUCLibc(const ArgList &Args) {
5748 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005749 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005750}
5751
Daniel Sanders2bf13662014-07-10 14:40:57 +00005752bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005753 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5754 return llvm::StringSwitch<bool>(NaNArg->getValue())
5755 .Case("2008", true)
5756 .Case("legacy", false)
5757 .Default(false);
5758
5759 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005760 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5761 .Cases("mips32r6", "mips64r6", true)
5762 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005763
5764 return false;
5765}
5766
Daniel Sanders379d44b2014-07-16 11:52:23 +00005767bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5768 StringRef ABIName) {
5769 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005770 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005771 return false;
5772
5773 if (ABIName != "32")
5774 return false;
5775
5776 return llvm::StringSwitch<bool>(CPUName)
5777 .Cases("mips2", "mips3", "mips4", "mips5", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005778 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
5779 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005780 .Default(false);
5781}
5782
Tim Northover157d9112014-01-16 08:48:16 +00005783llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005784 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5785 // archs which Darwin doesn't use.
5786
5787 // The matching this routine does is fairly pointless, since it is neither the
5788 // complete architecture list, nor a reasonable subset. The problem is that
5789 // historically the driver driver accepts this and also ties its -march=
5790 // handling to the architecture name, so we need to be careful before removing
5791 // support for it.
5792
5793 // This code must be kept in sync with Clang's Darwin specific argument
5794 // translation.
5795
5796 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5797 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5798 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5799 .Case("ppc64", llvm::Triple::ppc64)
5800 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5801 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5802 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005803 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005804 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005805 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005806 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005807 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005808 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005809 .Case("r600", llvm::Triple::r600)
Tom Stellardd8e38a32015-01-06 20:34:47 +00005810 .Case("amdgcn", llvm::Triple::amdgcn)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005811 .Case("nvptx", llvm::Triple::nvptx)
5812 .Case("nvptx64", llvm::Triple::nvptx64)
5813 .Case("amdil", llvm::Triple::amdil)
5814 .Case("spir", llvm::Triple::spir)
5815 .Default(llvm::Triple::UnknownArch);
5816}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005817
Tim Northover157d9112014-01-16 08:48:16 +00005818void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005819 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00005820 T.setArch(Arch);
5821
5822 if (Str == "x86_64h")
5823 T.setArchName(Str);
5824 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5825 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005826 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005827 }
5828}
5829
Bob Wilsondecc03e2012-11-23 06:14:39 +00005830const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00005831 const InputInfo &Input) {
5832 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005833}
5834
Bob Wilsondecc03e2012-11-23 06:14:39 +00005835const char *Clang::getBaseInputStem(const ArgList &Args,
5836 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00005837 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005838
Chris Lattner906bb902011-01-16 08:14:11 +00005839 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005840 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005841
5842 return Str;
5843}
5844
Bob Wilsondecc03e2012-11-23 06:14:39 +00005845const char *Clang::getDependencyFileName(const ArgList &Args,
5846 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005847 // FIXME: Think about this more.
5848 std::string Res;
5849
5850 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005851 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005852 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005853 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005854 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005855 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005856 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005857}
5858
Ed Schouten3c3e58c2015-03-26 11:13:44 +00005859void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA,
5860 const InputInfo &Output,
5861 const InputInfoList &Inputs,
5862 const ArgList &Args,
5863 const char *LinkingOutput) const {
5864 const ToolChain &ToolChain = getToolChain();
5865 const Driver &D = ToolChain.getDriver();
5866 ArgStringList CmdArgs;
5867
5868 // Silence warning for "clang -g foo.o -o foo"
5869 Args.ClaimAllArgs(options::OPT_g_Group);
5870 // and "clang -emit-llvm foo.o -o foo"
5871 Args.ClaimAllArgs(options::OPT_emit_llvm);
5872 // and for "clang -w foo.o -o foo". Other warning options are already
5873 // handled somewhere else.
5874 Args.ClaimAllArgs(options::OPT_w);
5875
5876 if (!D.SysRoot.empty())
5877 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5878
5879 // CloudABI only supports static linkage.
5880 CmdArgs.push_back("-Bstatic");
5881 CmdArgs.push_back("--eh-frame-hdr");
5882 CmdArgs.push_back("--gc-sections");
5883
5884 if (Output.isFilename()) {
5885 CmdArgs.push_back("-o");
5886 CmdArgs.push_back(Output.getFilename());
5887 } else {
5888 assert(Output.isNothing() && "Invalid output.");
5889 }
5890
5891 if (!Args.hasArg(options::OPT_nostdlib) &&
5892 !Args.hasArg(options::OPT_nostartfiles)) {
5893 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
5894 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
5895 }
5896
5897 Args.AddAllArgs(CmdArgs, options::OPT_L);
5898 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
5899 for (const auto &Path : Paths)
5900 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
5901 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5902 Args.AddAllArgs(CmdArgs, options::OPT_e);
5903 Args.AddAllArgs(CmdArgs, options::OPT_s);
5904 Args.AddAllArgs(CmdArgs, options::OPT_t);
5905 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5906 Args.AddAllArgs(CmdArgs, options::OPT_r);
5907
5908 if (D.IsUsingLTO(ToolChain, Args))
5909 AddGoldPlugin(ToolChain, Args, CmdArgs);
5910
5911 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5912
5913 if (!Args.hasArg(options::OPT_nostdlib) &&
5914 !Args.hasArg(options::OPT_nodefaultlibs)) {
5915 if (D.CCCIsCXX())
5916 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5917 CmdArgs.push_back("-lc");
5918 CmdArgs.push_back("-lcompiler_rt");
5919 }
5920
5921 if (!Args.hasArg(options::OPT_nostdlib) &&
5922 !Args.hasArg(options::OPT_nostartfiles))
5923 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
5924
5925 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
5926 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
5927}
5928
Daniel Dunbarbe220842009-03-20 16:06:39 +00005929void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005930 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005931 const InputInfoList &Inputs,
5932 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005933 const char *LinkingOutput) const {
5934 ArgStringList CmdArgs;
5935
5936 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5937 const InputInfo &Input = Inputs[0];
5938
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005939 // Determine the original source input.
5940 const Action *SourceAction = &JA;
5941 while (SourceAction->getKind() != Action::InputClass) {
5942 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5943 SourceAction = SourceAction->getInputs()[0];
5944 }
5945
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005946 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005947 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005948 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5949 // FIXME: at run-time detect assembler capabilities or rely on version
5950 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005951 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005952 const llvm::Triple &T(getToolChain().getTriple());
5953 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005954 CmdArgs.push_back("-Q");
5955 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005956
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005957 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005958 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005959 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005960 if (Args.hasArg(options::OPT_gstabs))
5961 CmdArgs.push_back("--gstabs");
5962 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005963 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005964 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005965
Daniel Dunbarbe220842009-03-20 16:06:39 +00005966 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005967 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005968
Daniel Dunbar6d484762010-07-22 01:47:22 +00005969 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005970 if (getToolChain().getArch() == llvm::Triple::x86 ||
5971 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005972 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5973 CmdArgs.push_back("-force_cpusubtype_ALL");
5974
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005975 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005976 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005977 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005978 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005979 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005980 CmdArgs.push_back("-static");
5981
Daniel Dunbarbe220842009-03-20 16:06:39 +00005982 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5983 options::OPT_Xassembler);
5984
5985 assert(Output.isFilename() && "Unexpected lipo output.");
5986 CmdArgs.push_back("-o");
5987 CmdArgs.push_back(Output.getFilename());
5988
Daniel Dunbarb440f562010-08-02 02:38:21 +00005989 assert(Input.isFilename() && "Invalid input.");
5990 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005991
5992 // asm_final spec is empty.
5993
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005994 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005995 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005996 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005997}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005998
Tim Northover157d9112014-01-16 08:48:16 +00005999void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00006000
Tim Northover157d9112014-01-16 08:48:16 +00006001void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6002 ArgStringList &CmdArgs) const {
6003 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006004
Daniel Dunbarc1964212009-03-26 16:23:12 +00006005 // Derived from darwin_arch spec.
6006 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006007 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006008
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006009 // FIXME: Is this needed anymore?
6010 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006011 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00006012}
6013
Bill Wendling3b2000f2012-10-02 18:02:50 +00006014bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
6015 // We only need to generate a temp path for LTO if we aren't compiling object
6016 // files. When compiling source files, we run 'dsymutil' after linking. We
6017 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006018 for (const auto &Input : Inputs)
6019 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00006020 return true;
6021
6022 return false;
6023}
6024
Daniel Dunbarccbc4522010-09-09 21:51:05 +00006025void darwin::Link::AddLinkArgs(Compilation &C,
6026 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00006027 ArgStringList &CmdArgs,
6028 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006029 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00006030 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00006031
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006032 unsigned Version[3] = { 0, 0, 0 };
6033 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6034 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00006035 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006036 Version[1], Version[2], HadExtra) ||
6037 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006038 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006039 << A->getAsString(Args);
6040 }
6041
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006042 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006043 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006044 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6045 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006046
Bob Wilson3d27dad2013-08-02 22:25:34 +00006047 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6048 CmdArgs.push_back("-export_dynamic");
6049
Bob Wilsonb111ec92015-03-02 19:01:14 +00006050 // If we are using App Extension restrictions, pass a flag to the linker
6051 // telling it that the compiled code has been audited.
6052 if (Args.hasFlag(options::OPT_fapplication_extension,
6053 options::OPT_fno_application_extension, false))
6054 CmdArgs.push_back("-application_extension");
6055
Bill Wendling313b6bf2012-11-16 23:03:00 +00006056 // If we are using LTO, then automatically create a temporary file path for
6057 // the linker to use, so that it's lifetime will extend past a possible
6058 // dsymutil step.
Peter Collingbournea4ccff32015-02-20 20:30:56 +00006059 if (Version[0] >= 116 && D.IsUsingLTO(getToolChain(), Args) &&
6060 NeedsTempPath(Inputs)) {
Bill Wendling313b6bf2012-11-16 23:03:00 +00006061 const char *TmpPath = C.getArgs().MakeArgString(
6062 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
6063 C.addTempFile(TmpPath);
6064 CmdArgs.push_back("-object_path_lto");
6065 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00006066 }
6067
Daniel Dunbarc1964212009-03-26 16:23:12 +00006068 // Derived from the "link" spec.
6069 Args.AddAllArgs(CmdArgs, options::OPT_static);
6070 if (!Args.hasArg(options::OPT_static))
6071 CmdArgs.push_back("-dynamic");
6072 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6073 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6074 // here. How do we wish to handle such things?
6075 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006076
Daniel Dunbarc1964212009-03-26 16:23:12 +00006077 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00006078 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00006079 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00006080 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006081
6082 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6083 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6084 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6085
6086 Arg *A;
6087 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6088 (A = Args.getLastArg(options::OPT_current__version)) ||
6089 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006090 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006091 << A->getAsString(Args) << "-dynamiclib";
6092
6093 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6094 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6095 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6096 } else {
6097 CmdArgs.push_back("-dylib");
6098
6099 Arg *A;
6100 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6101 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6102 (A = Args.getLastArg(options::OPT_client__name)) ||
6103 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6104 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6105 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006106 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006107 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006108
Daniel Dunbarc1964212009-03-26 16:23:12 +00006109 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6110 "-dylib_compatibility_version");
6111 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6112 "-dylib_current_version");
6113
Tim Northover157d9112014-01-16 08:48:16 +00006114 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006115
6116 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6117 "-dylib_install_name");
6118 }
6119
6120 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6121 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6122 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006123 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006124 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006125 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6126 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6127 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6128 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6129 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6130 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006131 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006132 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6133 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6134 Args.AddAllArgs(CmdArgs, options::OPT_init);
6135
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006136 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006137 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006138
Daniel Dunbarc1964212009-03-26 16:23:12 +00006139 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6140 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6141 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6142 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6143 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006144
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006145 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6146 options::OPT_fno_pie,
6147 options::OPT_fno_PIE)) {
6148 if (A->getOption().matches(options::OPT_fpie) ||
6149 A->getOption().matches(options::OPT_fPIE))
6150 CmdArgs.push_back("-pie");
6151 else
6152 CmdArgs.push_back("-no_pie");
6153 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006154
6155 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6156 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6157 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6158 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6159 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6160 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6161 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6162 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6163 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6164 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6165 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6166 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6167 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6168 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6169 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6170 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006171
Daniel Dunbar84384642011-05-02 21:03:47 +00006172 // Give --sysroot= preference, over the Apple specific behavior to also use
6173 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006174 StringRef sysroot = C.getSysRoot();
6175 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006176 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006177 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006178 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6179 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006180 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006181 }
6182
Daniel Dunbarc1964212009-03-26 16:23:12 +00006183 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6184 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6185 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6186 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6187 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006188 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006189 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6190 Args.AddAllArgs(CmdArgs, options::OPT_y);
6191 Args.AddLastArg(CmdArgs, options::OPT_w);
6192 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6193 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6194 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6195 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6196 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6197 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6198 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6199 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6200 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6201 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6202 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6203 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6204}
6205
6206void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006207 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006208 const InputInfoList &Inputs,
6209 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00006210 const char *LinkingOutput) const {
6211 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006212
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006213 // If the number of arguments surpasses the system limits, we will encode the
6214 // input files in a separate file, shortening the command line. To this end,
6215 // build a list of input file names that can be passed via a file with the
6216 // -filelist linker option.
6217 llvm::opt::ArgStringList InputFileList;
6218
Daniel Dunbarc1964212009-03-26 16:23:12 +00006219 // The logic here is derived from gcc's behavior; most of which
6220 // comes from specs (starting with link_command). Consult gcc for
6221 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006222 ArgStringList CmdArgs;
6223
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006224 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6225 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6226 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006227 for (const auto &Arg : Args)
6228 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006229 const char *Exec =
6230 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
6231 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00006232 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006233 return;
6234 }
6235
Daniel Dunbarc1964212009-03-26 16:23:12 +00006236 // I'm not sure why this particular decomposition exists in gcc, but
6237 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006238 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006239
Daniel Dunbarc1964212009-03-26 16:23:12 +00006240 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6241 Args.AddAllArgs(CmdArgs, options::OPT_s);
6242 Args.AddAllArgs(CmdArgs, options::OPT_t);
6243 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6244 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006245 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006246 Args.AddAllArgs(CmdArgs, options::OPT_r);
6247
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006248 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6249 // members of static archive libraries which implement Objective-C classes or
6250 // categories.
6251 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6252 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006253
Daniel Dunbarc1964212009-03-26 16:23:12 +00006254 CmdArgs.push_back("-o");
6255 CmdArgs.push_back(Output.getFilename());
6256
Chad Rosier06fd3c62012-05-16 23:45:12 +00006257 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006258 !Args.hasArg(options::OPT_nostartfiles))
6259 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006260
6261 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006262
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006263 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6264 options::OPT_fno_openmp, false)) {
6265 switch (getOpenMPRuntime(getToolChain(), Args)) {
6266 case OMPRT_OMP:
6267 CmdArgs.push_back("-lomp");
6268 break;
6269 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00006270 CmdArgs.push_back("-lgomp");
6271 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006272 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00006273 CmdArgs.push_back("-liomp5");
6274 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006275 case OMPRT_Unknown:
6276 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00006277 break;
6278 }
Alexey Bataev186b28a2014-03-06 05:43:53 +00006279 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006280
Douglas Gregor9295df02012-05-15 21:00:27 +00006281 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006282 // Build the input file for -filelist (list of linker input files) in case we
6283 // need it later
6284 for (const auto &II : Inputs) {
6285 if (!II.isFilename()) {
6286 // This is a linker input argument.
6287 // We cannot mix input arguments and file names in a -filelist input, thus
6288 // we prematurely stop our list (remaining files shall be passed as
6289 // arguments).
6290 if (InputFileList.size() > 0)
6291 break;
6292
6293 continue;
6294 }
6295
6296 InputFileList.push_back(II.getFilename());
6297 }
6298
Bob Wilson16d93952012-05-15 18:57:39 +00006299 if (isObjCRuntimeLinked(Args) &&
6300 !Args.hasArg(options::OPT_nostdlib) &&
6301 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006302 // We use arclite library for both ARC and subscripting support.
6303 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6304
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006305 CmdArgs.push_back("-framework");
6306 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006307 // Link libobj.
6308 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006309 }
John McCall31168b02011-06-15 23:02:42 +00006310
Daniel Dunbarc1964212009-03-26 16:23:12 +00006311 if (LinkingOutput) {
6312 CmdArgs.push_back("-arch_multiple");
6313 CmdArgs.push_back("-final_output");
6314 CmdArgs.push_back(LinkingOutput);
6315 }
6316
Daniel Dunbarc1964212009-03-26 16:23:12 +00006317 if (Args.hasArg(options::OPT_fnested_functions))
6318 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006319
Justin Bognerc7701242015-05-12 05:44:36 +00006320 // TODO: It would be nice to use addProfileRT() here, but darwin's compiler-rt
6321 // paths are different enough from other toolchains that this needs a fair
6322 // amount of refactoring done first.
6323 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6324
Daniel Dunbarc1964212009-03-26 16:23:12 +00006325 if (!Args.hasArg(options::OPT_nostdlib) &&
6326 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006327 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006328 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006329
Daniel Dunbarc1964212009-03-26 16:23:12 +00006330 // link_ssp spec is empty.
6331
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006332 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006333 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006334 }
6335
Chad Rosier06fd3c62012-05-16 23:45:12 +00006336 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006337 !Args.hasArg(options::OPT_nostartfiles)) {
6338 // endfile_spec is empty.
6339 }
6340
6341 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6342 Args.AddAllArgs(CmdArgs, options::OPT_F);
6343
Steven Wu3ffb61b2015-02-06 18:08:29 +00006344 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00006345 for (const Arg *A : Args.filtered(options::OPT_iframework))
6346 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00006347
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006348 if (!Args.hasArg(options::OPT_nostdlib) &&
6349 !Args.hasArg(options::OPT_nodefaultlibs)) {
6350 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6351 if (A->getValue() == StringRef("Accelerate")) {
6352 CmdArgs.push_back("-framework");
6353 CmdArgs.push_back("Accelerate");
6354 }
6355 }
6356 }
6357
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006358 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006359 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006360 std::unique_ptr<Command> Cmd =
6361 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
6362 Cmd->setInputFileList(std::move(InputFileList));
6363 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006364}
6365
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006366void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006367 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006368 const InputInfoList &Inputs,
6369 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006370 const char *LinkingOutput) const {
6371 ArgStringList CmdArgs;
6372
6373 CmdArgs.push_back("-create");
6374 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006375
6376 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006377 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006378
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006379 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006380 assert(II.isFilename() && "Unexpected lipo input.");
6381 CmdArgs.push_back(II.getFilename());
6382 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006383
6384 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00006385 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006386}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006387
Daniel Dunbar88299622010-06-04 18:28:36 +00006388void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006389 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00006390 const InputInfoList &Inputs,
6391 const ArgList &Args,
6392 const char *LinkingOutput) const {
6393 ArgStringList CmdArgs;
6394
Daniel Dunbareb86b042011-05-09 17:23:16 +00006395 CmdArgs.push_back("-o");
6396 CmdArgs.push_back(Output.getFilename());
6397
Daniel Dunbar88299622010-06-04 18:28:36 +00006398 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6399 const InputInfo &Input = Inputs[0];
6400 assert(Input.isFilename() && "Unexpected dsymutil input.");
6401 CmdArgs.push_back(Input.getFilename());
6402
Daniel Dunbar88299622010-06-04 18:28:36 +00006403 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006404 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00006405 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006406}
6407
Eric Christopher551ef452011-08-23 17:56:55 +00006408void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006409 const InputInfo &Output,
6410 const InputInfoList &Inputs,
6411 const ArgList &Args,
6412 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006413 ArgStringList CmdArgs;
6414 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006415 CmdArgs.push_back("--debug-info");
6416 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006417 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006418
6419 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6420 const InputInfo &Input = Inputs[0];
6421 assert(Input.isFilename() && "Unexpected verify input");
6422
6423 // Grabbing the output of the earlier dsymutil run.
6424 CmdArgs.push_back(Input.getFilename());
6425
6426 const char *Exec =
6427 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00006428 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006429}
6430
David Chisnallf571cde2012-02-15 13:39:01 +00006431void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6432 const InputInfo &Output,
6433 const InputInfoList &Inputs,
6434 const ArgList &Args,
6435 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006436 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006437 ArgStringList CmdArgs;
6438
6439 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6440 options::OPT_Xassembler);
6441
6442 CmdArgs.push_back("-o");
6443 CmdArgs.push_back(Output.getFilename());
6444
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006445 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006446 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006447
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006448 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006449 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006450}
6451
David Chisnallf571cde2012-02-15 13:39:01 +00006452void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6453 const InputInfo &Output,
6454 const InputInfoList &Inputs,
6455 const ArgList &Args,
6456 const char *LinkingOutput) const {
6457 // FIXME: Find a real GCC, don't hard-code versions here
6458 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6459 const llvm::Triple &T = getToolChain().getTriple();
6460 std::string LibPath = "/usr/lib/";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006461 const llvm::Triple::ArchType Arch = T.getArch();
David Chisnallf571cde2012-02-15 13:39:01 +00006462 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006463 case llvm::Triple::x86:
6464 GCCLibPath +=
6465 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6466 break;
6467 case llvm::Triple::x86_64:
6468 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6469 GCCLibPath += "/4.5.2/amd64/";
6470 LibPath += "amd64/";
6471 break;
6472 default:
6473 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006474 }
6475
6476 ArgStringList CmdArgs;
6477
David Chisnall272a0712012-02-29 15:06:12 +00006478 // Demangle C++ names in errors
6479 CmdArgs.push_back("-C");
6480
David Chisnallf571cde2012-02-15 13:39:01 +00006481 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6482 (!Args.hasArg(options::OPT_shared))) {
6483 CmdArgs.push_back("-e");
6484 CmdArgs.push_back("_start");
6485 }
6486
6487 if (Args.hasArg(options::OPT_static)) {
6488 CmdArgs.push_back("-Bstatic");
6489 CmdArgs.push_back("-dn");
6490 } else {
6491 CmdArgs.push_back("-Bdynamic");
6492 if (Args.hasArg(options::OPT_shared)) {
6493 CmdArgs.push_back("-shared");
6494 } else {
6495 CmdArgs.push_back("--dynamic-linker");
6496 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6497 }
6498 }
6499
6500 if (Output.isFilename()) {
6501 CmdArgs.push_back("-o");
6502 CmdArgs.push_back(Output.getFilename());
6503 } else {
6504 assert(Output.isNothing() && "Invalid output.");
6505 }
6506
6507 if (!Args.hasArg(options::OPT_nostdlib) &&
6508 !Args.hasArg(options::OPT_nostartfiles)) {
6509 if (!Args.hasArg(options::OPT_shared)) {
6510 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6511 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006512 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006513 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6514 } else {
6515 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006516 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6517 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006518 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006519 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006520 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006521 }
6522
6523 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6524
6525 Args.AddAllArgs(CmdArgs, options::OPT_L);
6526 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6527 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006528 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006529
6530 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6531
6532 if (!Args.hasArg(options::OPT_nostdlib) &&
6533 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006534 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006535 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006536 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006537 if (!Args.hasArg(options::OPT_shared)) {
6538 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006539 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006540 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006541 }
David Chisnallf571cde2012-02-15 13:39:01 +00006542 }
6543
6544 if (!Args.hasArg(options::OPT_nostdlib) &&
6545 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006546 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006547 }
David Chisnall96de9932012-02-16 16:00:47 +00006548 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006549
Alexey Samsonov7811d192014-02-20 13:57:37 +00006550 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006551
6552 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006553 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006554 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006555}
6556
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006557void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006558 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006559 const InputInfoList &Inputs,
6560 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006561 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006562 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006563 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006564 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006565
Rafael Espindolacc126272014-02-28 01:55:21 +00006566 switch (getToolChain().getArch()) {
6567 case llvm::Triple::x86:
6568 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6569 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006570 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006571 break;
6572
6573 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006574 CmdArgs.push_back("-mppc");
6575 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006576 break;
6577
6578 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006579 case llvm::Triple::sparcel:
Rafael Espindolacc126272014-02-28 01:55:21 +00006580 CmdArgs.push_back("-32");
6581 NeedsKPIC = true;
6582 break;
6583
6584 case llvm::Triple::sparcv9:
6585 CmdArgs.push_back("-64");
6586 CmdArgs.push_back("-Av9a");
6587 NeedsKPIC = true;
6588 break;
6589
6590 case llvm::Triple::mips64:
6591 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006592 StringRef CPUName;
6593 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006594 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006595
6596 CmdArgs.push_back("-mabi");
6597 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6598
6599 if (getToolChain().getArch() == llvm::Triple::mips64)
6600 CmdArgs.push_back("-EB");
6601 else
6602 CmdArgs.push_back("-EL");
6603
Rafael Espindolacc126272014-02-28 01:55:21 +00006604 NeedsKPIC = true;
6605 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006606 }
6607
Rafael Espindolacc126272014-02-28 01:55:21 +00006608 default:
6609 break;
6610 }
6611
6612 if (NeedsKPIC)
6613 addAssemblerKPIC(Args, CmdArgs);
6614
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006615 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6616 options::OPT_Xassembler);
6617
6618 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006619 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006620
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006621 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006622 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006623
6624 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006625 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006626 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006627}
6628
6629void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006630 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006631 const InputInfoList &Inputs,
6632 const ArgList &Args,
6633 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006634 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006635 ArgStringList CmdArgs;
6636
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006637 // Silence warning for "clang -g foo.o -o foo"
6638 Args.ClaimAllArgs(options::OPT_g_Group);
6639 // and "clang -emit-llvm foo.o -o foo"
6640 Args.ClaimAllArgs(options::OPT_emit_llvm);
6641 // and for "clang -w foo.o -o foo". Other warning options are already
6642 // handled somewhere else.
6643 Args.ClaimAllArgs(options::OPT_w);
6644
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006645 if (getToolChain().getArch() == llvm::Triple::mips64)
6646 CmdArgs.push_back("-EB");
6647 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6648 CmdArgs.push_back("-EL");
6649
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006650 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006651 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006652 CmdArgs.push_back("-e");
6653 CmdArgs.push_back("__start");
6654 }
6655
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006656 if (Args.hasArg(options::OPT_static)) {
6657 CmdArgs.push_back("-Bstatic");
6658 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006659 if (Args.hasArg(options::OPT_rdynamic))
6660 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006661 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006662 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006663 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006664 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006665 } else {
6666 CmdArgs.push_back("-dynamic-linker");
6667 CmdArgs.push_back("/usr/libexec/ld.so");
6668 }
6669 }
6670
Rafael Espindola044f7832013-06-05 04:28:55 +00006671 if (Args.hasArg(options::OPT_nopie))
6672 CmdArgs.push_back("-nopie");
6673
Daniel Dunbarb440f562010-08-02 02:38:21 +00006674 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006675 CmdArgs.push_back("-o");
6676 CmdArgs.push_back(Output.getFilename());
6677 } else {
6678 assert(Output.isNothing() && "Invalid output.");
6679 }
6680
6681 if (!Args.hasArg(options::OPT_nostdlib) &&
6682 !Args.hasArg(options::OPT_nostartfiles)) {
6683 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006684 if (Args.hasArg(options::OPT_pg))
6685 CmdArgs.push_back(Args.MakeArgString(
6686 getToolChain().GetFilePath("gcrt0.o")));
6687 else
6688 CmdArgs.push_back(Args.MakeArgString(
6689 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006690 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006691 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006692 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006693 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006694 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006695 }
6696 }
6697
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006698 std::string Triple = getToolChain().getTripleString();
6699 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006700 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006701 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006702 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006703
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006704 Args.AddAllArgs(CmdArgs, options::OPT_L);
6705 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6706 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006707 Args.AddAllArgs(CmdArgs, options::OPT_s);
6708 Args.AddAllArgs(CmdArgs, options::OPT_t);
6709 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6710 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006711
Daniel Dunbar54423b22010-09-17 00:24:54 +00006712 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006713
6714 if (!Args.hasArg(options::OPT_nostdlib) &&
6715 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006716 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006717 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006718 if (Args.hasArg(options::OPT_pg))
6719 CmdArgs.push_back("-lm_p");
6720 else
6721 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006722 }
6723
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006724 // FIXME: For some reason GCC passes -lgcc before adding
6725 // the default system libraries. Just mimic this for now.
6726 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006727
Eric Christopher17674ec2012-09-13 06:32:34 +00006728 if (Args.hasArg(options::OPT_pthread)) {
6729 if (!Args.hasArg(options::OPT_shared) &&
6730 Args.hasArg(options::OPT_pg))
6731 CmdArgs.push_back("-lpthread_p");
6732 else
6733 CmdArgs.push_back("-lpthread");
6734 }
6735
Chandler Carruth45661652011-12-17 22:32:42 +00006736 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006737 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006738 CmdArgs.push_back("-lc_p");
6739 else
6740 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006741 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006742
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006743 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006744 }
6745
6746 if (!Args.hasArg(options::OPT_nostdlib) &&
6747 !Args.hasArg(options::OPT_nostartfiles)) {
6748 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006749 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006750 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006751 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006752 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006753 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006754 }
6755
6756 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006757 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006758 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006759}
Ed Schoutene33194b2009-04-02 19:13:12 +00006760
Eli Friedman9fa28852012-08-08 23:57:20 +00006761void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6762 const InputInfo &Output,
6763 const InputInfoList &Inputs,
6764 const ArgList &Args,
6765 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006766 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00006767 ArgStringList CmdArgs;
6768
6769 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6770 options::OPT_Xassembler);
6771
6772 CmdArgs.push_back("-o");
6773 CmdArgs.push_back(Output.getFilename());
6774
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006775 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006776 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006777
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006778 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006779 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006780}
6781
6782void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6783 const InputInfo &Output,
6784 const InputInfoList &Inputs,
6785 const ArgList &Args,
6786 const char *LinkingOutput) const {
6787 const Driver &D = getToolChain().getDriver();
6788 ArgStringList CmdArgs;
6789
6790 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6791 (!Args.hasArg(options::OPT_shared))) {
6792 CmdArgs.push_back("-e");
6793 CmdArgs.push_back("__start");
6794 }
6795
6796 if (Args.hasArg(options::OPT_static)) {
6797 CmdArgs.push_back("-Bstatic");
6798 } else {
6799 if (Args.hasArg(options::OPT_rdynamic))
6800 CmdArgs.push_back("-export-dynamic");
6801 CmdArgs.push_back("--eh-frame-hdr");
6802 CmdArgs.push_back("-Bdynamic");
6803 if (Args.hasArg(options::OPT_shared)) {
6804 CmdArgs.push_back("-shared");
6805 } else {
6806 CmdArgs.push_back("-dynamic-linker");
6807 CmdArgs.push_back("/usr/libexec/ld.so");
6808 }
6809 }
6810
6811 if (Output.isFilename()) {
6812 CmdArgs.push_back("-o");
6813 CmdArgs.push_back(Output.getFilename());
6814 } else {
6815 assert(Output.isNothing() && "Invalid output.");
6816 }
6817
6818 if (!Args.hasArg(options::OPT_nostdlib) &&
6819 !Args.hasArg(options::OPT_nostartfiles)) {
6820 if (!Args.hasArg(options::OPT_shared)) {
6821 if (Args.hasArg(options::OPT_pg))
6822 CmdArgs.push_back(Args.MakeArgString(
6823 getToolChain().GetFilePath("gcrt0.o")));
6824 else
6825 CmdArgs.push_back(Args.MakeArgString(
6826 getToolChain().GetFilePath("crt0.o")));
6827 CmdArgs.push_back(Args.MakeArgString(
6828 getToolChain().GetFilePath("crtbegin.o")));
6829 } else {
6830 CmdArgs.push_back(Args.MakeArgString(
6831 getToolChain().GetFilePath("crtbeginS.o")));
6832 }
6833 }
6834
6835 Args.AddAllArgs(CmdArgs, options::OPT_L);
6836 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6837 Args.AddAllArgs(CmdArgs, options::OPT_e);
6838
6839 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6840
6841 if (!Args.hasArg(options::OPT_nostdlib) &&
6842 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006843 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006844 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6845 if (Args.hasArg(options::OPT_pg))
6846 CmdArgs.push_back("-lm_p");
6847 else
6848 CmdArgs.push_back("-lm");
6849 }
6850
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006851 if (Args.hasArg(options::OPT_pthread)) {
6852 if (!Args.hasArg(options::OPT_shared) &&
6853 Args.hasArg(options::OPT_pg))
6854 CmdArgs.push_back("-lpthread_p");
6855 else
6856 CmdArgs.push_back("-lpthread");
6857 }
6858
Eli Friedman9fa28852012-08-08 23:57:20 +00006859 if (!Args.hasArg(options::OPT_shared)) {
6860 if (Args.hasArg(options::OPT_pg))
6861 CmdArgs.push_back("-lc_p");
6862 else
6863 CmdArgs.push_back("-lc");
6864 }
6865
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006866 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006867 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006868 case llvm::Triple::arm:
6869 MyArch = "arm";
6870 break;
6871 case llvm::Triple::x86:
6872 MyArch = "i386";
6873 break;
6874 case llvm::Triple::x86_64:
6875 MyArch = "amd64";
6876 break;
6877 default:
6878 llvm_unreachable("Unsupported architecture");
6879 }
6880 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006881 }
6882
6883 if (!Args.hasArg(options::OPT_nostdlib) &&
6884 !Args.hasArg(options::OPT_nostartfiles)) {
6885 if (!Args.hasArg(options::OPT_shared))
6886 CmdArgs.push_back(Args.MakeArgString(
6887 getToolChain().GetFilePath("crtend.o")));
6888 else
6889 CmdArgs.push_back(Args.MakeArgString(
6890 getToolChain().GetFilePath("crtendS.o")));
6891 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006892
6893 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006894 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006895 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006896}
6897
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006898void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006899 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006900 const InputInfoList &Inputs,
6901 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006902 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006903 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006904 ArgStringList CmdArgs;
6905
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006906 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6907 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006908 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006909 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006910 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006911 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006912 else if (getToolChain().getArch() == llvm::Triple::mips ||
6913 getToolChain().getArch() == llvm::Triple::mipsel ||
6914 getToolChain().getArch() == llvm::Triple::mips64 ||
6915 getToolChain().getArch() == llvm::Triple::mips64el) {
6916 StringRef CPUName;
6917 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006918 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006919
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006920 CmdArgs.push_back("-march");
6921 CmdArgs.push_back(CPUName.data());
6922
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006923 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006924 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006925
6926 if (getToolChain().getArch() == llvm::Triple::mips ||
6927 getToolChain().getArch() == llvm::Triple::mips64)
6928 CmdArgs.push_back("-EB");
6929 else
6930 CmdArgs.push_back("-EL");
6931
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006932 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006933 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006934 getToolChain().getArch() == llvm::Triple::armeb ||
6935 getToolChain().getArch() == llvm::Triple::thumb ||
6936 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006937 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006938 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006939 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6940
6941 if (FloatABI == "hard") {
6942 CmdArgs.push_back("-mfpu=vfp");
6943 } else {
6944 CmdArgs.push_back("-mfpu=softvfp");
6945 }
6946
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006947 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006948 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006949 case llvm::Triple::GNUEABI:
6950 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006951 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006952 break;
6953
6954 default:
6955 CmdArgs.push_back("-matpcs");
6956 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006957 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006958 getToolChain().getArch() == llvm::Triple::sparcel ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006959 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006960 if (getToolChain().getArch() == llvm::Triple::sparc)
6961 CmdArgs.push_back("-Av8plusa");
6962 else
6963 CmdArgs.push_back("-Av9a");
6964
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006965 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006966 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006967
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006968 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6969 options::OPT_Xassembler);
6970
6971 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006972 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006973
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006974 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006975 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006976
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006977 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006978 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006979}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006980
6981void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006982 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006983 const InputInfoList &Inputs,
6984 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006985 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006986 const toolchains::FreeBSD &ToolChain =
6987 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00006988 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006989 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006990 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006991 !Args.hasArg(options::OPT_shared) &&
6992 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006993 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006994
6995 // Silence warning for "clang -g foo.o -o foo"
6996 Args.ClaimAllArgs(options::OPT_g_Group);
6997 // and "clang -emit-llvm foo.o -o foo"
6998 Args.ClaimAllArgs(options::OPT_emit_llvm);
6999 // and for "clang -w foo.o -o foo". Other warning options are already
7000 // handled somewhere else.
7001 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007002
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007003 if (!D.SysRoot.empty())
7004 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7005
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007006 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007007 CmdArgs.push_back("-pie");
7008
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007009 if (Args.hasArg(options::OPT_static)) {
7010 CmdArgs.push_back("-Bstatic");
7011 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007012 if (Args.hasArg(options::OPT_rdynamic))
7013 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007014 CmdArgs.push_back("--eh-frame-hdr");
7015 if (Args.hasArg(options::OPT_shared)) {
7016 CmdArgs.push_back("-Bshareable");
7017 } else {
7018 CmdArgs.push_back("-dynamic-linker");
7019 CmdArgs.push_back("/libexec/ld-elf.so.1");
7020 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007021 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00007022 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7023 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7024 CmdArgs.push_back("--hash-style=both");
7025 }
7026 }
7027 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007028 }
7029
7030 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7031 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007032 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007033 CmdArgs.push_back("-m");
7034 CmdArgs.push_back("elf_i386_fbsd");
7035 }
7036
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007037 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00007038 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00007039 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00007040 }
7041
Daniel Dunbarb440f562010-08-02 02:38:21 +00007042 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007043 CmdArgs.push_back("-o");
7044 CmdArgs.push_back(Output.getFilename());
7045 } else {
7046 assert(Output.isNothing() && "Invalid output.");
7047 }
7048
7049 if (!Args.hasArg(options::OPT_nostdlib) &&
7050 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007051 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007052 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007053 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00007054 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007055 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007056 crt1 = "Scrt1.o";
7057 else
7058 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007059 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007060 if (crt1)
7061 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7062
7063 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7064
Craig Topper92fc2df2014-05-17 16:56:41 +00007065 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00007066 if (Args.hasArg(options::OPT_static))
7067 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007068 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007069 crtbegin = "crtbeginS.o";
7070 else
7071 crtbegin = "crtbegin.o";
7072
7073 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007074 }
7075
7076 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007077 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007078 for (const auto &Path : Paths)
7079 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007080 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7081 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00007082 Args.AddAllArgs(CmdArgs, options::OPT_s);
7083 Args.AddAllArgs(CmdArgs, options::OPT_t);
7084 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7085 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007086
Peter Collingbournea4ccff32015-02-20 20:30:56 +00007087 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007088 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00007089
Alexey Samsonov52550342014-09-15 19:58:40 +00007090 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00007091 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007092
7093 if (!Args.hasArg(options::OPT_nostdlib) &&
7094 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007095 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00007096 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00007097 if (Args.hasArg(options::OPT_pg))
7098 CmdArgs.push_back("-lm_p");
7099 else
7100 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007101 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007102 if (NeedsSanitizerDeps)
7103 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007104 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7105 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007106 if (Args.hasArg(options::OPT_pg))
7107 CmdArgs.push_back("-lgcc_p");
7108 else
7109 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007110 if (Args.hasArg(options::OPT_static)) {
7111 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007112 } else if (Args.hasArg(options::OPT_pg)) {
7113 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007114 } else {
7115 CmdArgs.push_back("--as-needed");
7116 CmdArgs.push_back("-lgcc_s");
7117 CmdArgs.push_back("--no-as-needed");
7118 }
7119
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007120 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007121 if (Args.hasArg(options::OPT_pg))
7122 CmdArgs.push_back("-lpthread_p");
7123 else
7124 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007125 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007126
Roman Divacky66f22762011-02-10 16:59:40 +00007127 if (Args.hasArg(options::OPT_pg)) {
7128 if (Args.hasArg(options::OPT_shared))
7129 CmdArgs.push_back("-lc");
7130 else
7131 CmdArgs.push_back("-lc_p");
7132 CmdArgs.push_back("-lgcc_p");
7133 } else {
7134 CmdArgs.push_back("-lc");
7135 CmdArgs.push_back("-lgcc");
7136 }
7137
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007138 if (Args.hasArg(options::OPT_static)) {
7139 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007140 } else if (Args.hasArg(options::OPT_pg)) {
7141 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007142 } else {
7143 CmdArgs.push_back("--as-needed");
7144 CmdArgs.push_back("-lgcc_s");
7145 CmdArgs.push_back("--no-as-needed");
7146 }
7147 }
7148
7149 if (!Args.hasArg(options::OPT_nostdlib) &&
7150 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007151 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007152 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007153 else
7154 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007155 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007156 }
7157
Alexey Samsonov7811d192014-02-20 13:57:37 +00007158 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007159
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007160 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007161 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007162 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007163}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007164
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007165void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7166 const InputInfo &Output,
7167 const InputInfoList &Inputs,
7168 const ArgList &Args,
7169 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007170 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007171 ArgStringList CmdArgs;
7172
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007173 // GNU as needs different flags for creating the correct output format
7174 // on architectures with different ABIs or optional feature sets.
7175 switch (getToolChain().getArch()) {
7176 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007177 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007178 break;
7179 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007180 case llvm::Triple::armeb:
7181 case llvm::Triple::thumb:
7182 case llvm::Triple::thumbeb: {
Gabor Ballabas208826c2015-06-04 17:56:32 +00007183 std::string MArch = arm::getARMTargetCPU(Args, getToolChain().getTriple());
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007184 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007185 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007186 }
7187
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007188 case llvm::Triple::mips:
7189 case llvm::Triple::mipsel:
7190 case llvm::Triple::mips64:
7191 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007192 StringRef CPUName;
7193 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007194 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007195
7196 CmdArgs.push_back("-march");
7197 CmdArgs.push_back(CPUName.data());
7198
7199 CmdArgs.push_back("-mabi");
7200 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7201
7202 if (getToolChain().getArch() == llvm::Triple::mips ||
7203 getToolChain().getArch() == llvm::Triple::mips64)
7204 CmdArgs.push_back("-EB");
7205 else
7206 CmdArgs.push_back("-EL");
7207
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007208 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007209 break;
7210 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007211
7212 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007213 case llvm::Triple::sparcel:
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007214 CmdArgs.push_back("-32");
7215 addAssemblerKPIC(Args, CmdArgs);
7216 break;
7217
7218 case llvm::Triple::sparcv9:
7219 CmdArgs.push_back("-64");
7220 CmdArgs.push_back("-Av9");
7221 addAssemblerKPIC(Args, CmdArgs);
7222 break;
7223
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007224 default:
7225 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007226 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007227
7228 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7229 options::OPT_Xassembler);
7230
7231 CmdArgs.push_back("-o");
7232 CmdArgs.push_back(Output.getFilename());
7233
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007234 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007235 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007236
David Chisnallddbd68f2011-09-27 22:03:18 +00007237 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00007238 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007239}
7240
7241void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
7242 const InputInfo &Output,
7243 const InputInfoList &Inputs,
7244 const ArgList &Args,
7245 const char *LinkingOutput) const {
7246 const Driver &D = getToolChain().getDriver();
7247 ArgStringList CmdArgs;
7248
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007249 if (!D.SysRoot.empty())
7250 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7251
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007252 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007253 if (Args.hasArg(options::OPT_static)) {
7254 CmdArgs.push_back("-Bstatic");
7255 } else {
7256 if (Args.hasArg(options::OPT_rdynamic))
7257 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007258 if (Args.hasArg(options::OPT_shared)) {
7259 CmdArgs.push_back("-Bshareable");
7260 } else {
7261 CmdArgs.push_back("-dynamic-linker");
7262 CmdArgs.push_back("/libexec/ld.elf_so");
7263 }
7264 }
7265
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007266 // Many NetBSD architectures support more than one ABI.
7267 // Determine the correct emulation for ld.
7268 switch (getToolChain().getArch()) {
7269 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007270 CmdArgs.push_back("-m");
7271 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007272 break;
7273 case llvm::Triple::arm:
7274 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007275 CmdArgs.push_back("-m");
7276 switch (getToolChain().getTriple().getEnvironment()) {
7277 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007278 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007279 CmdArgs.push_back("armelf_nbsd_eabi");
7280 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007281 case llvm::Triple::EABIHF:
7282 case llvm::Triple::GNUEABIHF:
7283 CmdArgs.push_back("armelf_nbsd_eabihf");
7284 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007285 default:
7286 CmdArgs.push_back("armelf_nbsd");
7287 break;
7288 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007289 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007290 case llvm::Triple::armeb:
7291 case llvm::Triple::thumbeb:
John Brawn94fd9632015-05-21 12:19:49 +00007292 arm::appendEBLinkFlags(Args, CmdArgs,
7293 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007294 CmdArgs.push_back("-m");
7295 switch (getToolChain().getTriple().getEnvironment()) {
7296 case llvm::Triple::EABI:
7297 case llvm::Triple::GNUEABI:
7298 CmdArgs.push_back("armelfb_nbsd_eabi");
7299 break;
7300 case llvm::Triple::EABIHF:
7301 case llvm::Triple::GNUEABIHF:
7302 CmdArgs.push_back("armelfb_nbsd_eabihf");
7303 break;
7304 default:
7305 CmdArgs.push_back("armelfb_nbsd");
7306 break;
7307 }
7308 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007309 case llvm::Triple::mips64:
7310 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007311 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007312 CmdArgs.push_back("-m");
7313 if (getToolChain().getArch() == llvm::Triple::mips64)
7314 CmdArgs.push_back("elf32btsmip");
7315 else
7316 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007317 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007318 CmdArgs.push_back("-m");
7319 if (getToolChain().getArch() == llvm::Triple::mips64)
7320 CmdArgs.push_back("elf64btsmip");
7321 else
7322 CmdArgs.push_back("elf64ltsmip");
7323 }
7324 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007325 case llvm::Triple::ppc:
7326 CmdArgs.push_back("-m");
7327 CmdArgs.push_back("elf32ppc_nbsd");
7328 break;
7329
7330 case llvm::Triple::ppc64:
7331 case llvm::Triple::ppc64le:
7332 CmdArgs.push_back("-m");
7333 CmdArgs.push_back("elf64ppc");
7334 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007335
7336 case llvm::Triple::sparc:
7337 CmdArgs.push_back("-m");
7338 CmdArgs.push_back("elf32_sparc");
7339 break;
7340
7341 case llvm::Triple::sparcv9:
7342 CmdArgs.push_back("-m");
7343 CmdArgs.push_back("elf64_sparc");
7344 break;
7345
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007346 default:
7347 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007348 }
7349
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007350 if (Output.isFilename()) {
7351 CmdArgs.push_back("-o");
7352 CmdArgs.push_back(Output.getFilename());
7353 } else {
7354 assert(Output.isNothing() && "Invalid output.");
7355 }
7356
7357 if (!Args.hasArg(options::OPT_nostdlib) &&
7358 !Args.hasArg(options::OPT_nostartfiles)) {
7359 if (!Args.hasArg(options::OPT_shared)) {
7360 CmdArgs.push_back(Args.MakeArgString(
7361 getToolChain().GetFilePath("crt0.o")));
7362 CmdArgs.push_back(Args.MakeArgString(
7363 getToolChain().GetFilePath("crti.o")));
7364 CmdArgs.push_back(Args.MakeArgString(
7365 getToolChain().GetFilePath("crtbegin.o")));
7366 } else {
7367 CmdArgs.push_back(Args.MakeArgString(
7368 getToolChain().GetFilePath("crti.o")));
7369 CmdArgs.push_back(Args.MakeArgString(
7370 getToolChain().GetFilePath("crtbeginS.o")));
7371 }
7372 }
7373
7374 Args.AddAllArgs(CmdArgs, options::OPT_L);
7375 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7376 Args.AddAllArgs(CmdArgs, options::OPT_e);
7377 Args.AddAllArgs(CmdArgs, options::OPT_s);
7378 Args.AddAllArgs(CmdArgs, options::OPT_t);
7379 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7380 Args.AddAllArgs(CmdArgs, options::OPT_r);
7381
7382 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7383
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007384 unsigned Major, Minor, Micro;
7385 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7386 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007387 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007388 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007389 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00007390 case llvm::Triple::arm:
7391 case llvm::Triple::armeb:
7392 case llvm::Triple::thumb:
7393 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007394 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007395 case llvm::Triple::ppc64:
7396 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007397 case llvm::Triple::x86:
7398 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007399 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007400 break;
7401 default:
7402 break;
7403 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007404 }
7405
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007406 if (!Args.hasArg(options::OPT_nostdlib) &&
7407 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007408 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007409 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7410 CmdArgs.push_back("-lm");
7411 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007412 if (Args.hasArg(options::OPT_pthread))
7413 CmdArgs.push_back("-lpthread");
7414 CmdArgs.push_back("-lc");
7415
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007416 if (useLibgcc) {
7417 if (Args.hasArg(options::OPT_static)) {
7418 // libgcc_eh depends on libc, so resolve as much as possible,
7419 // pull in any new requirements from libc and then get the rest
7420 // of libgcc.
7421 CmdArgs.push_back("-lgcc_eh");
7422 CmdArgs.push_back("-lc");
7423 CmdArgs.push_back("-lgcc");
7424 } else {
7425 CmdArgs.push_back("-lgcc");
7426 CmdArgs.push_back("--as-needed");
7427 CmdArgs.push_back("-lgcc_s");
7428 CmdArgs.push_back("--no-as-needed");
7429 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007430 }
7431 }
7432
7433 if (!Args.hasArg(options::OPT_nostdlib) &&
7434 !Args.hasArg(options::OPT_nostartfiles)) {
7435 if (!Args.hasArg(options::OPT_shared))
7436 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7437 "crtend.o")));
7438 else
7439 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7440 "crtendS.o")));
7441 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7442 "crtn.o")));
7443 }
7444
Alexey Samsonov7811d192014-02-20 13:57:37 +00007445 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007446
Logan Chieneb9162f2014-06-26 14:23:45 +00007447 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007448 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007449}
7450
Thomas Schwinge4e555262013-03-28 19:04:25 +00007451void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7452 const InputInfo &Output,
7453 const InputInfoList &Inputs,
7454 const ArgList &Args,
7455 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007456 claimNoWarnArgs(Args);
7457
Rafael Espindola92b00932010-08-10 00:25:48 +00007458 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007459 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007460
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007461 switch (getToolChain().getArch()) {
7462 default:
7463 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00007464 // Add --32/--64 to make sure we get the format we want.
7465 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007466 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00007467 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007468 break;
7469 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00007470 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7471 CmdArgs.push_back("--x32");
7472 else
7473 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007474 break;
7475 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007476 CmdArgs.push_back("-a32");
7477 CmdArgs.push_back("-mppc");
7478 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007479 break;
7480 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007481 CmdArgs.push_back("-a64");
7482 CmdArgs.push_back("-mppc64");
7483 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007484 break;
7485 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00007486 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007487 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007488 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007489 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007490 break;
7491 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007492 case llvm::Triple::sparcel:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007493 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007494 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007495 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007496 break;
7497 case llvm::Triple::sparcv9:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007498 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007499 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007500 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007501 break;
7502 case llvm::Triple::arm:
7503 case llvm::Triple::armeb:
7504 case llvm::Triple::thumb:
7505 case llvm::Triple::thumbeb: {
Scott Douglass3205f522015-03-23 10:54:24 +00007506 const llvm::Triple &Triple = getToolChain().getTriple();
7507 switch (Triple.getSubArch()) {
7508 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00007509 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00007510 break;
7511 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00007512 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00007513 break;
7514 default:
7515 break;
7516 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007517
Tim Northover9c7e0352013-12-12 11:55:52 +00007518 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
Derek Schuffa419e1c2015-04-10 23:07:19 +00007519 getToolChain().getDriver(), Args,
7520 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007521 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007522
7523 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007524
7525 // FIXME: remove krait check when GNU tools support krait cpu
7526 // for now replace it with -march=armv7-a to avoid a lower
7527 // march from being picked in the absence of a cpu flag.
7528 Arg *A;
7529 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Gabor Ballabas208826c2015-06-04 17:56:32 +00007530 StringRef(A->getValue()).lower() == "krait")
Ana Pazosdd6068d2013-12-06 22:43:17 +00007531 CmdArgs.push_back("-march=armv7-a");
7532 else
7533 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007534 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007535 break;
7536 }
7537 case llvm::Triple::mips:
7538 case llvm::Triple::mipsel:
7539 case llvm::Triple::mips64:
7540 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007541 StringRef CPUName;
7542 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007543 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007544 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007545
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007546 CmdArgs.push_back("-march");
7547 CmdArgs.push_back(CPUName.data());
7548
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007549 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007550 CmdArgs.push_back(ABIName.data());
7551
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007552 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7553 // or -mshared (not implemented) is in effect.
7554 bool IsPicOrPie = false;
7555 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7556 options::OPT_fpic, options::OPT_fno_pic,
7557 options::OPT_fPIE, options::OPT_fno_PIE,
7558 options::OPT_fpie, options::OPT_fno_pie)) {
7559 if (A->getOption().matches(options::OPT_fPIC) ||
7560 A->getOption().matches(options::OPT_fpic) ||
7561 A->getOption().matches(options::OPT_fPIE) ||
7562 A->getOption().matches(options::OPT_fpie))
7563 IsPicOrPie = true;
7564 }
7565 if (!IsPicOrPie)
7566 CmdArgs.push_back("-mno-shared");
7567
Daniel Sanders379d44b2014-07-16 11:52:23 +00007568 // LLVM doesn't support -mplt yet and acts as if it is always given.
7569 // However, -mplt has no effect with the N64 ABI.
7570 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007571
7572 if (getToolChain().getArch() == llvm::Triple::mips ||
7573 getToolChain().getArch() == llvm::Triple::mips64)
7574 CmdArgs.push_back("-EB");
7575 else
7576 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007577
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007578 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7579 if (StringRef(A->getValue()) == "2008")
7580 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7581 }
7582
Daniel Sanders379d44b2014-07-16 11:52:23 +00007583 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7584 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7585 options::OPT_mfp64)) {
7586 A->claim();
7587 A->render(Args, CmdArgs);
7588 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7589 ABIName))
7590 CmdArgs.push_back("-mfpxx");
7591
7592 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7593 // -mno-mips16 is actually -no-mips16.
7594 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7595 options::OPT_mno_mips16)) {
7596 if (A->getOption().matches(options::OPT_mips16)) {
7597 A->claim();
7598 A->render(Args, CmdArgs);
7599 } else {
7600 A->claim();
7601 CmdArgs.push_back("-no-mips16");
7602 }
7603 }
7604
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007605 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7606 options::OPT_mno_micromips);
7607 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7608 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7609
Simon Atanasyanbd986632013-11-26 11:58:04 +00007610 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7611 // Do not use AddLastArg because not all versions of MIPS assembler
7612 // support -mmsa / -mno-msa options.
7613 if (A->getOption().matches(options::OPT_mmsa))
7614 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7615 }
7616
Daniel Sanders379d44b2014-07-16 11:52:23 +00007617 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7618 options::OPT_msoft_float);
7619
7620 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7621 options::OPT_mno_odd_spreg);
7622
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007623 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007624 break;
7625 }
7626 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007627 // Always pass an -march option, since our default of z10 is later
7628 // than the GNU assembler's default.
7629 StringRef CPUName = getSystemZTargetCPU(Args);
7630 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007631 break;
7632 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007633 }
7634
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007635 if (NeedsKPIC)
7636 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007637
7638 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7639 options::OPT_Xassembler);
7640
7641 CmdArgs.push_back("-o");
7642 CmdArgs.push_back(Output.getFilename());
7643
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007644 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007645 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007646
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007647 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007648 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007649
7650 // Handle the debug info splitting at object creation time if we're
7651 // creating an object.
7652 // TODO: Currently only works on linux with newer objcopy.
7653 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007654 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007655 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00007656 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00007657}
7658
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007659static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007660 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007661 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007662 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7663 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007664 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007665 CmdArgs.push_back("-lgcc");
7666
Logan Chien3d3373c2012-11-19 12:04:11 +00007667 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007668 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007669 CmdArgs.push_back("-lgcc");
7670 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007671 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007672 CmdArgs.push_back("--as-needed");
7673 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007674 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007675 CmdArgs.push_back("--no-as-needed");
7676 }
7677
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007678 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007679 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007680 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007681 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007682
7683 // According to Android ABI, we have to link with libdl if we are
7684 // linking with non-static libgcc.
7685 //
7686 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7687 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7688 if (isAndroid && !StaticLibgcc)
7689 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007690}
7691
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007692static std::string getLinuxDynamicLinker(const ArgList &Args,
7693 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007694 const llvm::Triple::ArchType Arch = ToolChain.getArch();
7695
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007696 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7697 if (ToolChain.getTriple().isArch64Bit())
7698 return "/system/bin/linker64";
7699 else
7700 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007701 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
7702 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007703 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007704 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007705 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007706 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007707 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007708 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007709 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7710 return "/lib/ld-linux-armhf.so.3";
7711 else
7712 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007713 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
7714 // TODO: check which dynamic linker name.
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007715 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007716 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007717 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007718 return "/lib/ld-linux.so.3";
7719 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
7720 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007721 StringRef CPUName;
7722 StringRef ABIName;
7723 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7724 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7725
7726 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7727 .Case("o32", "/lib")
7728 .Case("n32", "/lib32")
7729 .Case("n64", "/lib64")
7730 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007731 StringRef LibName;
7732 if (mips::isUCLibc(Args))
7733 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7734 else
7735 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007736
7737 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007738 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007739 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007740 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007741 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7742 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007743 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007744 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00007745 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7746 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007747 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007748 } else if (Arch == llvm::Triple::systemz)
Ulrich Weigand8afad612014-07-28 13:17:52 +00007749 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007750 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007751 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007752 else if (Arch == llvm::Triple::x86_64 &&
Zinovy Nis1db95732014-07-10 15:27:19 +00007753 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7754 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007755 else
7756 return "/lib64/ld-linux-x86-64.so.2";
7757}
7758
Renato Golinc4b49242014-02-13 10:01:16 +00007759static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007760 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007761 // Make use of compiler-rt if --rtlib option is used
7762 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7763
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007764 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007765 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007766 switch (TC.getTriple().getOS()) {
7767 default: llvm_unreachable("unsupported OS");
7768 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007769 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007770 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007771 break;
7772 }
Renato Golinc4b49242014-02-13 10:01:16 +00007773 break;
7774 case ToolChain::RLT_Libgcc:
7775 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7776 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007777 }
7778}
7779
Rafael Espindola1e085772014-08-15 17:14:35 +00007780static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7781 switch (T.getArch()) {
7782 case llvm::Triple::x86:
7783 return "elf_i386";
7784 case llvm::Triple::aarch64:
7785 return "aarch64linux";
7786 case llvm::Triple::aarch64_be:
7787 return "aarch64_be_linux";
7788 case llvm::Triple::arm:
7789 case llvm::Triple::thumb:
7790 return "armelf_linux_eabi";
7791 case llvm::Triple::armeb:
7792 case llvm::Triple::thumbeb:
7793 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7794 case llvm::Triple::ppc:
7795 return "elf32ppclinux";
7796 case llvm::Triple::ppc64:
7797 return "elf64ppc";
7798 case llvm::Triple::ppc64le:
7799 return "elf64lppc";
7800 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007801 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00007802 return "elf32_sparc";
7803 case llvm::Triple::sparcv9:
7804 return "elf64_sparc";
7805 case llvm::Triple::mips:
7806 return "elf32btsmip";
7807 case llvm::Triple::mipsel:
7808 return "elf32ltsmip";
7809 case llvm::Triple::mips64:
7810 if (mips::hasMipsAbiArg(Args, "n32"))
7811 return "elf32btsmipn32";
7812 return "elf64btsmip";
7813 case llvm::Triple::mips64el:
7814 if (mips::hasMipsAbiArg(Args, "n32"))
7815 return "elf32ltsmipn32";
7816 return "elf64ltsmip";
7817 case llvm::Triple::systemz:
7818 return "elf64_s390";
7819 case llvm::Triple::x86_64:
7820 if (T.getEnvironment() == llvm::Triple::GNUX32)
7821 return "elf32_x86_64";
7822 return "elf_x86_64";
7823 default:
7824 llvm_unreachable("Unexpected arch");
7825 }
7826}
7827
Thomas Schwinge4e555262013-03-28 19:04:25 +00007828void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7829 const InputInfo &Output,
7830 const InputInfoList &Inputs,
7831 const ArgList &Args,
7832 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007833 const toolchains::Linux &ToolChain =
7834 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007835 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007836 const llvm::Triple::ArchType Arch = ToolChain.getArch();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007837 const bool isAndroid =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007838 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007839 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007840 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
7841 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007842
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007843 ArgStringList CmdArgs;
7844
Rafael Espindolad1002f62010-11-15 18:28:16 +00007845 // Silence warning for "clang -g foo.o -o foo"
7846 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007847 // and "clang -emit-llvm foo.o -o foo"
7848 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007849 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007850 // handled somewhere else.
7851 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007852
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007853 if (!D.SysRoot.empty())
7854 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007855
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007856 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007857 CmdArgs.push_back("-pie");
7858
Rafael Espindola1c76c592010-11-07 22:57:16 +00007859 if (Args.hasArg(options::OPT_rdynamic))
7860 CmdArgs.push_back("-export-dynamic");
7861
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007862 if (Args.hasArg(options::OPT_s))
7863 CmdArgs.push_back("-s");
7864
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007865 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
7866 arm::appendEBLinkFlags(
7867 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00007868 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007869
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007870 for (const auto &Opt : ToolChain.ExtraOpts)
7871 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007872
7873 if (!Args.hasArg(options::OPT_static)) {
7874 CmdArgs.push_back("--eh-frame-hdr");
7875 }
7876
7877 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007878 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007879
7880 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007881 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
7882 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007883 CmdArgs.push_back("-Bstatic");
7884 else
7885 CmdArgs.push_back("-static");
7886 } else if (Args.hasArg(options::OPT_shared)) {
7887 CmdArgs.push_back("-shared");
7888 }
7889
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007890 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
7891 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007892 (!Args.hasArg(options::OPT_static) &&
7893 !Args.hasArg(options::OPT_shared))) {
7894 CmdArgs.push_back("-dynamic-linker");
7895 CmdArgs.push_back(Args.MakeArgString(
7896 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7897 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007898
7899 CmdArgs.push_back("-o");
7900 CmdArgs.push_back(Output.getFilename());
7901
Rafael Espindola81937ec2010-12-01 01:52:43 +00007902 if (!Args.hasArg(options::OPT_nostdlib) &&
7903 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007904 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007905 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007906 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007907 if (Args.hasArg(options::OPT_pg))
7908 crt1 = "gcrt1.o";
7909 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007910 crt1 = "Scrt1.o";
7911 else
7912 crt1 = "crt1.o";
7913 }
7914 if (crt1)
7915 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007916
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007917 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7918 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007919
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007920 const char *crtbegin;
7921 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007922 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007923 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007924 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007925 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007926 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007927 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007928 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007929 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007930
7931 // Add crtfastmath.o if available and fast math is enabled.
7932 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007933 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007934
7935 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007936 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007937
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007938 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007939
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007940 for (const auto &Path : Paths)
7941 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007942
Peter Collingbournea4ccff32015-02-20 20:30:56 +00007943 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007944 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007945
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007946 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7947 CmdArgs.push_back("--no-demangle");
7948
Alexey Samsonov52550342014-09-15 19:58:40 +00007949 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007950 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007951 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007952 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007953
Hans Wennborg70850d82013-07-18 20:29:38 +00007954 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007955 !Args.hasArg(options::OPT_nostdlib) &&
7956 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007957 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7958 !Args.hasArg(options::OPT_static);
7959 if (OnlyLibstdcxxStatic)
7960 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007961 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007962 if (OnlyLibstdcxxStatic)
7963 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007964 CmdArgs.push_back("-lm");
7965 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00007966 // Silence warnings when linking C code with a C++ '-stdlib' argument.
7967 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007968
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007969 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007970 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7971 if (Args.hasArg(options::OPT_static))
7972 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007973
Alexey Samsonov52550342014-09-15 19:58:40 +00007974 if (NeedsSanitizerDeps)
7975 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7976
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00007977 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
7978 Args.hasArg(options::OPT_pthreads);
7979
7980 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
7981 options::OPT_fno_openmp, false)) {
7982 // OpenMP runtimes implies pthreads when using the GNU toolchain.
7983 // FIXME: Does this really make sense for all GNU toolchains?
7984 WantPthread = true;
7985
7986 // Also link the particular OpenMP runtimes.
7987 switch (getOpenMPRuntime(ToolChain, Args)) {
7988 case OMPRT_OMP:
7989 CmdArgs.push_back("-lomp");
7990 break;
7991 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00007992 CmdArgs.push_back("-lgomp");
7993
7994 // FIXME: Exclude this for platforms with libgomp that don't require
7995 // librt. Most modern Linux platforms require it, but some may not.
7996 CmdArgs.push_back("-lrt");
7997 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00007998 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00007999 CmdArgs.push_back("-liomp5");
8000 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008001 case OMPRT_Unknown:
8002 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00008003 break;
8004 }
Chandler Carruth01538002013-01-17 13:19:29 +00008005 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008006
Renato Golinc4b49242014-02-13 10:01:16 +00008007 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008008
Richard Smith31d1de22015-05-20 22:48:44 +00008009 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00008010 CmdArgs.push_back("-lpthread");
8011
8012 CmdArgs.push_back("-lc");
8013
8014 if (Args.hasArg(options::OPT_static))
8015 CmdArgs.push_back("--end-group");
8016 else
Renato Golinc4b49242014-02-13 10:01:16 +00008017 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00008018 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00008019
Rafael Espindola81937ec2010-12-01 01:52:43 +00008020 if (!Args.hasArg(options::OPT_nostartfiles)) {
8021 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008022 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008023 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008024 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008025 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00008026 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008027 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008028
Rafael Espindola81937ec2010-12-01 01:52:43 +00008029 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008030 if (!isAndroid)
8031 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00008032 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008033 }
8034
David Blaikiec11bf802014-09-04 16:04:28 +00008035 C.addCommand(
8036 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00008037}
8038
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008039
8040// NaCl ARM assembly (inline or standalone) can be written with a set of macros
8041// for the various SFI requirements like register masking. The assembly tool
8042// inserts the file containing the macros as an input into all the assembly
8043// jobs.
8044void nacltools::AssembleARM::ConstructJob(Compilation &C, const JobAction &JA,
8045 const InputInfo &Output,
8046 const InputInfoList &Inputs,
8047 const ArgList &Args,
8048 const char *LinkingOutput) const {
8049 const toolchains::NaCl_TC& ToolChain =
8050 static_cast<const toolchains::NaCl_TC&>(getToolChain());
8051 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8052 "nacl-arm-macros.s");
8053 InputInfoList NewInputs;
8054 NewInputs.push_back(NaClMacros);
8055 NewInputs.append(Inputs.begin(), Inputs.end());
8056 gnutools::Assemble::ConstructJob(C, JA, Output, NewInputs, Args,
8057 LinkingOutput);
8058}
8059
8060
8061// This is quite similar to gnutools::link::ConstructJob with changes that
8062// we use static by default, do not yet support sanitizers or LTO, and a few
8063// others. Eventually we can support more of that and hopefully migrate back
8064// to gnutools::link.
8065void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008066 const InputInfo &Output,
8067 const InputInfoList &Inputs,
8068 const ArgList &Args,
8069 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008070
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008071 const toolchains::NaCl_TC &ToolChain =
8072 static_cast<const toolchains::NaCl_TC &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008073 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008074 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008075 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008076 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008077
8078 ArgStringList CmdArgs;
8079
8080 // Silence warning for "clang -g foo.o -o foo"
8081 Args.ClaimAllArgs(options::OPT_g_Group);
8082 // and "clang -emit-llvm foo.o -o foo"
8083 Args.ClaimAllArgs(options::OPT_emit_llvm);
8084 // and for "clang -w foo.o -o foo". Other warning options are already
8085 // handled somewhere else.
8086 Args.ClaimAllArgs(options::OPT_w);
8087
8088 if (!D.SysRoot.empty())
8089 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8090
8091 if (Args.hasArg(options::OPT_rdynamic))
8092 CmdArgs.push_back("-export-dynamic");
8093
8094 if (Args.hasArg(options::OPT_s))
8095 CmdArgs.push_back("-s");
8096
8097 // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from
8098 // there is --build-id, which we do want.
8099 CmdArgs.push_back("--build-id");
8100
8101 if (!IsStatic)
8102 CmdArgs.push_back("--eh-frame-hdr");
8103
8104 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008105 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008106 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008107 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008108 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008109 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008110 CmdArgs.push_back("elf_x86_64_nacl");
8111 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008112 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8113 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008114
8115 if (IsStatic)
8116 CmdArgs.push_back("-static");
8117 else if (Args.hasArg(options::OPT_shared))
8118 CmdArgs.push_back("-shared");
8119
8120 CmdArgs.push_back("-o");
8121 CmdArgs.push_back(Output.getFilename());
8122 if (!Args.hasArg(options::OPT_nostdlib) &&
8123 !Args.hasArg(options::OPT_nostartfiles)) {
8124 if (!Args.hasArg(options::OPT_shared))
8125 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8126 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8127
8128 const char *crtbegin;
8129 if (IsStatic)
8130 crtbegin = "crtbeginT.o";
8131 else if (Args.hasArg(options::OPT_shared))
8132 crtbegin = "crtbeginS.o";
8133 else
8134 crtbegin = "crtbegin.o";
8135 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8136 }
8137
8138 Args.AddAllArgs(CmdArgs, options::OPT_L);
8139 Args.AddAllArgs(CmdArgs, options::OPT_u);
8140
8141 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8142
8143 for (const auto &Path : Paths)
8144 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8145
8146 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8147 CmdArgs.push_back("--no-demangle");
8148
8149 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8150
8151 if (D.CCCIsCXX() &&
8152 !Args.hasArg(options::OPT_nostdlib) &&
8153 !Args.hasArg(options::OPT_nodefaultlibs)) {
8154 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8155 !IsStatic;
8156 if (OnlyLibstdcxxStatic)
8157 CmdArgs.push_back("-Bstatic");
8158 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8159 if (OnlyLibstdcxxStatic)
8160 CmdArgs.push_back("-Bdynamic");
8161 CmdArgs.push_back("-lm");
8162 }
8163
8164 if (!Args.hasArg(options::OPT_nostdlib)) {
8165 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8166 // Always use groups, since it has no effect on dynamic libraries.
8167 CmdArgs.push_back("--start-group");
8168 CmdArgs.push_back("-lc");
8169 // NaCl's libc++ currently requires libpthread, so just always include it
8170 // in the group for C++.
8171 if (Args.hasArg(options::OPT_pthread) ||
8172 Args.hasArg(options::OPT_pthreads) ||
8173 D.CCCIsCXX()) {
8174 CmdArgs.push_back("-lpthread");
8175 }
8176
8177 CmdArgs.push_back("-lgcc");
8178 CmdArgs.push_back("--as-needed");
8179 if (IsStatic)
8180 CmdArgs.push_back("-lgcc_eh");
8181 else
8182 CmdArgs.push_back("-lgcc_s");
8183 CmdArgs.push_back("--no-as-needed");
8184 CmdArgs.push_back("--end-group");
8185 }
8186
8187 if (!Args.hasArg(options::OPT_nostartfiles)) {
8188 const char *crtend;
8189 if (Args.hasArg(options::OPT_shared))
8190 crtend = "crtendS.o";
8191 else
8192 crtend = "crtend.o";
8193
8194 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8195 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8196 }
8197 }
8198
8199 C.addCommand(llvm::make_unique<Command>(JA, *this,
8200 ToolChain.Linker.c_str(), CmdArgs));
8201}
8202
8203
Chris Lattner3e2ee142010-07-07 16:01:42 +00008204void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008205 const InputInfo &Output,
8206 const InputInfoList &Inputs,
8207 const ArgList &Args,
8208 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008209 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008210 ArgStringList CmdArgs;
8211
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008212 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008213
8214 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008215 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008216
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008217 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008218 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008219
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008220 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008221 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008222}
8223
8224void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008225 const InputInfo &Output,
8226 const InputInfoList &Inputs,
8227 const ArgList &Args,
8228 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008229 const Driver &D = getToolChain().getDriver();
8230 ArgStringList CmdArgs;
8231
Daniel Dunbarb440f562010-08-02 02:38:21 +00008232 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008233 CmdArgs.push_back("-o");
8234 CmdArgs.push_back(Output.getFilename());
8235 } else {
8236 assert(Output.isNothing() && "Invalid output.");
8237 }
8238
8239 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008240 !Args.hasArg(options::OPT_nostartfiles)) {
8241 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8242 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8243 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8244 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8245 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008246
8247 Args.AddAllArgs(CmdArgs, options::OPT_L);
8248 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8249 Args.AddAllArgs(CmdArgs, options::OPT_e);
8250
Daniel Dunbar54423b22010-09-17 00:24:54 +00008251 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008252
Alexey Samsonov7811d192014-02-20 13:57:37 +00008253 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008254
Chris Lattner3e2ee142010-07-07 16:01:42 +00008255 if (!Args.hasArg(options::OPT_nostdlib) &&
8256 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008257 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008258 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008259 CmdArgs.push_back("-lm");
8260 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008261 }
8262
8263 if (!Args.hasArg(options::OPT_nostdlib) &&
8264 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008265 if (Args.hasArg(options::OPT_pthread))
8266 CmdArgs.push_back("-lpthread");
8267 CmdArgs.push_back("-lc");
8268 CmdArgs.push_back("-lCompilerRT-Generic");
8269 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8270 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00008271 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008272 }
8273
Logan Chieneb9162f2014-06-26 14:23:45 +00008274 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008275 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008276}
8277
Daniel Dunbarcc912342009-05-02 18:28:39 +00008278/// DragonFly Tools
8279
8280// For now, DragonFly Assemble does just about the same as for
8281// FreeBSD, but this may change soon.
8282void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008283 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00008284 const InputInfoList &Inputs,
8285 const ArgList &Args,
8286 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008287 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008288 ArgStringList CmdArgs;
8289
8290 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8291 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008292 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008293 CmdArgs.push_back("--32");
8294
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008295 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008296
8297 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008298 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008299
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008300 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008301 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008302
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008303 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008304 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008305}
8306
8307void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008308 const InputInfo &Output,
8309 const InputInfoList &Inputs,
8310 const ArgList &Args,
8311 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008312 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008313 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008314 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008315
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008316 if (!D.SysRoot.empty())
8317 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8318
John McCall65b8da02013-04-11 22:55:55 +00008319 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008320 if (Args.hasArg(options::OPT_static)) {
8321 CmdArgs.push_back("-Bstatic");
8322 } else {
John McCall65b8da02013-04-11 22:55:55 +00008323 if (Args.hasArg(options::OPT_rdynamic))
8324 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008325 if (Args.hasArg(options::OPT_shared))
8326 CmdArgs.push_back("-Bshareable");
8327 else {
8328 CmdArgs.push_back("-dynamic-linker");
8329 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8330 }
John McCall65b8da02013-04-11 22:55:55 +00008331 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008332 }
8333
8334 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8335 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008336 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008337 CmdArgs.push_back("-m");
8338 CmdArgs.push_back("elf_i386");
8339 }
8340
Daniel Dunbarb440f562010-08-02 02:38:21 +00008341 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008342 CmdArgs.push_back("-o");
8343 CmdArgs.push_back(Output.getFilename());
8344 } else {
8345 assert(Output.isNothing() && "Invalid output.");
8346 }
8347
8348 if (!Args.hasArg(options::OPT_nostdlib) &&
8349 !Args.hasArg(options::OPT_nostartfiles)) {
8350 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008351 if (Args.hasArg(options::OPT_pg))
8352 CmdArgs.push_back(Args.MakeArgString(
8353 getToolChain().GetFilePath("gcrt1.o")));
8354 else {
8355 if (Args.hasArg(options::OPT_pie))
8356 CmdArgs.push_back(Args.MakeArgString(
8357 getToolChain().GetFilePath("Scrt1.o")));
8358 else
8359 CmdArgs.push_back(Args.MakeArgString(
8360 getToolChain().GetFilePath("crt1.o")));
8361 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008362 }
John McCall65b8da02013-04-11 22:55:55 +00008363 CmdArgs.push_back(Args.MakeArgString(
8364 getToolChain().GetFilePath("crti.o")));
8365 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8366 CmdArgs.push_back(Args.MakeArgString(
8367 getToolChain().GetFilePath("crtbeginS.o")));
8368 else
8369 CmdArgs.push_back(Args.MakeArgString(
8370 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008371 }
8372
8373 Args.AddAllArgs(CmdArgs, options::OPT_L);
8374 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8375 Args.AddAllArgs(CmdArgs, options::OPT_e);
8376
Daniel Dunbar54423b22010-09-17 00:24:54 +00008377 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008378
8379 if (!Args.hasArg(options::OPT_nostdlib) &&
8380 !Args.hasArg(options::OPT_nodefaultlibs)) {
8381 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8382 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00008383 if (UseGCC47)
8384 CmdArgs.push_back("-L/usr/lib/gcc47");
8385 else
8386 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008387
8388 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00008389 if (UseGCC47) {
8390 CmdArgs.push_back("-rpath");
8391 CmdArgs.push_back("/usr/lib/gcc47");
8392 } else {
8393 CmdArgs.push_back("-rpath");
8394 CmdArgs.push_back("/usr/lib/gcc44");
8395 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008396 }
8397
Hans Wennborg70850d82013-07-18 20:29:38 +00008398 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008399 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00008400 CmdArgs.push_back("-lm");
8401 }
8402
Daniel Dunbarcc912342009-05-02 18:28:39 +00008403 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00008404 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008405
8406 if (!Args.hasArg(options::OPT_nolibc)) {
8407 CmdArgs.push_back("-lc");
8408 }
8409
John McCall65b8da02013-04-11 22:55:55 +00008410 if (UseGCC47) {
8411 if (Args.hasArg(options::OPT_static) ||
8412 Args.hasArg(options::OPT_static_libgcc)) {
8413 CmdArgs.push_back("-lgcc");
8414 CmdArgs.push_back("-lgcc_eh");
8415 } else {
8416 if (Args.hasArg(options::OPT_shared_libgcc)) {
8417 CmdArgs.push_back("-lgcc_pic");
8418 if (!Args.hasArg(options::OPT_shared))
8419 CmdArgs.push_back("-lgcc");
8420 } else {
8421 CmdArgs.push_back("-lgcc");
8422 CmdArgs.push_back("--as-needed");
8423 CmdArgs.push_back("-lgcc_pic");
8424 CmdArgs.push_back("--no-as-needed");
8425 }
8426 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008427 } else {
John McCall65b8da02013-04-11 22:55:55 +00008428 if (Args.hasArg(options::OPT_shared)) {
8429 CmdArgs.push_back("-lgcc_pic");
8430 } else {
8431 CmdArgs.push_back("-lgcc");
8432 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008433 }
8434 }
8435
8436 if (!Args.hasArg(options::OPT_nostdlib) &&
8437 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00008438 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00008439 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00008440 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008441 else
8442 CmdArgs.push_back(Args.MakeArgString(
8443 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008444 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00008445 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008446 }
8447
Alexey Samsonov7811d192014-02-20 13:57:37 +00008448 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008449
Logan Chieneb9162f2014-06-26 14:23:45 +00008450 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008451 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008452}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008453
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008454// Try to find Exe from a Visual Studio distribution. This first tries to find
8455// an installed copy of Visual Studio and, failing that, looks in the PATH,
8456// making sure that whatever executable that's found is not a same-named exe
8457// from clang itself to prevent clang from falling back to itself.
8458static std::string FindVisualStudioExecutable(const ToolChain &TC,
8459 const char *Exe,
8460 const char *ClangProgramPath) {
8461 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8462 std::string visualStudioBinDir;
8463 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8464 visualStudioBinDir)) {
8465 SmallString<128> FilePath(visualStudioBinDir);
8466 llvm::sys::path::append(FilePath, Exe);
8467 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8468 return FilePath.str();
8469 }
8470
8471 return Exe;
8472}
8473
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008474void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
8475 const InputInfo &Output,
8476 const InputInfoList &Inputs,
8477 const ArgList &Args,
8478 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008479 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008480 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008481
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008482 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8483 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00008484 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
8485 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008486
8487 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008488 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008489 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008490
Zachary Turner10d75b22014-10-22 20:40:43 +00008491 if (!llvm::sys::Process::GetEnv("LIB")) {
8492 // If the VC environment hasn't been configured (perhaps because the user
8493 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00008494 // the environment variable is set however, assume the user knows what
8495 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00008496 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008497 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00008498 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8499 SmallString<128> LibDir(VisualStudioDir);
8500 llvm::sys::path::append(LibDir, "VC", "lib");
8501 switch (MSVC.getArch()) {
8502 case llvm::Triple::x86:
8503 // x86 just puts the libraries directly in lib
8504 break;
8505 case llvm::Triple::x86_64:
8506 llvm::sys::path::append(LibDir, "amd64");
8507 break;
8508 case llvm::Triple::arm:
8509 llvm::sys::path::append(LibDir, "arm");
8510 break;
8511 default:
8512 break;
8513 }
8514 CmdArgs.push_back(
8515 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8516 }
8517
8518 std::string WindowsSdkLibPath;
8519 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8520 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8521 WindowsSdkLibPath.c_str()));
8522 }
8523
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008524 CmdArgs.push_back("-nologo");
8525
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008526 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008527 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008528
Hans Wennborge4c47f22015-03-04 23:16:21 +00008529 bool DLL = Args.hasArg(options::OPT__SLASH_LD,
8530 options::OPT__SLASH_LDd,
8531 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00008532 if (DLL) {
8533 CmdArgs.push_back(Args.MakeArgString("-dll"));
8534
8535 SmallString<128> ImplibName(Output.getFilename());
8536 llvm::sys::path::replace_extension(ImplibName, "lib");
8537 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
Yaron Keren92e1b622015-03-18 10:17:07 +00008538 ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00008539 }
8540
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008541 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00008542 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00008543 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008544 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008545 static const char *CompilerRTComponents[] = {
8546 "asan_dynamic",
8547 "asan_dynamic_runtime_thunk",
8548 };
8549 for (const auto &Component : CompilerRTComponents)
8550 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00008551 // Make sure the dynamic runtime thunk is not optimized out at link time
8552 // to ensure proper SEH handling.
8553 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008554 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008555 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008556 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008557 static const char *CompilerRTComponents[] = {
8558 "asan",
8559 "asan_cxx",
8560 };
8561 for (const auto &Component : CompilerRTComponents)
8562 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008563 }
Hans Wennborg65f17522013-08-27 18:10:21 +00008564 }
8565
Hans Wennborg2e274592013-08-13 23:38:57 +00008566 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00008567
Reid Kleckner337188f2014-09-16 19:22:00 +00008568 // Add filenames, libraries, and other linker inputs.
8569 for (const auto &Input : Inputs) {
8570 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008571 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00008572 continue;
8573 }
8574
8575 const Arg &A = Input.getInputArg();
8576
8577 // Render -l options differently for the MSVC linker.
8578 if (A.getOption().matches(options::OPT_l)) {
8579 StringRef Lib = A.getValue();
8580 const char *LinkLibArg;
8581 if (Lib.endswith(".lib"))
8582 LinkLibArg = Args.MakeArgString(Lib);
8583 else
8584 LinkLibArg = Args.MakeArgString(Lib + ".lib");
8585 CmdArgs.push_back(LinkLibArg);
8586 continue;
8587 }
8588
8589 // Otherwise, this is some other kind of linker input option like -Wl, -z,
8590 // or -L. Render it, even if MSVC doesn't understand it.
8591 A.renderAsInput(Args, CmdArgs);
8592 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008593
Zachary Turner719f58c2014-12-01 23:06:47 +00008594 // We need to special case some linker paths. In the case of lld, we need to
8595 // translate 'lld' into 'lld-link', and in the case of the regular msvc
8596 // linker, we need to use a special search algorithm.
8597 llvm::SmallString<128> linkPath;
8598 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8599 if (Linker.equals_lower("lld"))
8600 Linker = "lld-link";
8601
8602 if (Linker.equals_lower("link")) {
8603 // If we're using the MSVC linker, it's not sufficient to just use link
8604 // from the program PATH, because other environments like GnuWin32 install
8605 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008606 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008607 C.getDriver().getClangProgramPath());
8608 } else {
8609 linkPath = Linker;
8610 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008611 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008612 }
8613
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008614 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00008615 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008616}
Hans Wennborg87cfa712013-09-19 20:32:16 +00008617
8618void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
8619 const InputInfo &Output,
8620 const InputInfoList &Inputs,
8621 const ArgList &Args,
8622 const char *LinkingOutput) const {
8623 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8624}
8625
David Blaikiec11bf802014-09-04 16:04:28 +00008626std::unique_ptr<Command> visualstudio::Compile::GetCommand(
8627 Compilation &C, const JobAction &JA, const InputInfo &Output,
8628 const InputInfoList &Inputs, const ArgList &Args,
8629 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00008630 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00008631 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008632 CmdArgs.push_back("/c"); // Compile only.
8633 CmdArgs.push_back("/W0"); // No warnings.
8634
8635 // The goal is to be able to invoke this tool correctly based on
8636 // any flag accepted by clang-cl.
8637
8638 // These are spelled the same way in clang and cl.exe,.
8639 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8640 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008641
8642 // Optimization level.
8643 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8644 if (A->getOption().getID() == options::OPT_O0) {
8645 CmdArgs.push_back("/Od");
8646 } else {
8647 StringRef OptLevel = A->getValue();
8648 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8649 A->render(Args, CmdArgs);
8650 else if (OptLevel == "3")
8651 CmdArgs.push_back("/Ox");
8652 }
8653 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008654
Nico Weber3f8dafb2015-03-12 19:37:10 +00008655 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00008656 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8657
David Majnemerf6072342014-07-01 22:24:56 +00008658 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8659 /*default=*/false))
8660 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008661 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8662 options::OPT_fno_function_sections))
8663 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8664 ? "/Gy"
8665 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008666 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8667 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008668 CmdArgs.push_back(
8669 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008670 if (Args.hasArg(options::OPT_fsyntax_only))
8671 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008672 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8673 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008674
Nico Weber3f8dafb2015-03-12 19:37:10 +00008675 std::vector<std::string> Includes =
8676 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008677 for (const auto &Include : Includes)
8678 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008679
Hans Wennborg87cfa712013-09-19 20:32:16 +00008680 // Flags that can simply be passed through.
8681 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8682 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008683 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008684
8685 // The order of these flags is relevant, so pick the last one.
8686 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8687 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8688 A->render(Args, CmdArgs);
8689
8690
8691 // Input filename.
8692 assert(Inputs.size() == 1);
8693 const InputInfo &II = Inputs[0];
8694 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8695 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8696 if (II.isFilename())
8697 CmdArgs.push_back(II.getFilename());
8698 else
8699 II.getInputArg().renderAsInput(Args, CmdArgs);
8700
8701 // Output filename.
8702 assert(Output.getType() == types::TY_Object);
8703 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8704 Output.getFilename());
8705 CmdArgs.push_back(Fo);
8706
Hans Wennborg188382e2013-09-20 18:16:35 +00008707 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008708 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8709 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008710 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8711 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008712}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008713
8714
8715/// XCore Tools
8716// We pass assemble and link construction to the xcc tool.
8717
8718void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8719 const InputInfo &Output,
8720 const InputInfoList &Inputs,
8721 const ArgList &Args,
8722 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008723 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008724 ArgStringList CmdArgs;
8725
8726 CmdArgs.push_back("-o");
8727 CmdArgs.push_back(Output.getFilename());
8728
8729 CmdArgs.push_back("-c");
8730
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008731 if (Args.hasArg(options::OPT_v))
8732 CmdArgs.push_back("-v");
8733
Robert Lytton894d25c2014-05-02 09:33:25 +00008734 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8735 if (!A->getOption().matches(options::OPT_g0))
8736 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008737
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008738 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8739 false))
8740 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008741
8742 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8743 options::OPT_Xassembler);
8744
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008745 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008746 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008747
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008748 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008749 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008750}
8751
8752void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8753 const InputInfo &Output,
8754 const InputInfoList &Inputs,
8755 const ArgList &Args,
8756 const char *LinkingOutput) const {
8757 ArgStringList CmdArgs;
8758
8759 if (Output.isFilename()) {
8760 CmdArgs.push_back("-o");
8761 CmdArgs.push_back(Output.getFilename());
8762 } else {
8763 assert(Output.isNothing() && "Invalid output.");
8764 }
8765
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008766 if (Args.hasArg(options::OPT_v))
8767 CmdArgs.push_back("-v");
8768
David Majnemer8de68642014-12-05 08:11:58 +00008769 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008770 CmdArgs.push_back("-fexceptions");
8771
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008772 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8773
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008774 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008775 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008776}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008777
8778void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8779 const InputInfo &Output,
8780 const InputInfoList &Inputs,
8781 const ArgList &Args,
8782 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008783 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008784 const auto &TC =
8785 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8786 ArgStringList CmdArgs;
8787 const char *Exec;
8788
8789 switch (TC.getArch()) {
8790 default: llvm_unreachable("unsupported architecture");
8791 case llvm::Triple::arm:
8792 case llvm::Triple::thumb:
8793 break;
8794 case llvm::Triple::x86:
8795 CmdArgs.push_back("--32");
8796 break;
8797 case llvm::Triple::x86_64:
8798 CmdArgs.push_back("--64");
8799 break;
8800 }
8801
8802 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8803
8804 CmdArgs.push_back("-o");
8805 CmdArgs.push_back(Output.getFilename());
8806
8807 for (const auto &Input : Inputs)
8808 CmdArgs.push_back(Input.getFilename());
8809
8810 const std::string Assembler = TC.GetProgramPath("as");
8811 Exec = Args.MakeArgString(Assembler);
8812
8813 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8814}
8815
8816void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8817 const InputInfo &Output,
8818 const InputInfoList &Inputs,
8819 const ArgList &Args,
8820 const char *LinkingOutput) const {
8821 const auto &TC =
8822 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8823 const llvm::Triple &T = TC.getTriple();
8824 const Driver &D = TC.getDriver();
8825 SmallString<128> EntryPoint;
8826 ArgStringList CmdArgs;
8827 const char *Exec;
8828
8829 // Silence warning for "clang -g foo.o -o foo"
8830 Args.ClaimAllArgs(options::OPT_g_Group);
8831 // and "clang -emit-llvm foo.o -o foo"
8832 Args.ClaimAllArgs(options::OPT_emit_llvm);
8833 // and for "clang -w foo.o -o foo"
8834 Args.ClaimAllArgs(options::OPT_w);
8835 // Other warning options are already handled somewhere else.
8836
8837 if (!D.SysRoot.empty())
8838 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8839
8840 if (Args.hasArg(options::OPT_pie))
8841 CmdArgs.push_back("-pie");
8842 if (Args.hasArg(options::OPT_rdynamic))
8843 CmdArgs.push_back("-export-dynamic");
8844 if (Args.hasArg(options::OPT_s))
8845 CmdArgs.push_back("--strip-all");
8846
8847 CmdArgs.push_back("-m");
8848 switch (TC.getArch()) {
8849 default: llvm_unreachable("unsupported architecture");
8850 case llvm::Triple::arm:
8851 case llvm::Triple::thumb:
8852 // FIXME: this is incorrect for WinCE
8853 CmdArgs.push_back("thumb2pe");
8854 break;
8855 case llvm::Triple::x86:
8856 CmdArgs.push_back("i386pe");
8857 EntryPoint.append("_");
8858 break;
8859 case llvm::Triple::x86_64:
8860 CmdArgs.push_back("i386pep");
8861 break;
8862 }
8863
8864 if (Args.hasArg(options::OPT_shared)) {
8865 switch (T.getArch()) {
8866 default: llvm_unreachable("unsupported architecture");
8867 case llvm::Triple::arm:
8868 case llvm::Triple::thumb:
8869 case llvm::Triple::x86_64:
8870 EntryPoint.append("_DllMainCRTStartup");
8871 break;
8872 case llvm::Triple::x86:
8873 EntryPoint.append("_DllMainCRTStartup@12");
8874 break;
8875 }
8876
8877 CmdArgs.push_back("-shared");
8878 CmdArgs.push_back("-Bdynamic");
8879
8880 CmdArgs.push_back("--enable-auto-image-base");
8881
8882 CmdArgs.push_back("--entry");
8883 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8884 } else {
8885 EntryPoint.append("mainCRTStartup");
8886
8887 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
8888 : "-Bdynamic");
8889
8890 if (!Args.hasArg(options::OPT_nostdlib) &&
8891 !Args.hasArg(options::OPT_nostartfiles)) {
8892 CmdArgs.push_back("--entry");
8893 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8894 }
8895
8896 // FIXME: handle subsystem
8897 }
8898
8899 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00008900 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008901
8902 CmdArgs.push_back("-o");
8903 CmdArgs.push_back(Output.getFilename());
8904
8905 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
8906 SmallString<261> ImpLib(Output.getFilename());
8907 llvm::sys::path::replace_extension(ImpLib, ".lib");
8908
8909 CmdArgs.push_back("--out-implib");
8910 CmdArgs.push_back(Args.MakeArgString(ImpLib));
8911 }
8912
8913 if (!Args.hasArg(options::OPT_nostdlib) &&
8914 !Args.hasArg(options::OPT_nostartfiles)) {
8915 const std::string CRTPath(D.SysRoot + "/usr/lib/");
8916 const char *CRTBegin;
8917
8918 CRTBegin =
8919 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
8920 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
8921 }
8922
8923 Args.AddAllArgs(CmdArgs, options::OPT_L);
8924
8925 const auto &Paths = TC.getFilePaths();
8926 for (const auto &Path : Paths)
8927 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8928
8929 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
8930
8931 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8932 !Args.hasArg(options::OPT_nodefaultlibs)) {
8933 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
8934 !Args.hasArg(options::OPT_static);
8935 if (StaticCXX)
8936 CmdArgs.push_back("-Bstatic");
8937 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
8938 if (StaticCXX)
8939 CmdArgs.push_back("-Bdynamic");
8940 }
8941
8942 if (!Args.hasArg(options::OPT_nostdlib)) {
8943 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8944 // TODO handle /MT[d] /MD[d]
8945 CmdArgs.push_back("-lmsvcrt");
8946 AddRunTimeLibs(TC, D, CmdArgs, Args);
8947 }
8948 }
8949
8950 const std::string Linker = TC.GetProgramPath("ld");
8951 Exec = Args.MakeArgString(Linker);
8952
8953 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8954}