blob: ba5dad5466f34d97109fb196b0a0a4b57382dc08 [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"
James Y Knight5bdf7ab2015-08-19 15:12:02 +000035#include "llvm/Support/CodeGen.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"
James Y Knight5bdf7ab2015-08-19 15:12:02 +000044#include "llvm/Support/TargetParser.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000045
Ben Langmuir3b7b5402015-02-03 19:28:37 +000046#ifdef LLVM_ON_UNIX
47#include <unistd.h> // For getuid().
48#endif
49
Daniel Dunbar1a093d22009-03-18 06:00:36 +000050using namespace clang::driver;
51using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000052using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000053using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000054
Daniel Dunbar64198ef2009-09-10 01:21:05 +000055/// CheckPreprocessingOptions - Perform some validation of preprocessing
56/// arguments that is shared with gcc.
57static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000058 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
59 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
60 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000061 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000062 << A->getBaseArg().getAsString(Args)
63 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
64 }
65 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000066}
67
Daniel Dunbar4eadb602009-09-10 01:21:12 +000068/// CheckCodeGenerationOptions - Perform some validation of code generation
69/// arguments that is shared with gcc.
70static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
71 // In gcc, only ARM checks this, but it seems reasonable to check universally.
72 if (Args.hasArg(options::OPT_static))
Douglas Katzmana67e50c2015-06-26 15:47:46 +000073 if (const Arg *A =
74 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
75 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
76 << "-static";
Daniel Dunbar4eadb602009-09-10 01:21:12 +000077}
78
Bob Wilsond5aad2a2014-11-04 22:28:48 +000079// Add backslashes to escape spaces and other backslashes.
80// This is used for the space-separated argument list specified with
81// the -dwarf-debug-flags option.
82static void EscapeSpacesAndBackslashes(const char *Arg,
83 SmallVectorImpl<char> &Res) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000084 for (; *Arg; ++Arg) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +000085 switch (*Arg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000086 default:
87 break;
Bob Wilsond5aad2a2014-11-04 22:28:48 +000088 case ' ':
89 case '\\':
90 Res.push_back('\\');
91 break;
92 }
93 Res.push_back(*Arg);
94 }
95}
96
Chris Lattnerbf2803f2010-03-29 17:55:58 +000097// Quote target names for inclusion in GNU Make dependency files.
98// Only the characters '$', '#', ' ', '\t' are quoted.
Douglas Katzmana67e50c2015-06-26 15:47:46 +000099static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000100 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
101 switch (Target[i]) {
102 case ' ':
103 case '\t':
104 // Escape the preceding backslashes
105 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
106 Res.push_back('\\');
107
108 // Escape the space/tab
109 Res.push_back('\\');
110 break;
111 case '$':
112 Res.push_back('$');
113 break;
114 case '#':
115 Res.push_back('\\');
116 break;
117 default:
118 break;
119 }
120
121 Res.push_back(Target[i]);
122 }
123}
124
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000125static void addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
126 const char *ArgName, const char *EnvVar) {
Bill Wendlingc0938f32012-03-12 22:10:06 +0000127 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000128 bool CombinedArg = false;
129
Bill Wendling281ca292012-03-12 21:22:35 +0000130 if (!DirList)
131 return; // Nothing to do.
132
Chad Rosier616e8a52012-10-30 21:42:09 +0000133 StringRef Name(ArgName);
134 if (Name.equals("-I") || Name.equals("-L"))
135 CombinedArg = true;
136
Bill Wendling281ca292012-03-12 21:22:35 +0000137 StringRef Dirs(DirList);
138 if (Dirs.empty()) // Empty string should not add '.'.
139 return;
140
141 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000142 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000143 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000144 if (CombinedArg) {
145 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
146 } else {
147 CmdArgs.push_back(ArgName);
148 CmdArgs.push_back(".");
149 }
Bill Wendling281ca292012-03-12 21:22:35 +0000150 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000151 if (CombinedArg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000152 CmdArgs.push_back(
153 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
Chad Rosier616e8a52012-10-30 21:42:09 +0000154 } else {
155 CmdArgs.push_back(ArgName);
156 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
157 }
Bill Wendling281ca292012-03-12 21:22:35 +0000158 }
Nico Weber89355782012-03-19 15:00:03 +0000159 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000160 }
161
162 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000163 if (CombinedArg) {
164 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
165 } else {
166 CmdArgs.push_back(ArgName);
167 CmdArgs.push_back(".");
168 }
Bill Wendling281ca292012-03-12 21:22:35 +0000169 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000170 if (CombinedArg) {
171 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
172 } else {
173 CmdArgs.push_back(ArgName);
174 CmdArgs.push_back(Args.MakeArgString(Dirs));
175 }
Bill Wendling281ca292012-03-12 21:22:35 +0000176 }
177}
178
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000179static void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
180 const ArgList &Args, ArgStringList &CmdArgs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000181 const Driver &D = TC.getDriver();
182
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000183 // Add extra linker input arguments which are not treated as inputs
184 // (constructed via -Xarch_).
185 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
186
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000187 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000188 if (!TC.HasNativeLLVMSupport()) {
189 // Don't try to pass LLVM inputs unless we have native support.
190 if (II.getType() == types::TY_LLVM_IR ||
191 II.getType() == types::TY_LTO_IR ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000192 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
193 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
Daniel Dunbar54423b22010-09-17 00:24:54 +0000194 }
195
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000196 // Add filenames immediately.
197 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000198 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000199 continue;
200 }
201
202 // Otherwise, this is a linker input argument.
203 const Arg &A = II.getInputArg();
204
205 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000206 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000207 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000208 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000209 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000210 else if (A.getOption().matches(options::OPT_z)) {
211 // Pass -z prefix for gcc linker compatibility.
212 A.claim();
213 A.render(Args, CmdArgs);
214 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000215 A.renderAsInput(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000216 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000217 }
Bill Wendling281ca292012-03-12 21:22:35 +0000218
219 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000220 // and only supported on native toolchains.
221 if (!TC.isCrossCompiling())
222 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000223}
224
John McCall31168b02011-06-15 23:02:42 +0000225/// \brief Determine whether Objective-C automated reference counting is
226/// enabled.
227static bool isObjCAutoRefCount(const ArgList &Args) {
228 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
229}
230
Ted Kremeneke65b0862012-03-06 20:05:56 +0000231/// \brief Determine whether we are linking the ObjC runtime.
232static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000233 if (isObjCAutoRefCount(Args)) {
234 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000235 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000236 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000237 return Args.hasArg(options::OPT_fobjc_link_runtime);
238}
239
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000240static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000241 // Don't forward inputs from the original command line. They are added from
242 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000243 return O.getKind() != Option::InputClass &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000244 !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000245}
246
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000247void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
248 const Driver &D, const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000249 ArgStringList &CmdArgs,
250 const InputInfo &Output,
251 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000252 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000253
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000254 CheckPreprocessingOptions(D, Args);
255
256 Args.AddLastArg(CmdArgs, options::OPT_C);
257 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000258
259 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000260 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000261 (A = Args.getLastArg(options::OPT_MD)) ||
262 (A = Args.getLastArg(options::OPT_MMD))) {
263 // Determine the output location.
264 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000265 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000266 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000267 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000268 } else if (Output.getType() == types::TY_Dependencies) {
269 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000270 } else if (A->getOption().matches(options::OPT_M) ||
271 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000272 DepFile = "-";
273 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000274 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000275 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000276 }
277 CmdArgs.push_back("-dependency-file");
278 CmdArgs.push_back(DepFile);
279
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000280 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000281 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
282 const char *DepTarget;
283
284 // If user provided -o, that is the dependency target, except
285 // when we are only generating a dependency file.
286 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
287 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000288 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000289 } else {
290 // Otherwise derive from the base input.
291 //
292 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000293 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000294 llvm::sys::path::replace_extension(P, "o");
295 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000296 }
297
298 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000299 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000300 QuoteTarget(DepTarget, Quoted);
301 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 }
303
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000304 if (A->getOption().matches(options::OPT_M) ||
305 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000306 CmdArgs.push_back("-sys-header-deps");
Manuel Klimekc68aa162015-03-19 12:00:22 +0000307 if ((isa<PrecompileJobAction>(JA) &&
308 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
309 Args.hasArg(options::OPT_fmodule_file_deps))
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000310 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000311 }
312
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000313 if (Args.hasArg(options::OPT_MG)) {
314 if (!A || A->getOption().matches(options::OPT_MD) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000315 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000316 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000317 CmdArgs.push_back("-MG");
318 }
319
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000320 Args.AddLastArg(CmdArgs, options::OPT_MP);
Paul Robinsond7214a72015-04-27 18:14:32 +0000321 Args.AddLastArg(CmdArgs, options::OPT_MV);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000322
323 // Convert all -MQ <target> args to -MT <quoted target>
Sean Silva14facf32015-06-09 01:57:17 +0000324 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000325 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000326
Daniel Dunbara442fd52010-06-11 22:00:13 +0000327 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000328 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000329 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000330 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000331 CmdArgs.push_back(Args.MakeArgString(Quoted));
332
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000333 // -MT flag - no change
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000334 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000335 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000336 }
337 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000338
Douglas Gregor111af7d2009-04-18 00:34:01 +0000339 // Add -i* options, and automatically translate to
340 // -include-pch/-include-pth for transparent PCH support. It's
341 // wonky, but we include looking for .gch so we can support seamless
342 // replacement into a build system already set up to be generating
343 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000344 bool RenderedImplicitInclude = false;
Sean Silva14facf32015-06-09 01:57:17 +0000345 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000346 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000347 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
348 RenderedImplicitInclude = true;
349
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000350 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000351 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000352
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000353 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000354 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000355 SmallString<128> P(A->getValue());
356 // We want the files to have a name like foo.h.pch. Add a dummy extension
357 // so that replace_extension does the right thing.
358 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000359 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000360 llvm::sys::path::replace_extension(P, "pch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000361 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000362 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000363 }
364
Douglas Gregor111af7d2009-04-18 00:34:01 +0000365 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000366 llvm::sys::path::replace_extension(P, "pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000367 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000368 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000369 }
370
Douglas Gregor111af7d2009-04-18 00:34:01 +0000371 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000372 llvm::sys::path::replace_extension(P, "gch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000373 if (llvm::sys::fs::exists(P)) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000374 FoundPCH = UsePCH;
375 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000376 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000377 }
378
379 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000380 if (IsFirstImplicitInclude) {
381 A->claim();
382 if (UsePCH)
383 CmdArgs.push_back("-include-pch");
384 else
385 CmdArgs.push_back("-include-pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000386 CmdArgs.push_back(Args.MakeArgString(P));
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000387 continue;
388 } else {
389 // Ignore the PCH if not first on command line and emit warning.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000390 D.Diag(diag::warn_drv_pch_not_first_include) << P
391 << A->getAsString(Args);
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000392 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000393 }
394 }
395
396 // Not translated, render as usual.
397 A->claim();
398 A->render(Args, CmdArgs);
399 }
400
Douglas Katzman57a9c7e2015-07-29 18:39:14 +0000401 Args.AddAllArgs(CmdArgs,
402 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
403 options::OPT_F, options::OPT_index_header_map});
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000404
405 // Add -Wp, and -Xassembler if using the preprocessor.
406
407 // FIXME: There is a very unfortunate problem here, some troubled
408 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
409 // really support that we would have to parse and then translate
410 // those options. :(
411 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
412 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000413
414 // -I- is a deprecated GCC feature, reject it.
415 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000416 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000417
418 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
419 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000420 StringRef sysroot = C.getSysRoot();
421 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000422 if (!Args.hasArg(options::OPT_isysroot)) {
423 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000424 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000425 }
426 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000427
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000428 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000429 // FIXME: We should probably sink the logic for handling these from the
430 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000431 // CPATH - included following the user specified includes (but prior to
432 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000433 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000434 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000435 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000436 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000437 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000438 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000439 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000440 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000441 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000442
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000443 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000444 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000445 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000446
447 // Add system include arguments.
448 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000449}
450
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000451// FIXME: Move to target hook.
452static bool isSignedCharDefault(const llvm::Triple &Triple) {
453 switch (Triple.getArch()) {
454 default:
455 return true;
456
Tim Northover9bb857a2013-01-31 12:13:10 +0000457 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000458 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000459 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000460 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000461 case llvm::Triple::thumb:
462 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000463 if (Triple.isOSDarwin() || Triple.isOSWindows())
464 return true;
465 return false;
466
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000467 case llvm::Triple::ppc:
468 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000469 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000470 return true;
471 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000472
David Majnemerdcecd932015-05-23 19:23:55 +0000473 case llvm::Triple::hexagon:
Bill Schmidt778d3872013-07-26 01:36:11 +0000474 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000475 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000476 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000477 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000478 }
479}
480
Robert Lytton0e076492013-08-13 09:43:10 +0000481static bool isNoCommonDefault(const llvm::Triple &Triple) {
482 switch (Triple.getArch()) {
483 default:
484 return false;
485
486 case llvm::Triple::xcore:
487 return true;
488 }
489}
490
Renato Goline17c5802015-07-27 23:44:42 +0000491// ARM tools start.
492
493// Get SubArch (vN).
494static int getARMSubArchVersionNumber(const llvm::Triple &Triple) {
495 llvm::StringRef Arch = Triple.getArchName();
496 return llvm::ARMTargetParser::parseArchVersion(Arch);
497}
498
499// True if M-profile.
500static bool isARMMProfile(const llvm::Triple &Triple) {
501 llvm::StringRef Arch = Triple.getArchName();
502 unsigned Profile = llvm::ARMTargetParser::parseArchProfile(Arch);
503 return Profile == llvm::ARM::PK_M;
504}
505
506// Get Arch/CPU from args.
Renato Golin7c542b42015-07-27 23:44:45 +0000507static void getARMArchCPUFromArgs(const ArgList &Args, llvm::StringRef &Arch,
508 llvm::StringRef &CPU, bool FromAs = false) {
Renato Goline17c5802015-07-27 23:44:42 +0000509 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
510 CPU = A->getValue();
511 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
512 Arch = A->getValue();
Renato Golin7c542b42015-07-27 23:44:45 +0000513 if (!FromAs)
514 return;
515
516 for (const Arg *A :
517 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
518 StringRef Value = A->getValue();
519 if (Value.startswith("-mcpu="))
520 CPU = Value.substr(6);
521 if (Value.startswith("-march="))
522 Arch = Value.substr(7);
523 }
Renato Goline17c5802015-07-27 23:44:42 +0000524}
525
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000526// Handle -mhwdiv=.
Renato Golin7c542b42015-07-27 23:44:45 +0000527// FIXME: Use ARMTargetParser.
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000528static void getARMHWDivFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000529 const ArgList &Args, StringRef HWDiv,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000530 std::vector<const char *> &Features) {
Alexandros Lamprinease5b47642015-07-28 09:08:03 +0000531 unsigned HWDivID = llvm::ARMTargetParser::parseHWDiv(HWDiv);
532 if (!llvm::ARMTargetParser::getHWDivFeatures(HWDivID, Features))
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000533 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
534}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000535
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000536// Handle -mfpu=.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000537static void getARMFPUFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000538 const ArgList &Args, StringRef FPU,
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000539 std::vector<const char *> &Features) {
John Brawn5a589ad2015-06-05 13:34:11 +0000540 unsigned FPUID = llvm::ARMTargetParser::parseFPU(FPU);
541 if (!llvm::ARMTargetParser::getFPUFeatures(FPUID, Features))
Chad Rosiercfbfc582012-04-04 20:51:35 +0000542 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
543}
544
Renato Golin7c542b42015-07-27 23:44:45 +0000545// Check if -march is valid by checking if it can be canonicalised and parsed.
546// getARMArch is used here instead of just checking the -march value in order
547// to handle -march=native correctly.
548static void checkARMArchName(const Driver &D, const Arg *A, const ArgList &Args,
Renato Goline17c5802015-07-27 23:44:42 +0000549 llvm::StringRef ArchName,
550 const llvm::Triple &Triple) {
551 std::string MArch = arm::getARMArch(ArchName, Triple);
552 if (llvm::ARMTargetParser::parseArch(MArch) == llvm::ARM::AK_INVALID)
553 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000554}
555
Renato Golin7c542b42015-07-27 23:44:45 +0000556// Check -mcpu=. Needs ArchName to handle -mcpu=generic.
557static void checkARMCPUName(const Driver &D, const Arg *A, const ArgList &Args,
558 llvm::StringRef CPUName, llvm::StringRef ArchName,
Renato Goline17c5802015-07-27 23:44:42 +0000559 const llvm::Triple &Triple) {
560 std::string CPU = arm::getARMTargetCPU(CPUName, ArchName, Triple);
561 std::string Arch = arm::getARMArch(ArchName, Triple);
562 if (strcmp(arm::getLLVMArchSuffixForARM(CPU, Arch), "") == 0)
563 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000564}
565
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000566// Select the float ABI as determined by -msoft-float, -mhard-float, and
567// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000568StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000569 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000570 StringRef FloatABI;
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000571 if (Arg *A =
572 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
573 options::OPT_mfloat_abi_EQ)) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000574 if (A->getOption().matches(options::OPT_msoft_float))
575 FloatABI = "soft";
576 else if (A->getOption().matches(options::OPT_mhard_float))
577 FloatABI = "hard";
578 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000579 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000580 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000581 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Daniel Dunbar78485922009-09-10 23:00:09 +0000582 FloatABI = "soft";
583 }
584 }
585 }
586
587 // If unspecified, choose the default based on the platform.
588 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000589 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000590 case llvm::Triple::Darwin:
591 case llvm::Triple::MacOSX:
592 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000593 // Darwin defaults to "softfp" for v6 and v7.
594 //
John Brawn94fd9632015-05-21 12:19:49 +0000595 if (getARMSubArchVersionNumber(Triple) == 6 ||
596 getARMSubArchVersionNumber(Triple) == 7)
Daniel Dunbar78485922009-09-10 23:00:09 +0000597 FloatABI = "softfp";
598 else
599 FloatABI = "soft";
600 break;
601 }
602
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000603 // FIXME: this is invalid for WindowsCE
604 case llvm::Triple::Win32:
605 FloatABI = "hard";
606 break;
607
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000608 case llvm::Triple::FreeBSD:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000609 switch (Triple.getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +0000610 case llvm::Triple::GNUEABIHF:
611 FloatABI = "hard";
612 break;
613 default:
614 // FreeBSD defaults to soft float
615 FloatABI = "soft";
616 break;
617 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000618 break;
619
Daniel Dunbar78485922009-09-10 23:00:09 +0000620 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000621 switch (Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000622 case llvm::Triple::GNUEABIHF:
623 FloatABI = "hard";
624 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000625 case llvm::Triple::GNUEABI:
626 FloatABI = "softfp";
627 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000628 case llvm::Triple::EABIHF:
629 FloatABI = "hard";
630 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000631 case llvm::Triple::EABI:
632 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
633 FloatABI = "softfp";
634 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000635 case llvm::Triple::Android: {
John Brawn94fd9632015-05-21 12:19:49 +0000636 if (getARMSubArchVersionNumber(Triple) == 7)
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000637 FloatABI = "softfp";
638 else
639 FloatABI = "soft";
640 break;
641 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000642 default:
643 // Assume "soft", but warn the user we are guessing.
644 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000645 if (Triple.getOS() != llvm::Triple::UnknownOS ||
646 !Triple.isOSBinFormatMachO())
647 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000648 break;
649 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000650 }
651 }
652
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000653 return FloatABI;
654}
655
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000656static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
657 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000658 std::vector<const char *> &Features,
659 bool ForAS) {
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000660 bool KernelOrKext =
661 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Nico Weber6e0ebae2015-04-29 21:16:40 +0000662 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Renato Golin7c542b42015-07-27 23:44:45 +0000663 const Arg *WaCPU = nullptr, *WaFPU = nullptr;
664 const Arg *WaHDiv = nullptr, *WaArch = nullptr;
665
Nico Weber6e0ebae2015-04-29 21:16:40 +0000666 if (!ForAS) {
667 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
668 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
669 // stripped out by the ARM target. We should probably pass this a new
670 // -target-option, which is handled by the -cc1/-cc1as invocation.
671 //
672 // FIXME2: For consistency, it would be ideal if we set up the target
673 // machine state the same when using the frontend or the assembler. We don't
674 // currently do that for the assembler, we pass the options directly to the
675 // backend and never even instantiate the frontend TargetInfo. If we did,
676 // and used its handleTargetFeatures hook, then we could ensure the
677 // assembler and the frontend behave the same.
678
679 // Use software floating point operations?
680 if (FloatABI == "soft")
681 Features.push_back("+soft-float");
682
683 // Use software floating point argument passing?
684 if (FloatABI != "hard")
685 Features.push_back("+soft-float-abi");
Renato Golin7c542b42015-07-27 23:44:45 +0000686 } else {
687 // Here, we make sure that -Wa,-mfpu/cpu/arch/hwdiv will be passed down
688 // to the assembler correctly.
689 for (const Arg *A :
690 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
691 StringRef Value = A->getValue();
692 if (Value.startswith("-mfpu=")) {
693 WaFPU = A;
694 } else if (Value.startswith("-mcpu=")) {
695 WaCPU = A;
696 } else if (Value.startswith("-mhwdiv=")) {
697 WaHDiv = A;
698 } else if (Value.startswith("-march=")) {
699 WaArch = A;
700 }
701 }
Nico Weber6e0ebae2015-04-29 21:16:40 +0000702 }
703
Renato Golin7c542b42015-07-27 23:44:45 +0000704 // Check -march. ClangAs gives preference to -Wa,-march=.
705 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000706 StringRef ArchName;
Renato Golin7c542b42015-07-27 23:44:45 +0000707 if (WaArch) {
708 if (ArchArg)
709 D.Diag(clang::diag::warn_drv_unused_argument)
710 << ArchArg->getAsString(Args);
711 ArchName = StringRef(WaArch->getValue()).substr(7);
712 checkARMArchName(D, WaArch, Args, ArchName, Triple);
713 // FIXME: Set Arch.
714 D.Diag(clang::diag::warn_drv_unused_argument) << WaArch->getAsString(Args);
715 } else if (ArchArg) {
716 ArchName = ArchArg->getValue();
717 checkARMArchName(D, ArchArg, Args, ArchName, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000718 }
719
Renato Golin7c542b42015-07-27 23:44:45 +0000720 // Check -mcpu. ClangAs gives preference to -Wa,-mcpu=.
721 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000722 StringRef CPUName;
Renato Golin7c542b42015-07-27 23:44:45 +0000723 if (WaCPU) {
724 if (CPUArg)
725 D.Diag(clang::diag::warn_drv_unused_argument)
726 << CPUArg->getAsString(Args);
727 CPUName = StringRef(WaCPU->getValue()).substr(6);
728 checkARMCPUName(D, WaCPU, Args, CPUName, ArchName, Triple);
729 } else if (CPUArg) {
730 CPUName = CPUArg->getValue();
731 checkARMCPUName(D, CPUArg, Args, CPUName, ArchName, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000732 }
John Brawna95c1a82015-05-08 12:52:18 +0000733
Renato Golin23459c62015-07-30 16:40:17 +0000734 // Add CPU features for generic CPUs
735 if (CPUName == "native") {
736 llvm::StringMap<bool> HostFeatures;
737 if (llvm::sys::getHostCPUFeatures(HostFeatures))
738 for (auto &F : HostFeatures)
739 Features.push_back(
740 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
741 }
742
743 // Honor -mfpu=. ClangAs gives preference to -Wa,-mfpu=.
744 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
745 if (WaFPU) {
746 if (FPUArg)
747 D.Diag(clang::diag::warn_drv_unused_argument)
748 << FPUArg->getAsString(Args);
749 getARMFPUFeatures(D, WaFPU, Args, StringRef(WaFPU->getValue()).substr(6),
750 Features);
751 } else if (FPUArg) {
752 getARMFPUFeatures(D, FPUArg, Args, FPUArg->getValue(), Features);
753 }
754
755 // Honor -mhwdiv=. ClangAs gives preference to -Wa,-mhwdiv=.
756 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
757 if (WaHDiv) {
758 if (HDivArg)
759 D.Diag(clang::diag::warn_drv_unused_argument)
760 << HDivArg->getAsString(Args);
761 getARMHWDivFeatures(D, WaHDiv, Args,
762 StringRef(WaHDiv->getValue()).substr(8), Features);
763 } else if (HDivArg)
764 getARMHWDivFeatures(D, HDivArg, Args, HDivArg->getValue(), Features);
765
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000766 // Setting -msoft-float effectively disables NEON because of the GCC
767 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000768 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000769 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000770 // Also need to explicitly disable features which imply NEON.
771 Features.push_back("-crypto");
772 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000773
Eric Christopher269c2a22015-04-04 03:34:43 +0000774 // En/disable crc code generation.
775 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bernard Ogden18b57012013-10-29 09:47:51 +0000776 if (A->getOption().matches(options::OPT_mcrc))
777 Features.push_back("+crc");
778 else
779 Features.push_back("-crc");
780 }
Vladimir Sukharevc6dab752015-05-14 08:25:18 +0000781
782 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
783 Features.insert(Features.begin(), "+v8.1a");
784 }
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000785
Akira Hatanakac2694822015-07-07 08:28:42 +0000786 // Look for the last occurrence of -mlong-calls or -mno-long-calls. If
787 // neither options are specified, see if we are compiling for kernel/kext and
788 // decide whether to pass "+long-calls" based on the OS and its version.
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000789 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
790 options::OPT_mno_long_calls)) {
791 if (A->getOption().matches(options::OPT_mlong_calls))
792 Features.push_back("+long-calls");
793 } else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6))) {
794 Features.push_back("+long-calls");
795 }
Akira Hatanaka580efb22015-07-16 00:43:00 +0000796
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000797 // Kernel code has more strict alignment requirements.
798 if (KernelOrKext)
799 Features.push_back("+strict-align");
800 else if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
801 options::OPT_munaligned_access)) {
802 if (A->getOption().matches(options::OPT_munaligned_access)) {
803 // No v6M core supports unaligned memory access (v6M ARM ARM A3.2).
804 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
805 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
806 } else
807 Features.push_back("+strict-align");
808 } else {
809 // Assume pre-ARMv6 doesn't support unaligned accesses.
810 //
811 // ARMv6 may or may not support unaligned accesses depending on the
812 // SCTLR.U bit, which is architecture-specific. We assume ARMv6
813 // Darwin and NetBSD targets support unaligned accesses, and others don't.
814 //
815 // ARMv7 always has SCTLR.U set to 1, but it has a new SCTLR.A bit
816 // which raises an alignment fault on unaligned accesses. Linux
817 // defaults this bit to 0 and handles it as a system-wide (not
818 // per-process) setting. It is therefore safe to assume that ARMv7+
819 // Linux targets support unaligned accesses. The same goes for NaCl.
820 //
821 // The above behavior is consistent with GCC.
822 int VersionNum = getARMSubArchVersionNumber(Triple);
823 if (Triple.isOSDarwin() || Triple.isOSNetBSD()) {
824 if (VersionNum < 6)
825 Features.push_back("+strict-align");
826 } else if (Triple.isOSLinux() || Triple.isOSNaCl()) {
827 if (VersionNum < 7)
828 Features.push_back("+strict-align");
829 } else
830 Features.push_back("+strict-align");
831 }
832
Akira Hatanaka0a23fac2015-07-21 01:41:08 +0000833 // llvm does not support reserving registers in general. There is support
834 // for reserving r9 on ARM though (defined as a platform-specific register
835 // in ARM EABI).
836 if (Args.hasArg(options::OPT_ffixed_r9))
837 Features.push_back("+reserve-r9");
838
Akira Hatanaka580efb22015-07-16 00:43:00 +0000839 // The kext linker doesn't know how to deal with movw/movt.
840 if (KernelOrKext)
841 Features.push_back("+no-movt");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000842}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000843
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000844void Clang::AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000845 bool KernelOrKext) const {
846 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000847 // Get the effective triple, which takes into account the deployment target.
848 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
849 llvm::Triple Triple(TripleStr);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000850
851 // Select the ABI to use.
852 //
853 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +0000854 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +0000855 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000856 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000857 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000858 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000859 // The backend is hardwired to assume AAPCS for M-class processors, ensure
860 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000861 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000862 Triple.getOS() == llvm::Triple::UnknownOS || isARMMProfile(Triple)) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000863 ABIName = "aapcs";
864 } else {
865 ABIName = "apcs-gnu";
866 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000867 } else if (Triple.isOSWindows()) {
868 // FIXME: this is invalid for WindowsCE
869 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000870 } else {
871 // Select the default based on the platform.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000872 switch (Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000873 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000874 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000875 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000876 ABIName = "aapcs-linux";
877 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000878 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000879 case llvm::Triple::EABI:
880 ABIName = "aapcs";
881 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000882 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +0000883 if (Triple.getOS() == llvm::Triple::NetBSD)
884 ABIName = "apcs-gnu";
885 else
886 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000887 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000888 }
889 }
890 CmdArgs.push_back("-target-abi");
891 CmdArgs.push_back(ABIName);
892
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000893 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000894 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000895 if (FloatABI == "soft") {
896 // Floating point operations and argument passing are soft.
897 //
898 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000899 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000900 CmdArgs.push_back("-mfloat-abi");
901 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000902 } else if (FloatABI == "softfp") {
903 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000904 CmdArgs.push_back("-mfloat-abi");
905 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000906 } else {
907 // Floating point operations and argument passing are hard.
908 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000909 CmdArgs.push_back("-mfloat-abi");
910 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000911 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000912
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000913 // Forward the -mglobal-merge option for explicit control over the pass.
Chad Rosierba3df1d2011-08-26 00:26:29 +0000914 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
915 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000916 CmdArgs.push_back("-backend-option");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000917 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000918 CmdArgs.push_back("-arm-global-merge=false");
919 else
920 CmdArgs.push_back("-arm-global-merge=true");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000921 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000922
Bob Wilson9c8af452013-04-11 18:53:25 +0000923 if (!Args.hasFlag(options::OPT_mimplicit_float,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000924 options::OPT_mno_implicit_float, true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000925 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000926}
Renato Goline17c5802015-07-27 23:44:42 +0000927// ARM tools end.
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000928
Tim Northover573cbee2014-05-24 12:52:07 +0000929/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
930/// targeting.
931static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000932 Arg *A;
933 std::string CPU;
934 // If we have -mtune or -mcpu, use that.
935 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +0000936 CPU = StringRef(A->getValue()).lower();
Kevin Qin110db6f2014-07-18 07:03:22 +0000937 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
Renato Golin4045f662015-05-08 15:44:36 +0000938 StringRef Mcpu = A->getValue();
Gabor Ballabas726ce7f2015-06-12 17:33:37 +0000939 CPU = Mcpu.split("+").first.lower();
Tim Northovera2ee4332014-03-29 15:09:45 +0000940 }
941
Kevin Qin110db6f2014-07-18 07:03:22 +0000942 // Handle CPU name is 'native'.
943 if (CPU == "native")
944 return llvm::sys::getHostCPUName();
945 else if (CPU.size())
946 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000947
James Molloy9b1586b2014-04-17 12:51:17 +0000948 // Make sure we pick "cyclone" if -arch is used.
949 // FIXME: Should this be picked by checking the target triple instead?
950 if (Args.getLastArg(options::OPT_arch))
951 return "cyclone";
952
953 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000954}
955
Tim Northover573cbee2014-05-24 12:52:07 +0000956void Clang::AddAArch64TargetArgs(const ArgList &Args,
957 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000958 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
959 llvm::Triple Triple(TripleStr);
960
961 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
962 Args.hasArg(options::OPT_mkernel) ||
963 Args.hasArg(options::OPT_fapple_kext))
964 CmdArgs.push_back("-disable-red-zone");
965
966 if (!Args.hasFlag(options::OPT_mimplicit_float,
967 options::OPT_mno_implicit_float, true))
968 CmdArgs.push_back("-no-implicit-float");
969
Craig Topper92fc2df2014-05-17 16:56:41 +0000970 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000971 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
972 ABIName = A->getValue();
973 else if (Triple.isOSDarwin())
974 ABIName = "darwinpcs";
975 else
976 ABIName = "aapcs";
977
978 CmdArgs.push_back("-target-abi");
979 CmdArgs.push_back(ABIName);
980
Bradley Smith9ff64332014-10-13 10:16:06 +0000981 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
982 options::OPT_mno_fix_cortex_a53_835769)) {
983 CmdArgs.push_back("-backend-option");
984 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
985 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
986 else
987 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Bradley Smith04ee8aa2014-10-16 16:35:14 +0000988 } else if (Triple.getEnvironment() == llvm::Triple::Android) {
989 // Enabled A53 errata (835769) workaround by default on android
990 CmdArgs.push_back("-backend-option");
991 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +0000992 }
993
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000994 // Forward the -mglobal-merge option for explicit control over the pass.
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000995 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
996 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000997 CmdArgs.push_back("-backend-option");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000998 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000999 CmdArgs.push_back("-aarch64-global-merge=false");
1000 else
1001 CmdArgs.push_back("-aarch64-global-merge=true");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001002 }
Tim Northovera2ee4332014-03-29 15:09:45 +00001003}
1004
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001005// Get CPU and ABI names. They are not independent
1006// so we have to calculate them together.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001007void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple,
1008 StringRef &CPUName, StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00001009 const char *DefMips32CPU = "mips32r2";
1010 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +00001011
Daniel Sanders2bf13662014-07-10 14:40:57 +00001012 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
1013 // default for mips64(el)?-img-linux-gnu.
1014 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1015 Triple.getEnvironment() == llvm::Triple::GNU) {
1016 DefMips32CPU = "mips32r6";
1017 DefMips64CPU = "mips64r6";
1018 }
Renato Golin7c542b42015-07-27 23:44:45 +00001019
Petar Jovanovic9fe32cd2015-07-17 12:57:30 +00001020 // MIPS64r6 is the default for Android MIPS64 (mips64el-linux-android).
1021 if (Triple.getEnvironment() == llvm::Triple::Android)
1022 DefMips64CPU = "mips64r6";
Daniel Sanders2bf13662014-07-10 14:40:57 +00001023
Brad Smithba26f582015-01-06 02:53:17 +00001024 // MIPS3 is the default for mips64*-unknown-openbsd.
1025 if (Triple.getOS() == llvm::Triple::OpenBSD)
1026 DefMips64CPU = "mips3";
1027
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001028 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
Simon Atanasyane0cc7c72013-10-09 12:12:24 +00001029 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001030
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001031 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001032 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001033 // Convert a GNU style Mips ABI name to the name
1034 // accepted by LLVM Mips backend.
1035 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001036 .Case("32", "o32")
1037 .Case("64", "n64")
1038 .Default(ABIName);
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001039 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001040
1041 // Setup default CPU and ABI names.
1042 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001043 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001044 default:
1045 llvm_unreachable("Unexpected triple arch name");
1046 case llvm::Triple::mips:
1047 case llvm::Triple::mipsel:
1048 CPUName = DefMips32CPU;
1049 break;
1050 case llvm::Triple::mips64:
1051 case llvm::Triple::mips64el:
1052 CPUName = DefMips64CPU;
1053 break;
1054 }
1055 }
1056
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001057 if (ABIName.empty()) {
1058 // Deduce ABI name from the target triple.
1059 if (Triple.getArch() == llvm::Triple::mips ||
1060 Triple.getArch() == llvm::Triple::mipsel)
1061 ABIName = "o32";
1062 else
1063 ABIName = "n64";
1064 }
1065
1066 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001067 // Deduce CPU name from ABI name.
1068 CPUName = llvm::StringSwitch<const char *>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001069 .Cases("o32", "eabi", DefMips32CPU)
1070 .Cases("n32", "n64", DefMips64CPU)
1071 .Default("");
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001072 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001073
1074 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001075}
1076
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001077// Convert ABI name to the GNU tools acceptable variant.
1078static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1079 return llvm::StringSwitch<llvm::StringRef>(ABI)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001080 .Case("o32", "32")
1081 .Case("n64", "64")
1082 .Default(ABI);
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001083}
1084
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001085// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1086// and -mfloat-abi=.
1087static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001088 StringRef FloatABI;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001089 if (Arg *A =
1090 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1091 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001092 if (A->getOption().matches(options::OPT_msoft_float))
1093 FloatABI = "soft";
1094 else if (A->getOption().matches(options::OPT_mhard_float))
1095 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001096 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001097 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001098 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001099 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001100 FloatABI = "hard";
1101 }
1102 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001103 }
1104
1105 // If unspecified, choose the default based on the platform.
1106 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001107 // Assume "hard", because it's a default value used by gcc.
1108 // When we start to recognize specific target MIPS processors,
1109 // we will be able to select the default more correctly.
1110 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001111 }
1112
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001113 return FloatABI;
1114}
1115
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001116static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001117 std::vector<const char *> &Features,
1118 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001119 StringRef FeatureName) {
1120 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001121 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001122 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001123 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001124 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001125 }
1126}
1127
Daniel Sanders379d44b2014-07-16 11:52:23 +00001128static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1129 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001130 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001131 StringRef CPUName;
1132 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001133 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001134 ABIName = getGnuCompatibleMipsABIName(ABIName);
1135
Daniel Sandersfeb61302014-08-08 15:47:17 +00001136 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1137 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001138
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001139 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001140 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001141 // FIXME: Note, this is a hack. We need to pass the selected float
1142 // mode to the MipsTargetInfoBase to define appropriate macros there.
1143 // Now it is the only method.
1144 Features.push_back("+soft-float");
1145 }
1146
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001147 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001148 StringRef Val = StringRef(A->getValue());
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00001149 if (Val == "2008") {
1150 if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1151 Features.push_back("+nan2008");
1152 else {
1153 Features.push_back("-nan2008");
1154 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1155 }
1156 } else if (Val == "legacy") {
1157 if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1158 Features.push_back("-nan2008");
1159 else {
1160 Features.push_back("+nan2008");
1161 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1162 }
1163 } else
Matheus Almeida602bff32014-05-07 16:16:07 +00001164 D.Diag(diag::err_drv_unsupported_option_argument)
1165 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001166 }
1167
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001168 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1169 options::OPT_mdouble_float, "single-float");
1170 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1171 "mips16");
1172 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1173 options::OPT_mno_micromips, "micromips");
1174 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1175 "dsp");
1176 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1177 "dspr2");
1178 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1179 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001180
1181 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1182 // pass -mfpxx
1183 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1184 options::OPT_mfp64)) {
1185 if (A->getOption().matches(options::OPT_mfp32))
1186 Features.push_back(Args.MakeArgString("-fp64"));
1187 else if (A->getOption().matches(options::OPT_mfpxx)) {
1188 Features.push_back(Args.MakeArgString("+fpxx"));
1189 Features.push_back(Args.MakeArgString("+nooddspreg"));
1190 } else
1191 Features.push_back(Args.MakeArgString("+fp64"));
Toma Tabacu94ea6862015-06-16 13:54:13 +00001192 } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001193 Features.push_back(Args.MakeArgString("+fpxx"));
1194 Features.push_back(Args.MakeArgString("+nooddspreg"));
1195 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001196
Daniel Sanders28e5d392014-07-10 10:39:51 +00001197 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1198 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001199}
1200
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001201void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001202 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001203 const Driver &D = getToolChain().getDriver();
1204 StringRef CPUName;
1205 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001206 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001207 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001208
1209 CmdArgs.push_back("-target-abi");
1210 CmdArgs.push_back(ABIName.data());
1211
1212 StringRef FloatABI = getMipsFloatABI(D, Args);
1213
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001214 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001215 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001216 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001217 CmdArgs.push_back("-mfloat-abi");
1218 CmdArgs.push_back("soft");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001219 } else {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001220 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001221 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001222 CmdArgs.push_back("-mfloat-abi");
1223 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001224 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001225
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001226 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1227 if (A->getOption().matches(options::OPT_mxgot)) {
1228 CmdArgs.push_back("-mllvm");
1229 CmdArgs.push_back("-mxgot");
1230 }
1231 }
1232
Simon Atanasyanc580b322013-05-11 06:33:44 +00001233 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1234 options::OPT_mno_ldc1_sdc1)) {
1235 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1236 CmdArgs.push_back("-mllvm");
1237 CmdArgs.push_back("-mno-ldc1-sdc1");
1238 }
1239 }
1240
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001241 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1242 options::OPT_mno_check_zero_division)) {
1243 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1244 CmdArgs.push_back("-mllvm");
1245 CmdArgs.push_back("-mno-check-zero-division");
1246 }
1247 }
1248
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001249 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001250 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001251 CmdArgs.push_back("-mllvm");
1252 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1253 A->claim();
1254 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001255}
1256
Hal Finkel8eb59282012-06-11 22:35:19 +00001257/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1258static std::string getPPCTargetCPU(const ArgList &Args) {
1259 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001260 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001261
1262 if (CPUName == "native") {
1263 std::string CPU = llvm::sys::getHostCPUName();
1264 if (!CPU.empty() && CPU != "generic")
1265 return CPU;
1266 else
1267 return "";
1268 }
1269
1270 return llvm::StringSwitch<const char *>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001271 .Case("common", "generic")
1272 .Case("440", "440")
1273 .Case("440fp", "440")
1274 .Case("450", "450")
1275 .Case("601", "601")
1276 .Case("602", "602")
1277 .Case("603", "603")
1278 .Case("603e", "603e")
1279 .Case("603ev", "603ev")
1280 .Case("604", "604")
1281 .Case("604e", "604e")
1282 .Case("620", "620")
1283 .Case("630", "pwr3")
1284 .Case("G3", "g3")
1285 .Case("7400", "7400")
1286 .Case("G4", "g4")
1287 .Case("7450", "7450")
1288 .Case("G4+", "g4+")
1289 .Case("750", "750")
1290 .Case("970", "970")
1291 .Case("G5", "g5")
1292 .Case("a2", "a2")
1293 .Case("a2q", "a2q")
1294 .Case("e500mc", "e500mc")
1295 .Case("e5500", "e5500")
1296 .Case("power3", "pwr3")
1297 .Case("power4", "pwr4")
1298 .Case("power5", "pwr5")
1299 .Case("power5x", "pwr5x")
1300 .Case("power6", "pwr6")
1301 .Case("power6x", "pwr6x")
1302 .Case("power7", "pwr7")
1303 .Case("power8", "pwr8")
1304 .Case("pwr3", "pwr3")
1305 .Case("pwr4", "pwr4")
1306 .Case("pwr5", "pwr5")
1307 .Case("pwr5x", "pwr5x")
1308 .Case("pwr6", "pwr6")
1309 .Case("pwr6x", "pwr6x")
1310 .Case("pwr7", "pwr7")
1311 .Case("pwr8", "pwr8")
1312 .Case("powerpc", "ppc")
1313 .Case("powerpc64", "ppc64")
1314 .Case("powerpc64le", "ppc64le")
1315 .Default("");
Hal Finkel8eb59282012-06-11 22:35:19 +00001316 }
1317
1318 return "";
1319}
1320
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001321static void getPPCTargetFeatures(const ArgList &Args,
1322 std::vector<const char *> &Features) {
Sean Silva14facf32015-06-09 01:57:17 +00001323 for (const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1324 StringRef Name = A->getOption().getName();
1325 A->claim();
Eric Christopher643bb6a2013-10-16 20:40:08 +00001326
1327 // Skip over "-m".
1328 assert(Name.startswith("m") && "Invalid feature name.");
1329 Name = Name.substr(1);
1330
1331 bool IsNegative = Name.startswith("no-");
1332 if (IsNegative)
1333 Name = Name.substr(3);
1334
1335 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1336 // pass the correct option to the backend while calling the frontend
1337 // option the same.
1338 // TODO: Change the LLVM backend option maybe?
1339 if (Name == "mfcrf")
1340 Name = "mfocrf";
1341
1342 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1343 }
1344
1345 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001346 AddTargetFeature(Args, Features, options::OPT_faltivec,
1347 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001348}
1349
Ulrich Weigand8afad612014-07-28 13:17:52 +00001350void Clang::AddPPCTargetArgs(const ArgList &Args,
1351 ArgStringList &CmdArgs) const {
1352 // Select the ABI to use.
1353 const char *ABIName = nullptr;
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001354 if (getToolChain().getTriple().isOSLinux())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001355 switch (getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001356 case llvm::Triple::ppc64: {
1357 // When targeting a processor that supports QPX, or if QPX is
1358 // specifically enabled, default to using the ABI that supports QPX (so
1359 // long as it is not specifically disabled).
1360 bool HasQPX = false;
1361 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1362 HasQPX = A->getValue() == StringRef("a2q");
1363 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1364 if (HasQPX) {
1365 ABIName = "elfv1-qpx";
1366 break;
1367 }
1368
Ulrich Weigand8afad612014-07-28 13:17:52 +00001369 ABIName = "elfv1";
1370 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001371 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001372 case llvm::Triple::ppc64le:
1373 ABIName = "elfv2";
1374 break;
1375 default:
1376 break;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001377 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001378
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001379 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1380 // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
1381 // the option if given as we don't have backend support for any targets
1382 // that don't use the altivec abi.
1383 if (StringRef(A->getValue()) != "altivec")
1384 ABIName = A->getValue();
1385
Ulrich Weigand8afad612014-07-28 13:17:52 +00001386 if (ABIName) {
1387 CmdArgs.push_back("-target-abi");
1388 CmdArgs.push_back(ABIName);
1389 }
1390}
1391
1392bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1393 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1394 return A && (A->getValue() == StringRef(Value));
1395}
1396
Tom Stellard6674c702013-04-01 20:56:53 +00001397/// Get the (LLVM) name of the R600 gpu we are targeting.
1398static std::string getR600TargetGPU(const ArgList &Args) {
1399 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001400 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001401 return llvm::StringSwitch<const char *>(GPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001402 .Cases("rv630", "rv635", "r600")
1403 .Cases("rv610", "rv620", "rs780", "rs880")
1404 .Case("rv740", "rv770")
1405 .Case("palm", "cedar")
1406 .Cases("sumo", "sumo2", "sumo")
1407 .Case("hemlock", "cypress")
1408 .Case("aruba", "cayman")
1409 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001410 }
1411 return "";
1412}
1413
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001414void Clang::AddSparcTargetArgs(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001415 ArgStringList &CmdArgs) const {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001416 const Driver &D = getToolChain().getDriver();
James Y Knightb2406522015-06-15 20:51:24 +00001417 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001418
James Y Knightb2406522015-06-15 20:51:24 +00001419 bool SoftFloatABI = false;
1420 if (Arg *A =
1421 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001422 if (A->getOption().matches(options::OPT_msoft_float))
James Y Knightb2406522015-06-15 20:51:24 +00001423 SoftFloatABI = true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001424 }
1425
James Y Knightb2406522015-06-15 20:51:24 +00001426 // Only the hard-float ABI on Sparc is standardized, and it is the
1427 // default. GCC also supports a nonstandard soft-float ABI mode, and
1428 // perhaps LLVM should implement that, too. However, since llvm
1429 // currently does not support Sparc soft-float, at all, display an
1430 // error if it's requested.
1431 if (SoftFloatABI) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001432 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-msoft-float"
1433 << Triple;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001434 }
1435}
1436
Richard Sandiford4652d892013-07-19 16:51:51 +00001437static const char *getSystemZTargetCPU(const ArgList &Args) {
1438 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1439 return A->getValue();
1440 return "z10";
1441}
1442
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001443static void getSystemZTargetFeatures(const ArgList &Args,
1444 std::vector<const char *> &Features) {
1445 // -m(no-)htm overrides use of the transactional-execution facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001446 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001447 if (A->getOption().matches(options::OPT_mhtm))
1448 Features.push_back("+transactional-execution");
1449 else
1450 Features.push_back("-transactional-execution");
1451 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001452 // -m(no-)vx overrides use of the vector facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001453 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001454 if (A->getOption().matches(options::OPT_mvx))
1455 Features.push_back("+vector");
1456 else
1457 Features.push_back("-vector");
1458 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001459}
1460
Chandler Carruth953fb082013-01-13 11:46:33 +00001461static const char *getX86TargetCPU(const ArgList &Args,
1462 const llvm::Triple &Triple) {
1463 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001464 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001465 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001466 return "core-avx2";
1467
Chandler Carruth953fb082013-01-13 11:46:33 +00001468 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001469 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001470
1471 // FIXME: Reject attempts to use -march=native unless the target matches
1472 // the host.
1473 //
1474 // FIXME: We should also incorporate the detected target features for use
1475 // with -native.
1476 std::string CPU = llvm::sys::getHostCPUName();
1477 if (!CPU.empty() && CPU != "generic")
1478 return Args.MakeArgString(CPU);
1479 }
1480
Reid Kleckner3123eff2015-06-30 16:32:04 +00001481 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1482 // Mapping built by referring to X86TargetInfo::getDefaultFeatures().
1483 StringRef Arch = A->getValue();
1484 const char *CPU;
1485 if (Triple.getArch() == llvm::Triple::x86) {
1486 CPU = llvm::StringSwitch<const char *>(Arch)
1487 .Case("IA32", "i386")
1488 .Case("SSE", "pentium3")
1489 .Case("SSE2", "pentium4")
1490 .Case("AVX", "sandybridge")
1491 .Case("AVX2", "haswell")
1492 .Default(nullptr);
1493 } else {
1494 CPU = llvm::StringSwitch<const char *>(Arch)
1495 .Case("AVX", "sandybridge")
1496 .Case("AVX2", "haswell")
1497 .Default(nullptr);
1498 }
1499 if (CPU)
1500 return CPU;
1501 }
1502
Chandler Carruth953fb082013-01-13 11:46:33 +00001503 // Select the default CPU if none was given (or detection failed).
1504
1505 if (Triple.getArch() != llvm::Triple::x86_64 &&
1506 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001507 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001508
1509 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1510
1511 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001512 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001513 if (Triple.getArchName() == "x86_64h")
1514 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001515 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001516 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001517
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001518 // Set up default CPU name for PS4 compilers.
1519 if (Triple.isPS4CPU())
1520 return "btver2";
1521
Alexey Bataev286d1b92014-01-31 04:07:13 +00001522 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001523 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001524 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001525
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001526 // Everything else goes to x86-64 in 64-bit mode.
1527 if (Is64Bit)
1528 return "x86-64";
1529
1530 switch (Triple.getOS()) {
1531 case llvm::Triple::FreeBSD:
1532 case llvm::Triple::NetBSD:
1533 case llvm::Triple::OpenBSD:
1534 return "i486";
1535 case llvm::Triple::Haiku:
1536 return "i586";
1537 case llvm::Triple::Bitrig:
1538 return "i686";
1539 default:
1540 // Fallback to p4.
1541 return "pentium4";
1542 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001543}
1544
Renato Golin7c542b42015-07-27 23:44:45 +00001545static std::string getCPUName(const ArgList &Args, const llvm::Triple &T,
1546 bool FromAs = false) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001547 switch (T.getArch()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001548 default:
1549 return "";
1550
Amara Emerson703da2e2013-10-31 09:32:33 +00001551 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001552 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001553 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001554
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001555 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001556 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001557 case llvm::Triple::thumb:
Renato Goline17c5802015-07-27 23:44:42 +00001558 case llvm::Triple::thumbeb: {
1559 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00001560 getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs);
Renato Goline17c5802015-07-27 23:44:42 +00001561 return arm::getARMTargetCPU(MCPU, MArch, T);
1562 }
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001563 case llvm::Triple::mips:
1564 case llvm::Triple::mipsel:
1565 case llvm::Triple::mips64:
1566 case llvm::Triple::mips64el: {
1567 StringRef CPUName;
1568 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001569 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001570 return CPUName;
1571 }
1572
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001573 case llvm::Triple::nvptx:
1574 case llvm::Triple::nvptx64:
1575 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1576 return A->getValue();
1577 return "";
1578
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001579 case llvm::Triple::ppc:
1580 case llvm::Triple::ppc64:
1581 case llvm::Triple::ppc64le: {
1582 std::string TargetCPUName = getPPCTargetCPU(Args);
1583 // LLVM may default to generating code for the native CPU,
1584 // but, like gcc, we default to a more generic option for
1585 // each architecture. (except on Darwin)
1586 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1587 if (T.getArch() == llvm::Triple::ppc64)
1588 TargetCPUName = "ppc64";
1589 else if (T.getArch() == llvm::Triple::ppc64le)
1590 TargetCPUName = "ppc64le";
1591 else
1592 TargetCPUName = "ppc";
1593 }
1594 return TargetCPUName;
1595 }
1596
1597 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001598 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001599 case llvm::Triple::sparcv9:
1600 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001601 return A->getValue();
1602 return "";
1603
1604 case llvm::Triple::x86:
1605 case llvm::Triple::x86_64:
1606 return getX86TargetCPU(Args, T);
1607
1608 case llvm::Triple::hexagon:
Douglas Katzman54366072015-07-27 16:53:08 +00001609 return "hexagon" + toolchains::HexagonToolChain::GetTargetCPU(Args).str();
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001610
1611 case llvm::Triple::systemz:
1612 return getSystemZTargetCPU(Args);
1613
1614 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001615 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001616 return getR600TargetGPU(Args);
1617 }
1618}
1619
Alp Tokerce365ca2013-12-02 12:43:03 +00001620static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1621 ArgStringList &CmdArgs) {
1622 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1623 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1624 // forward.
1625 CmdArgs.push_back("-plugin");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001626 std::string Plugin =
1627 ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001628 CmdArgs.push_back(Args.MakeArgString(Plugin));
1629
1630 // Try to pass driver level flags relevant to LTO code generation down to
1631 // the plugin.
1632
1633 // Handle flags for selecting CPU variants.
1634 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1635 if (!CPU.empty())
1636 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1637}
1638
Sanjay Patel2987c292015-06-11 14:53:41 +00001639/// This is a helper function for validating the optional refinement step
1640/// parameter in reciprocal argument strings. Return false if there is an error
1641/// parsing the refinement step. Otherwise, return true and set the Position
1642/// of the refinement step in the input string.
1643static bool getRefinementStep(const StringRef &In, const Driver &D,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001644 const Arg &A, size_t &Position) {
Sanjay Patel2987c292015-06-11 14:53:41 +00001645 const char RefinementStepToken = ':';
1646 Position = In.find(RefinementStepToken);
1647 if (Position != StringRef::npos) {
1648 StringRef Option = A.getOption().getName();
1649 StringRef RefStep = In.substr(Position + 1);
1650 // Allow exactly one numeric character for the additional refinement
1651 // step parameter. This is reasonable for all currently-supported
1652 // operations and architectures because we would expect that a larger value
1653 // of refinement steps would cause the estimate "optimization" to
1654 // under-perform the native operation. Also, if the estimate does not
1655 // converge quickly, it probably will not ever converge, so further
1656 // refinement steps will not produce a better answer.
1657 if (RefStep.size() != 1) {
1658 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1659 return false;
1660 }
1661 char RefStepChar = RefStep[0];
1662 if (RefStepChar < '0' || RefStepChar > '9') {
1663 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1664 return false;
1665 }
1666 }
1667 return true;
1668}
1669
1670/// The -mrecip flag requires processing of many optional parameters.
1671static void ParseMRecip(const Driver &D, const ArgList &Args,
1672 ArgStringList &OutStrings) {
1673 StringRef DisabledPrefixIn = "!";
1674 StringRef DisabledPrefixOut = "!";
1675 StringRef EnabledPrefixOut = "";
1676 StringRef Out = "-mrecip=";
1677
1678 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1679 if (!A)
1680 return;
1681
1682 unsigned NumOptions = A->getNumValues();
1683 if (NumOptions == 0) {
1684 // No option is the same as "all".
1685 OutStrings.push_back(Args.MakeArgString(Out + "all"));
1686 return;
1687 }
1688
1689 // Pass through "all", "none", or "default" with an optional refinement step.
1690 if (NumOptions == 1) {
1691 StringRef Val = A->getValue(0);
1692 size_t RefStepLoc;
1693 if (!getRefinementStep(Val, D, *A, RefStepLoc))
1694 return;
1695 StringRef ValBase = Val.slice(0, RefStepLoc);
1696 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1697 OutStrings.push_back(Args.MakeArgString(Out + Val));
1698 return;
1699 }
1700 }
1701
1702 // Each reciprocal type may be enabled or disabled individually.
1703 // Check each input value for validity, concatenate them all back together,
1704 // and pass through.
1705
1706 llvm::StringMap<bool> OptionStrings;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001707 OptionStrings.insert(std::make_pair("divd", false));
1708 OptionStrings.insert(std::make_pair("divf", false));
1709 OptionStrings.insert(std::make_pair("vec-divd", false));
1710 OptionStrings.insert(std::make_pair("vec-divf", false));
1711 OptionStrings.insert(std::make_pair("sqrtd", false));
1712 OptionStrings.insert(std::make_pair("sqrtf", false));
1713 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
1714 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
Sanjay Patel2987c292015-06-11 14:53:41 +00001715
1716 for (unsigned i = 0; i != NumOptions; ++i) {
1717 StringRef Val = A->getValue(i);
1718
1719 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1720 // Ignore the disablement token for string matching.
1721 if (IsDisabled)
1722 Val = Val.substr(1);
1723
1724 size_t RefStep;
1725 if (!getRefinementStep(Val, D, *A, RefStep))
1726 return;
1727
1728 StringRef ValBase = Val.slice(0, RefStep);
1729 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1730 if (OptionIter == OptionStrings.end()) {
1731 // Try again specifying float suffix.
1732 OptionIter = OptionStrings.find(ValBase.str() + 'f');
1733 if (OptionIter == OptionStrings.end()) {
1734 // The input name did not match any known option string.
1735 D.Diag(diag::err_drv_unknown_argument) << Val;
1736 return;
1737 }
1738 // The option was specified without a float or double suffix.
1739 // Make sure that the double entry was not already specified.
1740 // The float entry will be checked below.
1741 if (OptionStrings[ValBase.str() + 'd']) {
1742 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1743 return;
1744 }
1745 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001746
Sanjay Patel2987c292015-06-11 14:53:41 +00001747 if (OptionIter->second == true) {
1748 // Duplicate option specified.
1749 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1750 return;
1751 }
1752
1753 // Mark the matched option as found. Do not allow duplicate specifiers.
1754 OptionIter->second = true;
1755
1756 // If the precision was not specified, also mark the double entry as found.
1757 if (ValBase.back() != 'f' && ValBase.back() != 'd')
1758 OptionStrings[ValBase.str() + 'd'] = true;
1759
1760 // Build the output string.
1761 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1762 Out = Args.MakeArgString(Out + Prefix + Val);
1763 if (i != NumOptions - 1)
1764 Out = Args.MakeArgString(Out + ",");
1765 }
1766
1767 OutStrings.push_back(Args.MakeArgString(Out));
1768}
1769
Eric Christopherc54920a2015-03-23 19:26:05 +00001770static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001771 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001772 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001773 // If -march=native, autodetect the feature list.
1774 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1775 if (StringRef(A->getValue()) == "native") {
1776 llvm::StringMap<bool> HostFeatures;
1777 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1778 for (auto &F : HostFeatures)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001779 Features.push_back(
1780 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
Craig Toppera8bd6002015-03-31 05:45:00 +00001781 }
1782 }
1783
Jim Grosbach82eee262013-11-16 00:53:35 +00001784 if (Triple.getArchName() == "x86_64h") {
1785 // x86_64h implies quite a few of the more modern subtarget features
1786 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1787 Features.push_back("-rdrnd");
1788 Features.push_back("-aes");
1789 Features.push_back("-pclmul");
1790 Features.push_back("-rtm");
1791 Features.push_back("-hle");
1792 Features.push_back("-fsgsbase");
1793 }
1794
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001795 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00001796 // Add features to be compatible with gcc for Android.
Alexey Bataev286d1b92014-01-31 04:07:13 +00001797 if (Triple.getEnvironment() == llvm::Triple::Android) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001798 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001799 Features.push_back("+sse4.2");
1800 Features.push_back("+popcnt");
1801 } else
1802 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001803 }
1804
Eric Christopherc54920a2015-03-23 19:26:05 +00001805 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001806 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1807 StringRef Arch = A->getValue();
1808 bool ArchUsed = false;
1809 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001810 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001811 if (Arch == "AVX" || Arch == "AVX2") {
1812 ArchUsed = true;
1813 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1814 }
1815 }
1816 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001817 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001818 if (Arch == "IA32") {
1819 ArchUsed = true;
1820 } else if (Arch == "SSE" || Arch == "SSE2") {
1821 ArchUsed = true;
1822 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1823 }
1824 }
1825 if (!ArchUsed)
1826 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1827 }
1828
Jim Grosbach82eee262013-11-16 00:53:35 +00001829 // Now add any that the user explicitly requested on the command line,
1830 // which may override the defaults.
Sean Silva14facf32015-06-09 01:57:17 +00001831 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1832 StringRef Name = A->getOption().getName();
1833 A->claim();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001834
1835 // Skip over "-m".
1836 assert(Name.startswith("m") && "Invalid feature name.");
1837 Name = Name.substr(1);
1838
1839 bool IsNegative = Name.startswith("no-");
1840 if (IsNegative)
1841 Name = Name.substr(3);
1842
1843 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1844 }
1845}
1846
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001847void Clang::AddX86TargetArgs(const ArgList &Args,
1848 ArgStringList &CmdArgs) const {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001849 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001850 Args.hasArg(options::OPT_mkernel) ||
1851 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001852 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001853
Bob Wilson2616e2e2013-02-10 16:01:41 +00001854 // Default to avoid implicit floating-point for kernel/kext code, but allow
1855 // that to be overridden with -mno-soft-float.
1856 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1857 Args.hasArg(options::OPT_fapple_kext));
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001858 if (Arg *A = Args.getLastArg(
1859 options::OPT_msoft_float, options::OPT_mno_soft_float,
1860 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
Bob Wilson2616e2e2013-02-10 16:01:41 +00001861 const Option &O = A->getOption();
1862 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1863 O.matches(options::OPT_msoft_float));
1864 }
1865 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001866 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001867
1868 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1869 StringRef Value = A->getValue();
1870 if (Value == "intel" || Value == "att") {
1871 CmdArgs.push_back("-mllvm");
1872 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1873 } else {
1874 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1875 << A->getOption().getName() << Value;
1876 }
1877 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001878}
1879
Tony Linthicum76329bf2011-12-12 21:14:55 +00001880void Clang::AddHexagonTargetArgs(const ArgList &Args,
1881 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00001882 CmdArgs.push_back("-mqdsp6-compat");
1883 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001884
Douglas Katzman54366072015-07-27 16:53:08 +00001885 if (const char *v =
1886 toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001887 std::string SmallDataThreshold = "-hexagon-small-data-threshold=";
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001888 SmallDataThreshold += v;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001889 CmdArgs.push_back("-mllvm");
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001890 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001891 }
1892
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001893 if (!Args.hasArg(options::OPT_fno_short_enums))
1894 CmdArgs.push_back("-fshort-enums");
1895 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001896 CmdArgs.push_back("-mllvm");
1897 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001898 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001899 CmdArgs.push_back("-mllvm");
1900 CmdArgs.push_back("-machine-sink-split=0");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001901}
1902
Kevin Qin110db6f2014-07-18 07:03:22 +00001903// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001904static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001905 std::vector<const char *> &Features) {
1906 SmallVector<StringRef, 8> Split;
1907 text.split(Split, StringRef("+"), -1, false);
1908
Douglas Katzman2675d012015-06-29 19:12:56 +00001909 for (const StringRef Feature : Split) {
1910 const char *result = llvm::StringSwitch<const char *>(Feature)
Kevin Qin110db6f2014-07-18 07:03:22 +00001911 .Case("fp", "+fp-armv8")
1912 .Case("simd", "+neon")
1913 .Case("crc", "+crc")
1914 .Case("crypto", "+crypto")
1915 .Case("nofp", "-fp-armv8")
1916 .Case("nosimd", "-neon")
1917 .Case("nocrc", "-crc")
1918 .Case("nocrypto", "-crypto")
1919 .Default(nullptr);
1920 if (result)
1921 Features.push_back(result);
Douglas Katzman2675d012015-06-29 19:12:56 +00001922 else if (Feature == "neon" || Feature == "noneon")
Kevin Qin110db6f2014-07-18 07:03:22 +00001923 D.Diag(diag::err_drv_no_neon_modifier);
1924 else
1925 return false;
1926 }
1927 return true;
1928}
1929
1930// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1931// decode CPU and feature.
1932static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1933 std::vector<const char *> &Features) {
1934 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1935 CPU = Split.first;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001936 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" ||
1937 CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001938 Features.push_back("+neon");
1939 Features.push_back("+crc");
1940 Features.push_back("+crypto");
1941 } else if (CPU == "generic") {
1942 Features.push_back("+neon");
1943 } else {
1944 return false;
1945 }
1946
1947 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1948 return false;
1949
1950 return true;
1951}
1952
1953static bool
1954getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1955 const ArgList &Args,
1956 std::vector<const char *> &Features) {
Gabor Ballabas36451492015-06-18 14:23:12 +00001957 std::string MarchLowerCase = March.lower();
1958 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001959
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001960 if (Split.first == "armv8-a" || Split.first == "armv8a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001961 // ok, no additional features.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001962 } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001963 Features.push_back("+v8.1a");
1964 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00001965 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00001966 }
Kevin Qin110db6f2014-07-18 07:03:22 +00001967
1968 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1969 return false;
1970
1971 return true;
1972}
1973
1974static bool
1975getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1976 const ArgList &Args,
1977 std::vector<const char *> &Features) {
1978 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001979 std::string McpuLowerCase = Mcpu.lower();
1980 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00001981 return false;
1982
1983 return true;
1984}
1985
1986static bool
1987getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1988 const ArgList &Args,
1989 std::vector<const char *> &Features) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00001990 std::string MtuneLowerCase = Mtune.lower();
Kevin Qin110db6f2014-07-18 07:03:22 +00001991 // Handle CPU name is 'native'.
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00001992 if (MtuneLowerCase == "native")
1993 MtuneLowerCase = llvm::sys::getHostCPUName();
1994 if (MtuneLowerCase == "cyclone") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001995 Features.push_back("+zcm");
1996 Features.push_back("+zcz");
1997 }
1998 return true;
1999}
2000
2001static bool
2002getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2003 const ArgList &Args,
2004 std::vector<const char *> &Features) {
2005 StringRef CPU;
2006 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002007 std::string McpuLowerCase = Mcpu.lower();
2008 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00002009 return false;
2010
2011 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
2012}
2013
Akira Hatanaka92500472015-07-27 19:29:04 +00002014static void getAArch64TargetFeatures(const Driver &D,
2015 const llvm::Triple &Triple,
2016 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002017 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00002018 Arg *A;
2019 bool success = true;
2020 // Enable NEON by default.
2021 Features.push_back("+neon");
2022 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2023 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
2024 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2025 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002026 else if (Args.hasArg(options::OPT_arch))
2027 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
2028 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002029
2030 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2031 success =
2032 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
2033 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2034 success =
2035 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002036 else if (Args.hasArg(options::OPT_arch))
2037 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
2038 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002039
2040 if (!success)
2041 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00002042
2043 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2044 Features.push_back("-fp-armv8");
2045 Features.push_back("-crypto");
2046 Features.push_back("-neon");
2047 }
Bradley Smith418c5932014-05-02 15:17:51 +00002048
2049 // En/disable crc
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002050 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bradley Smith418c5932014-05-02 15:17:51 +00002051 if (A->getOption().matches(options::OPT_mcrc))
2052 Features.push_back("+crc");
2053 else
2054 Features.push_back("-crc");
2055 }
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002056
Akira Hatanaka085da7e2015-07-29 14:25:58 +00002057 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2058 options::OPT_munaligned_access))
2059 if (A->getOption().matches(options::OPT_mno_unaligned_access))
2060 Features.push_back("+strict-align");
2061
Akira Hatanaka92500472015-07-27 19:29:04 +00002062 if (Args.hasArg(options::OPT_ffixed_x18) || Triple.isOSDarwin())
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002063 Features.push_back("+reserve-x18");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002064}
2065
2066static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002067 const ArgList &Args, ArgStringList &CmdArgs,
2068 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002069 std::vector<const char *> Features;
2070 switch (Triple.getArch()) {
2071 default:
2072 break;
2073 case llvm::Triple::mips:
2074 case llvm::Triple::mipsel:
2075 case llvm::Triple::mips64:
2076 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00002077 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002078 break;
2079
2080 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002081 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002082 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002083 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002084 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002085 break;
2086
2087 case llvm::Triple::ppc:
2088 case llvm::Triple::ppc64:
2089 case llvm::Triple::ppc64le:
2090 getPPCTargetFeatures(Args, Features);
2091 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00002092 case llvm::Triple::systemz:
2093 getSystemZTargetFeatures(Args, Features);
2094 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002095 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00002096 case llvm::Triple::aarch64_be:
Akira Hatanaka92500472015-07-27 19:29:04 +00002097 getAArch64TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002098 break;
2099 case llvm::Triple::x86:
2100 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002101 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002102 break;
2103 }
Rafael Espindola43964802013-08-21 17:34:32 +00002104
2105 // Find the last of each feature.
2106 llvm::StringMap<unsigned> LastOpt;
2107 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2108 const char *Name = Features[I];
2109 assert(Name[0] == '-' || Name[0] == '+');
2110 LastOpt[Name + 1] = I;
2111 }
2112
2113 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2114 // If this feature was overridden, ignore it.
2115 const char *Name = Features[I];
2116 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2117 assert(LastI != LastOpt.end());
2118 unsigned Last = LastI->second;
2119 if (Last != I)
2120 continue;
2121
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002122 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002123 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002124 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002125}
2126
David Majnemerae394812014-12-09 00:12:30 +00002127static bool
2128shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2129 const llvm::Triple &Triple) {
2130 // We use the zero-cost exception tables for Objective-C if the non-fragile
2131 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2132 // later.
2133 if (runtime.isNonFragile())
2134 return true;
2135
2136 if (!Triple.isMacOSX())
2137 return false;
2138
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002139 return (!Triple.isMacOSXVersionLT(10, 5) &&
David Majnemerae394812014-12-09 00:12:30 +00002140 (Triple.getArch() == llvm::Triple::x86_64 ||
2141 Triple.getArch() == llvm::Triple::arm));
2142}
2143
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002144/// Adds exception related arguments to the driver command arguments. There's a
2145/// master flag, -fexceptions and also language specific flags to enable/disable
2146/// C++ and Objective-C exceptions. This makes it possible to for example
2147/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002148static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002149 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002150 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002151 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002152 const Driver &D = TC.getDriver();
2153 const llvm::Triple &Triple = TC.getTriple();
2154
Chad Rosier4fab82c2012-03-26 22:04:46 +00002155 if (KernelOrKext) {
2156 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2157 // arguments now to avoid warnings about unused arguments.
2158 Args.ClaimAllArgs(options::OPT_fexceptions);
2159 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2160 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2161 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2162 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2163 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002164 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002165 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002166
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002167 // See if the user explicitly enabled exceptions.
2168 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2169 false);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002170
David Majnemerae394812014-12-09 00:12:30 +00002171 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2172 // is not necessarily sensible, but follows GCC.
2173 if (types::isObjC(InputType) &&
2174 Args.hasFlag(options::OPT_fobjc_exceptions,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002175 options::OPT_fno_objc_exceptions, true)) {
David Majnemerae394812014-12-09 00:12:30 +00002176 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002177
David Majnemerae394812014-12-09 00:12:30 +00002178 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002179 }
2180
2181 if (types::isCXX(InputType)) {
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002182 // Disable C++ EH by default on XCore, PS4, and MSVC.
2183 // FIXME: Remove MSVC from this list once things work.
2184 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
2185 !Triple.isPS4CPU() &&
2186 !Triple.isWindowsMSVCEnvironment();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002187 Arg *ExceptionArg = Args.getLastArg(
2188 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2189 options::OPT_fexceptions, options::OPT_fno_exceptions);
2190 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002191 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002192 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2193 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002194
2195 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002196 if (Triple.isPS4CPU()) {
2197 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2198 assert(ExceptionArg &&
2199 "On the PS4 exceptions should only be enabled if passing "
2200 "an argument");
2201 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2202 const Arg *RTTIArg = TC.getRTTIArg();
2203 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2204 D.Diag(diag::err_drv_argument_not_allowed_with)
2205 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2206 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2207 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2208 } else
2209 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2210
Anders Carlssone96ab552011-02-28 02:27:16 +00002211 CmdArgs.push_back("-fcxx-exceptions");
2212
David Majnemer8de68642014-12-05 08:11:58 +00002213 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002214 }
2215 }
2216
David Majnemer8de68642014-12-05 08:11:58 +00002217 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002218 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002219}
2220
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002221static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) {
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002222 bool Default = true;
2223 if (TC.getTriple().isOSDarwin()) {
2224 // The native darwin assembler doesn't support the linker_option directives,
2225 // so we disable them if we think the .s file will be passed to it.
2226 Default = TC.useIntegratedAs();
2227 }
2228 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2229 Default);
2230}
2231
Ted Kremenek62093662013-03-12 17:02:12 +00002232static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2233 const ToolChain &TC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002234 bool UseDwarfDirectory =
2235 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2236 options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002237 return !UseDwarfDirectory;
2238}
2239
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002240/// \brief Check whether the given input tree contains any compilation actions.
2241static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002242 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002243 return true;
2244
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002245 for (const auto &Act : *A)
2246 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002247 return true;
2248
2249 return false;
2250}
2251
2252/// \brief Check if -relax-all should be passed to the internal assembler.
2253/// This is done by default when compiling non-assembler source with -O0.
2254static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2255 bool RelaxDefault = true;
2256
2257 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2258 RelaxDefault = A->getOption().matches(options::OPT_O0);
2259
2260 if (RelaxDefault) {
2261 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002262 for (const auto &Act : C.getActions()) {
2263 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002264 RelaxDefault = true;
2265 break;
2266 }
2267 }
2268 }
2269
2270 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002271 RelaxDefault);
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002272}
2273
David Blaikie9260ed62013-07-25 21:19:01 +00002274static void CollectArgsForIntegratedAssembler(Compilation &C,
2275 const ArgList &Args,
2276 ArgStringList &CmdArgs,
2277 const Driver &D) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002278 if (UseRelaxAll(C, Args))
2279 CmdArgs.push_back("-mrelax-all");
David Blaikie9260ed62013-07-25 21:19:01 +00002280
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002281 // When passing -I arguments to the assembler we sometimes need to
2282 // unconditionally take the next argument. For example, when parsing
2283 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2284 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2285 // arg after parsing the '-I' arg.
2286 bool TakeNextArg = false;
David Peixottodfb66142013-11-14 22:52:58 +00002287
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002288 // When using an integrated assembler, translate -Wa, and -Xassembler
2289 // options.
2290 bool CompressDebugSections = false;
2291 for (const Arg *A :
2292 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2293 A->claim();
David Blaikie9260ed62013-07-25 21:19:01 +00002294
Renato Golin7c542b42015-07-27 23:44:45 +00002295 for (const StringRef Value : A->getValues()) {
2296 if (TakeNextArg) {
2297 CmdArgs.push_back(Value.data());
2298 TakeNextArg = false;
2299 continue;
2300 }
David Blaikie9260ed62013-07-25 21:19:01 +00002301
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002302 if (Value == "-force_cpusubtype_ALL") {
2303 // Do nothing, this is the default and we don't support anything else.
2304 } else if (Value == "-L") {
2305 CmdArgs.push_back("-msave-temp-labels");
2306 } else if (Value == "--fatal-warnings") {
2307 CmdArgs.push_back("-massembler-fatal-warnings");
2308 } else if (Value == "--noexecstack") {
2309 CmdArgs.push_back("-mnoexecstack");
2310 } else if (Value == "-compress-debug-sections" ||
2311 Value == "--compress-debug-sections") {
2312 CompressDebugSections = true;
2313 } else if (Value == "-nocompress-debug-sections" ||
2314 Value == "--nocompress-debug-sections") {
2315 CompressDebugSections = false;
2316 } else if (Value.startswith("-I")) {
2317 CmdArgs.push_back(Value.data());
2318 // We need to consume the next argument if the current arg is a plain
2319 // -I. The next arg will be the include directory.
2320 if (Value == "-I")
2321 TakeNextArg = true;
2322 } else if (Value.startswith("-gdwarf-")) {
2323 CmdArgs.push_back(Value.data());
Renato Golin7c542b42015-07-27 23:44:45 +00002324 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
2325 Value.startswith("-mhwdiv") || Value.startswith("-march")) {
2326 // Do nothing, we'll validate it later.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002327 } else {
2328 D.Diag(diag::err_drv_unsupported_option_argument)
David Blaikie9260ed62013-07-25 21:19:01 +00002329 << A->getOption().getName() << Value;
David Blaikie9260ed62013-07-25 21:19:01 +00002330 }
2331 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002332 }
2333 if (CompressDebugSections) {
2334 if (llvm::zlib::isAvailable())
2335 CmdArgs.push_back("-compress-debug-sections");
2336 else
2337 D.Diag(diag::warn_debug_compression_unavailable);
2338 }
David Blaikie9260ed62013-07-25 21:19:01 +00002339}
2340
Renato Goline807c122014-01-31 11:47:28 +00002341// Until ARM libraries are build separately, we have them all in one library
2342static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Reid Kleckner0213a472015-07-22 16:01:38 +00002343 if (TC.getTriple().isWindowsMSVCEnvironment() &&
Peter Collingbourne2659fb32015-07-02 02:07:43 +00002344 TC.getArch() == llvm::Triple::x86)
2345 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002346 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002347 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002348 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002349}
2350
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002351static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2352 // The runtimes are located in the OS-specific resource directory.
2353 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002354 const llvm::Triple &Triple = TC.getTriple();
2355 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002356 StringRef OSLibName =
2357 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002358 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002359 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002360}
2361
Peter Collingbourne581f4382015-07-02 01:48:12 +00002362SmallString<128> tools::getCompilerRT(const ToolChain &TC, StringRef Component,
2363 bool Shared) {
Dan Albert6f2875d2015-01-28 23:23:36 +00002364 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2365 ? "-android"
2366 : "";
2367
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002368 bool IsOSWindows = TC.getTriple().isOSWindows();
Reid Kleckner0213a472015-07-22 16:01:38 +00002369 bool IsITANMSVCWindows = TC.getTriple().isWindowsMSVCEnvironment() ||
2370 TC.getTriple().isWindowsItaniumEnvironment();
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002371 StringRef Arch = getArchNameForCompilerRTLib(TC);
Reid Kleckner0213a472015-07-22 16:01:38 +00002372 const char *Prefix = IsITANMSVCWindows ? "" : "lib";
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002373 const char *Suffix =
Reid Kleckner0213a472015-07-22 16:01:38 +00002374 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsITANMSVCWindows ? ".lib" : ".a");
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002375
2376 SmallString<128> Path = getCompilerRTLibDir(TC);
2377 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2378 Arch + Env + Suffix);
2379
2380 return Path;
2381}
2382
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002383// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002384// FIXME: Make sure we can also emit shared objects if they're requested
2385// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002386static void addClangRT(const ToolChain &TC, const ArgList &Args,
2387 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002388 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002389}
2390
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002391static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2392 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002393 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2394 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002395 Args.hasArg(options::OPT_fprofile_generate) ||
Diego Novillo578caf52015-07-09 17:23:53 +00002396 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002397 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Justin Bognera71e6812015-04-30 23:49:42 +00002398 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002399 Args.hasArg(options::OPT_fcreate_profile) ||
2400 Args.hasArg(options::OPT_coverage)))
2401 return;
2402
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002403 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002404}
2405
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002406namespace {
2407enum OpenMPRuntimeKind {
2408 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2409 /// without knowing what runtime to target.
2410 OMPRT_Unknown,
2411
2412 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2413 /// the default for Clang.
2414 OMPRT_OMP,
2415
2416 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2417 /// this runtime but can swallow the pragmas, and find and link against the
2418 /// runtime library itself.
2419 OMPRT_GOMP,
2420
Chandler Carruthc6625c62015-05-28 21:10:31 +00002421 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002422 /// OpenMP runtime. We support this mode for users with existing dependencies
2423 /// on this runtime library name.
2424 OMPRT_IOMP5
2425};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002426}
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002427
2428/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002429static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2430 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002431 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2432
2433 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2434 if (A)
2435 RuntimeName = A->getValue();
2436
2437 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002438 .Case("libomp", OMPRT_OMP)
2439 .Case("libgomp", OMPRT_GOMP)
2440 .Case("libiomp5", OMPRT_IOMP5)
2441 .Default(OMPRT_Unknown);
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002442
2443 if (RT == OMPRT_Unknown) {
2444 if (A)
2445 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002446 << A->getOption().getName() << A->getValue();
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002447 else
2448 // FIXME: We could use a nicer diagnostic here.
2449 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2450 }
2451
2452 return RT;
2453}
2454
Alexey Samsonov52550342014-09-15 19:58:40 +00002455static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2456 ArgStringList &CmdArgs, StringRef Sanitizer,
2457 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002458 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002459 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002460 if (!IsShared)
2461 CmdArgs.push_back("-whole-archive");
Dan Albert6f2875d2015-01-28 23:23:36 +00002462 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002463 if (!IsShared)
2464 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002465}
2466
Alexey Samsonov52550342014-09-15 19:58:40 +00002467// Tries to use a file with the list of dynamic symbols that need to be exported
2468// from the runtime library. Returns true if the file was found.
2469static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2470 ArgStringList &CmdArgs,
2471 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002472 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2473 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2474 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002475 return true;
2476 }
2477 return false;
2478}
2479
2480static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2481 ArgStringList &CmdArgs) {
2482 // Force linking against the system libraries sanitizers depends on
2483 // (see PR15823 why this is necessary).
2484 CmdArgs.push_back("--no-as-needed");
2485 CmdArgs.push_back("-lpthread");
2486 CmdArgs.push_back("-lrt");
2487 CmdArgs.push_back("-lm");
2488 // There's no libdl on FreeBSD.
2489 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2490 CmdArgs.push_back("-ldl");
2491}
2492
2493static void
2494collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2495 SmallVectorImpl<StringRef> &SharedRuntimes,
2496 SmallVectorImpl<StringRef> &StaticRuntimes,
2497 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2498 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2499 // Collect shared runtimes.
2500 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2501 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002502 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002503
Alexey Samsonov52550342014-09-15 19:58:40 +00002504 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002505 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002506 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2507 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002508 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002509 }
2510 if (SanArgs.needsAsanRt()) {
2511 if (SanArgs.needsSharedAsanRt()) {
2512 HelperStaticRuntimes.push_back("asan-preinit");
2513 } else {
2514 StaticRuntimes.push_back("asan");
2515 if (SanArgs.linkCXXRuntimes())
2516 StaticRuntimes.push_back("asan_cxx");
2517 }
2518 }
2519 if (SanArgs.needsDfsanRt())
2520 StaticRuntimes.push_back("dfsan");
2521 if (SanArgs.needsLsanRt())
2522 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002523 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002524 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002525 if (SanArgs.linkCXXRuntimes())
2526 StaticRuntimes.push_back("msan_cxx");
2527 }
2528 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002529 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002530 if (SanArgs.linkCXXRuntimes())
2531 StaticRuntimes.push_back("tsan_cxx");
2532 }
Alexey Samsonov52550342014-09-15 19:58:40 +00002533 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002534 StaticRuntimes.push_back("ubsan_standalone");
2535 if (SanArgs.linkCXXRuntimes())
2536 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002537 }
Peter Collingbournec4122c12015-06-15 21:08:13 +00002538 if (SanArgs.needsSafeStackRt())
2539 StaticRuntimes.push_back("safestack");
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002540}
2541
Alexey Samsonov52550342014-09-15 19:58:40 +00002542// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2543// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2544static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002545 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002546 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2547 HelperStaticRuntimes;
2548 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2549 HelperStaticRuntimes);
2550 for (auto RT : SharedRuntimes)
2551 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2552 for (auto RT : HelperStaticRuntimes)
2553 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2554 bool AddExportDynamic = false;
2555 for (auto RT : StaticRuntimes) {
2556 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2557 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2558 }
2559 // If there is a static runtime with no dynamic list, force all the symbols
2560 // to be dynamic to be sure we export sanitizer interface functions.
2561 if (AddExportDynamic)
2562 CmdArgs.push_back("-export-dynamic");
2563 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002564}
2565
Reid Kleckner86ea7702015-02-04 23:45:07 +00002566static bool areOptimizationsEnabled(const ArgList &Args) {
2567 // Find the last -O arg and see if it is non-zero.
2568 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2569 return !A->getOption().matches(options::OPT_O0);
2570 // Defaults to -O0.
2571 return false;
2572}
2573
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002574static bool shouldUseFramePointerForTarget(const ArgList &Args,
2575 const llvm::Triple &Triple) {
Reid Kleckner86ea7702015-02-04 23:45:07 +00002576 // XCore never wants frame pointers, regardless of OS.
2577 if (Triple.getArch() == llvm::Triple::xcore) {
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002578 return false;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002579 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002580
2581 if (Triple.isOSLinux()) {
2582 switch (Triple.getArch()) {
2583 // Don't use a frame pointer on linux if optimizing for certain targets.
2584 case llvm::Triple::mips64:
2585 case llvm::Triple::mips64el:
2586 case llvm::Triple::mips:
2587 case llvm::Triple::mipsel:
2588 case llvm::Triple::systemz:
2589 case llvm::Triple::x86:
2590 case llvm::Triple::x86_64:
2591 return !areOptimizationsEnabled(Args);
2592 default:
2593 return true;
2594 }
2595 }
2596
2597 if (Triple.isOSWindows()) {
2598 switch (Triple.getArch()) {
2599 case llvm::Triple::x86:
2600 return !areOptimizationsEnabled(Args);
2601 default:
2602 // All other supported Windows ISAs use xdata unwind information, so frame
2603 // pointers are not generally useful.
2604 return false;
2605 }
2606 }
2607
2608 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002609}
2610
Rafael Espindola224dd632011-12-14 21:02:23 +00002611static bool shouldUseFramePointer(const ArgList &Args,
2612 const llvm::Triple &Triple) {
2613 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2614 options::OPT_fomit_frame_pointer))
2615 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2616
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002617 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002618}
2619
Eric Christopherb7d97e92013-04-03 01:58:53 +00002620static bool shouldUseLeafFramePointer(const ArgList &Args,
2621 const llvm::Triple &Triple) {
2622 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2623 options::OPT_momit_leaf_frame_pointer))
2624 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2625
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002626 if (Triple.isPS4CPU())
2627 return false;
2628
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002629 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002630}
2631
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002632/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002633static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002634 SmallString<128> cwd;
2635 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002636 CmdArgs.push_back("-fdebug-compilation-dir");
2637 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002638 }
2639}
2640
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002641static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00002642 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2643 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2644 SmallString<128> T(FinalOutput->getValue());
2645 llvm::sys::path::replace_extension(T, "dwo");
2646 return Args.MakeArgString(T);
2647 } else {
2648 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002649 SmallString<128> T(
2650 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00002651 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00002652 llvm::sys::path::replace_extension(F, "dwo");
2653 T += F;
2654 return Args.MakeArgString(F);
2655 }
2656}
2657
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002658static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
2659 const JobAction &JA, const ArgList &Args,
2660 const InputInfo &Output, const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002661 ArgStringList ExtractArgs;
2662 ExtractArgs.push_back("--extract-dwo");
2663
2664 ArgStringList StripArgs;
2665 StripArgs.push_back("--strip-dwo");
2666
2667 // Grabbing the output of the earlier compile step.
2668 StripArgs.push_back(Output.getFilename());
2669 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002670 ExtractArgs.push_back(OutFile);
2671
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002672 const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
Justin Bognerd3371d82015-07-17 03:35:54 +00002673 InputInfo II(Output.getFilename(), types::TY_Object, Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002674
2675 // First extract the dwo sections.
Justin Bognerd3371d82015-07-17 03:35:54 +00002676 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00002677
2678 // Then remove them from the original .o file.
Justin Bognerd3371d82015-07-17 03:35:54 +00002679 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00002680}
2681
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002682/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002683/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2684static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002685 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002686 if (A->getOption().matches(options::OPT_O4) ||
2687 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002688 return true;
2689
2690 if (A->getOption().matches(options::OPT_O0))
2691 return false;
2692
2693 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2694
Rafael Espindola91780de2013-08-26 14:05:41 +00002695 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002696 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002697 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002698 return true;
2699
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002700 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002701 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002702 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002703
2704 unsigned OptLevel = 0;
2705 if (S.getAsInteger(10, OptLevel))
2706 return false;
2707
2708 return OptLevel > 1;
2709 }
2710
2711 return false;
2712}
2713
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002714/// Add -x lang to \p CmdArgs for \p Input.
2715static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2716 ArgStringList &CmdArgs) {
2717 // When using -verify-pch, we don't want to provide the type
2718 // 'precompiled-header' if it was inferred from the file extension
2719 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2720 return;
2721
2722 CmdArgs.push_back("-x");
2723 if (Args.hasArg(options::OPT_rewrite_objc))
2724 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2725 else
2726 CmdArgs.push_back(types::getTypeName(Input.getType()));
2727}
2728
David Majnemerc371ff02015-03-22 08:39:22 +00002729static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002730 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002731 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002732
2733 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002734 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002735
2736 unsigned Build = 0, Factor = 1;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002737 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002738 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002739 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002740}
2741
Rafael Espindola577637a2015-01-03 00:06:04 +00002742// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002743// options that build systems might add but are unused when assembling or only
2744// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002745static void claimNoWarnArgs(const ArgList &Args) {
2746 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002747 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002748 Args.ClaimAllArgs(options::OPT_flto);
2749 Args.ClaimAllArgs(options::OPT_fno_lto);
2750}
2751
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002752static void appendUserToPath(SmallVectorImpl<char> &Result) {
2753#ifdef LLVM_ON_UNIX
2754 const char *Username = getenv("LOGNAME");
2755#else
2756 const char *Username = getenv("USERNAME");
2757#endif
2758 if (Username) {
2759 // Validate that LoginName can be used in a path, and get its length.
2760 size_t Len = 0;
2761 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002762 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002763 Username = nullptr;
2764 break;
2765 }
2766 }
2767
2768 if (Username && Len > 0) {
2769 Result.append(Username, Username + Len);
2770 return;
2771 }
2772 }
2773
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002774// Fallback to user id.
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002775#ifdef LLVM_ON_UNIX
2776 std::string UID = llvm::utostr(getuid());
2777#else
2778 // FIXME: Windows seems to have an 'SID' that might work.
2779 std::string UID = "9999";
2780#endif
2781 Result.append(UID.begin(), UID.end());
2782}
2783
David Majnemere11d3732015-06-08 00:22:46 +00002784VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2785 const llvm::Triple &Triple,
2786 const llvm::opt::ArgList &Args,
2787 bool IsWindowsMSVC) {
2788 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2789 IsWindowsMSVC) ||
2790 Args.hasArg(options::OPT_fmsc_version) ||
2791 Args.hasArg(options::OPT_fms_compatibility_version)) {
2792 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2793 const Arg *MSCompatibilityVersion =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002794 Args.getLastArg(options::OPT_fms_compatibility_version);
David Majnemere11d3732015-06-08 00:22:46 +00002795
2796 if (MSCVersion && MSCompatibilityVersion) {
2797 if (D)
2798 D->Diag(diag::err_drv_argument_not_allowed_with)
2799 << MSCVersion->getAsString(Args)
2800 << MSCompatibilityVersion->getAsString(Args);
2801 return VersionTuple();
2802 }
2803
2804 if (MSCompatibilityVersion) {
2805 VersionTuple MSVT;
2806 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2807 D->Diag(diag::err_drv_invalid_value)
2808 << MSCompatibilityVersion->getAsString(Args)
2809 << MSCompatibilityVersion->getValue();
2810 return MSVT;
2811 }
2812
2813 if (MSCVersion) {
2814 unsigned Version = 0;
2815 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2816 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2817 << MSCVersion->getValue();
2818 return getMSCompatibilityVersion(Version);
2819 }
2820
2821 unsigned Major, Minor, Micro;
2822 Triple.getEnvironmentVersion(Major, Minor, Micro);
2823 if (Major || Minor || Micro)
2824 return VersionTuple(Major, Minor, Micro);
2825
2826 return VersionTuple(18);
2827 }
2828 return VersionTuple();
2829}
2830
Diego Novilloa0545962015-07-10 18:00:07 +00002831static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
2832 const InputInfo &Output, const ArgList &Args,
2833 ArgStringList &CmdArgs) {
2834 auto *ProfileGenerateArg = Args.getLastArg(
2835 options::OPT_fprofile_instr_generate,
2836 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
Diego Novillo758f3f52015-08-05 21:49:51 +00002837 options::OPT_fprofile_generate_EQ,
2838 options::OPT_fno_profile_instr_generate);
2839 if (ProfileGenerateArg &&
2840 ProfileGenerateArg->getOption().matches(
2841 options::OPT_fno_profile_instr_generate))
2842 ProfileGenerateArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00002843
2844 auto *ProfileUseArg = Args.getLastArg(
2845 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
Diego Novillo758f3f52015-08-05 21:49:51 +00002846 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
2847 options::OPT_fno_profile_instr_use);
2848 if (ProfileUseArg &&
2849 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
2850 ProfileUseArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00002851
2852 if (ProfileGenerateArg && ProfileUseArg)
2853 D.Diag(diag::err_drv_argument_not_allowed_with)
Renato Golin7c542b42015-07-27 23:44:45 +00002854 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
Diego Novilloa0545962015-07-10 18:00:07 +00002855
Diego Novillo758f3f52015-08-05 21:49:51 +00002856 if (ProfileGenerateArg) {
2857 if (ProfileGenerateArg->getOption().matches(
2858 options::OPT_fprofile_instr_generate_EQ))
2859 ProfileGenerateArg->render(Args, CmdArgs);
2860 else if (ProfileGenerateArg->getOption().matches(
2861 options::OPT_fprofile_generate_EQ)) {
2862 SmallString<128> Path(ProfileGenerateArg->getValue());
2863 llvm::sys::path::append(Path, "default.profraw");
2864 CmdArgs.push_back(
2865 Args.MakeArgString(Twine("-fprofile-instr-generate=") + Path));
2866 } else
2867 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2868 }
Diego Novilloa0545962015-07-10 18:00:07 +00002869
Diego Novillo758f3f52015-08-05 21:49:51 +00002870 if (ProfileUseArg) {
2871 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
2872 ProfileUseArg->render(Args, CmdArgs);
2873 else if ((ProfileUseArg->getOption().matches(
2874 options::OPT_fprofile_use_EQ) ||
2875 ProfileUseArg->getOption().matches(
2876 options::OPT_fprofile_instr_use))) {
2877 SmallString<128> Path(
2878 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
2879 if (Path.empty() || llvm::sys::fs::is_directory(Path))
2880 llvm::sys::path::append(Path, "default.profdata");
2881 CmdArgs.push_back(
2882 Args.MakeArgString(Twine("-fprofile-instr-use=") + Path));
2883 }
Diego Novilloa0545962015-07-10 18:00:07 +00002884 }
2885
2886 if (Args.hasArg(options::OPT_ftest_coverage) ||
2887 Args.hasArg(options::OPT_coverage))
2888 CmdArgs.push_back("-femit-coverage-notes");
2889 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2890 false) ||
2891 Args.hasArg(options::OPT_coverage))
2892 CmdArgs.push_back("-femit-coverage-data");
2893
Diego Novilloc4b94da2015-08-05 23:27:40 +00002894 if (Args.hasFlag(options::OPT_fcoverage_mapping,
2895 options::OPT_fno_coverage_mapping, false) &&
2896 !ProfileGenerateArg)
Diego Novilloa0545962015-07-10 18:00:07 +00002897 D.Diag(diag::err_drv_argument_only_allowed_with)
2898 << "-fcoverage-mapping"
2899 << "-fprofile-instr-generate";
2900
Diego Novilloc4b94da2015-08-05 23:27:40 +00002901 if (Args.hasFlag(options::OPT_fcoverage_mapping,
2902 options::OPT_fno_coverage_mapping, false))
Diego Novilloa0545962015-07-10 18:00:07 +00002903 CmdArgs.push_back("-fcoverage-mapping");
2904
2905 if (C.getArgs().hasArg(options::OPT_c) ||
2906 C.getArgs().hasArg(options::OPT_S)) {
2907 if (Output.isFilename()) {
2908 CmdArgs.push_back("-coverage-file");
2909 SmallString<128> CoverageFilename;
2910 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
2911 CoverageFilename = FinalOutput->getValue();
2912 } else {
2913 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
2914 }
2915 if (llvm::sys::path::is_relative(CoverageFilename)) {
2916 SmallString<128> Pwd;
2917 if (!llvm::sys::fs::current_path(Pwd)) {
2918 llvm::sys::path::append(Pwd, CoverageFilename);
2919 CoverageFilename.swap(Pwd);
2920 }
2921 }
2922 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2923 }
2924 }
2925}
2926
James Y Knight5bdf7ab2015-08-19 15:12:02 +00002927/// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
2928/// smooshes them together with platform defaults, to decide whether
2929/// this compile should be using PIC mode or not. Returns a tuple of
2930/// (RelocationModel, PICLevel, IsPIE).
2931static std::tuple<llvm::Reloc::Model, unsigned, bool>
2932ParsePICArgs(const ToolChain &ToolChain, const llvm::Triple &Triple,
2933 const ArgList &Args) {
2934 // FIXME: why does this code...and so much everywhere else, use both
2935 // ToolChain.getTriple() and Triple?
2936 bool PIE = ToolChain.isPIEDefault();
2937 bool PIC = PIE || ToolChain.isPICDefault();
2938 bool IsPICLevelTwo = PIC;
2939
2940 bool KernelOrKext =
2941 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
2942
2943 // Android-specific defaults for PIC/PIE
2944 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
2945 switch (ToolChain.getArch()) {
2946 case llvm::Triple::arm:
2947 case llvm::Triple::armeb:
2948 case llvm::Triple::thumb:
2949 case llvm::Triple::thumbeb:
2950 case llvm::Triple::aarch64:
2951 case llvm::Triple::mips:
2952 case llvm::Triple::mipsel:
2953 case llvm::Triple::mips64:
2954 case llvm::Triple::mips64el:
2955 PIC = true; // "-fpic"
2956 break;
2957
2958 case llvm::Triple::x86:
2959 case llvm::Triple::x86_64:
2960 PIC = true; // "-fPIC"
2961 IsPICLevelTwo = true;
2962 break;
2963
2964 default:
2965 break;
2966 }
2967 }
2968
2969 // OpenBSD-specific defaults for PIE
2970 if (ToolChain.getTriple().getOS() == llvm::Triple::OpenBSD) {
2971 switch (ToolChain.getArch()) {
2972 case llvm::Triple::mips64:
2973 case llvm::Triple::mips64el:
2974 case llvm::Triple::sparcel:
2975 case llvm::Triple::x86:
2976 case llvm::Triple::x86_64:
2977 IsPICLevelTwo = false; // "-fpie"
2978 break;
2979
2980 case llvm::Triple::ppc:
2981 case llvm::Triple::sparc:
2982 case llvm::Triple::sparcv9:
2983 IsPICLevelTwo = true; // "-fPIE"
2984 break;
2985
2986 default:
2987 break;
2988 }
2989 }
2990
2991 // The last argument relating to either PIC or PIE wins, and no
2992 // other argument is used. If the last argument is any flavor of the
2993 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
2994 // option implicitly enables PIC at the same level.
2995 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2996 options::OPT_fpic, options::OPT_fno_pic,
2997 options::OPT_fPIE, options::OPT_fno_PIE,
2998 options::OPT_fpie, options::OPT_fno_pie);
2999 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3000 // is forced, then neither PIC nor PIE flags will have no effect.
3001 if (!ToolChain.isPICDefaultForced()) {
3002 if (LastPICArg) {
3003 Option O = LastPICArg->getOption();
3004 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3005 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3006 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3007 PIC =
3008 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3009 IsPICLevelTwo =
3010 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3011 } else {
3012 PIE = PIC = false;
3013 }
3014 }
3015 }
3016
3017 // Introduce a Darwin-specific hack. If the default is PIC, but the
3018 // PIC level would've been set to level 1, force it back to level 2
3019 // PIC instead. This matches the behavior of Darwin GCC (based on
3020 // chandlerc's informal testing in 2012).
3021 if (PIC && ToolChain.getTriple().isOSDarwin())
3022 IsPICLevelTwo |= ToolChain.isPICDefault();
3023
James Y Knightc4015d32015-08-21 04:14:55 +00003024 // This kernel flags are a trump-card: they will disable PIC/PIE
3025 // generation, independent of the argument order.
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003026 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
3027 PIC = PIE = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003028
3029 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3030 // This is a very special mode. It trumps the other modes, almost no one
3031 // uses it, and it isn't even valid on any OS but Darwin.
3032 if (!ToolChain.getTriple().isOSDarwin())
3033 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
3034 << A->getSpelling() << ToolChain.getTriple().str();
3035
3036 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3037
3038 // Only a forced PIC mode can cause the actual compile to have PIC defines
3039 // etc., no flags are sufficient. This behavior was selected to closely
3040 // match that of llvm-gcc and Apple GCC before that.
3041 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
3042
3043 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2 : 0, false);
3044 }
3045
3046 if (PIC)
3047 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2 : 1, PIE);
3048
3049 return std::make_tuple(llvm::Reloc::Static, 0, false);
3050}
3051
3052static const char *RelocationModelName(llvm::Reloc::Model Model) {
3053 switch (Model) {
3054 case llvm::Reloc::Default:
3055 return nullptr;
3056 case llvm::Reloc::Static:
3057 return "static";
3058 case llvm::Reloc::PIC_:
3059 return "pic";
3060 case llvm::Reloc::DynamicNoPIC:
3061 return "dynamic-no-pic";
3062 }
Aaron Ballman2ec49282015-08-20 13:31:16 +00003063 llvm_unreachable("Unknown Reloc::Model kind");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003064}
3065
3066static void AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
3067 ArgStringList &CmdArgs) {
3068 llvm::Reloc::Model RelocationModel;
3069 unsigned PICLevel;
3070 bool IsPIE;
3071 std::tie(RelocationModel, PICLevel, IsPIE) =
3072 ParsePICArgs(ToolChain, ToolChain.getTriple(), Args);
3073
3074 if (RelocationModel != llvm::Reloc::Static)
3075 CmdArgs.push_back("-KPIC");
3076}
3077
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003078void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003079 const InputInfo &Output, const InputInfoList &Inputs,
3080 const ArgList &Args, const char *LinkingOutput) const {
James Y Knight2db38f32015-08-15 03:45:25 +00003081 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3082 const llvm::Triple Triple(TripleStr);
3083
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003084 bool KernelOrKext =
3085 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00003086 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003087 ArgStringList CmdArgs;
3088
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003089 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00003090 bool IsWindowsCygnus =
3091 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003092 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
3093
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003094 // Check number of inputs for sanity. We need at least one input.
3095 assert(Inputs.size() >= 1 && "Must have at least one input.");
Artem Belevichba558952015-05-06 18:20:23 +00003096 const InputInfo &Input = Inputs[0];
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003097 // CUDA compilation may have multiple inputs (source file + results of
3098 // device-side compilations). All other jobs are expected to have exactly one
3099 // input.
3100 bool IsCuda = types::isCuda(Input.getType());
3101 assert((IsCuda || Inputs.size() == 1) && "Unable to handle multiple inputs.");
Daniel Dunbare521a892009-03-31 20:53:55 +00003102
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003103 // Invoke ourselves in -cc1 mode.
3104 //
3105 // FIXME: Implement custom jobs for internal actions.
3106 CmdArgs.push_back("-cc1");
3107
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003108 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00003109 CmdArgs.push_back("-triple");
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003110 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00003111
James Y Knight2db38f32015-08-15 03:45:25 +00003112 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3113 Triple.getArch() == llvm::Triple::thumb)) {
3114 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003115 unsigned Version;
James Y Knight2db38f32015-08-15 03:45:25 +00003116 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003117 if (Version < 7)
James Y Knight2db38f32015-08-15 03:45:25 +00003118 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
Nico Webere8e53112014-05-11 01:04:02 +00003119 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003120 }
3121
Tim Northover336f1892014-03-29 13:16:12 +00003122 // Push all default warning arguments that are specific to
3123 // the given target. These come before user provided warning options
3124 // are provided.
3125 getToolChain().addClangWarningOptions(CmdArgs);
3126
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003127 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00003128 RewriteKind rewriteKind = RK_None;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003129
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003130 if (isa<AnalyzeJobAction>(JA)) {
3131 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
3132 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003133 } else if (isa<MigrateJobAction>(JA)) {
3134 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003135 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003136 if (Output.getType() == types::TY_Dependencies)
3137 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003138 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003139 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003140 if (Args.hasArg(options::OPT_rewrite_objc) &&
3141 !Args.hasArg(options::OPT_g_Group))
3142 CmdArgs.push_back("-P");
3143 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00003144 } else if (isa<AssembleJobAction>(JA)) {
3145 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003146
David Blaikie9260ed62013-07-25 21:19:01 +00003147 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00003148
3149 // Also ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003150 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003151 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00003152 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003153 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003154
Aaron Ballman1f10cc52012-07-31 01:21:00 +00003155 if (JA.getType() == types::TY_Nothing)
3156 CmdArgs.push_back("-fsyntax-only");
3157 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00003158 CmdArgs.push_back("-emit-pch");
3159 else
3160 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003161 } else if (isa<VerifyPCHJobAction>(JA)) {
3162 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003163 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00003164 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3165 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003166
Renato Golin7c542b42015-07-27 23:44:45 +00003167 if (JA.getType() == types::TY_LTO_IR || JA.getType() == types::TY_LTO_BC) {
Teresa Johnson8749d8042015-07-06 16:23:00 +00003168 CmdArgs.push_back("-flto");
3169 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003170 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003171 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003172 } else if (JA.getType() == types::TY_LLVM_IR ||
3173 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003174 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003175 } else if (JA.getType() == types::TY_LLVM_BC ||
3176 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003177 CmdArgs.push_back("-emit-llvm-bc");
3178 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00003179 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003180 } else if (JA.getType() == types::TY_AST) {
3181 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00003182 } else if (JA.getType() == types::TY_ModuleFile) {
3183 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003184 } else if (JA.getType() == types::TY_RewrittenObjC) {
3185 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003186 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00003187 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
3188 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003189 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003190 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003191 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003192 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00003193
3194 // Preserve use-list order by default when emitting bitcode, so that
3195 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
3196 // same result as running passes here. For LTO, we don't need to preserve
3197 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00003198 if (JA.getType() == types::TY_LLVM_BC)
3199 CmdArgs.push_back("-emit-llvm-uselists");
Daniel Dunbara3246a02009-03-18 08:07:30 +00003200 }
3201
Justin Bognera88f0122014-06-20 22:59:50 +00003202 // We normally speed up the clang process a bit by skipping destructors at
3203 // exit, but when we're generating diagnostics we can rely on some of the
3204 // cleanup.
3205 if (!C.isForDiagnostics())
3206 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003207
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003208// Disable the verification pass in -asserts builds.
John McCallbb79b5f2010-02-13 03:50:24 +00003209#ifdef NDEBUG
3210 CmdArgs.push_back("-disable-llvm-verifier");
3211#endif
3212
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003213 // Set the main file name, so that debug info works even with
3214 // -save-temps.
3215 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00003216 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003217
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003218 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00003219 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003220 if (Args.hasArg(options::OPT_static))
3221 CmdArgs.push_back("-static-define");
3222
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003223 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00003224 // Enable region store model by default.
3225 CmdArgs.push_back("-analyzer-store=region");
3226
Ted Kremenek7bea9a12009-12-07 22:26:14 +00003227 // Treat blocks as analysis entry points.
3228 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
3229
Ted Kremenek49c79792011-03-24 00:28:47 +00003230 CmdArgs.push_back("-analyzer-eagerly-assume");
3231
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003232 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003233 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003234 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00003235
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003236 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003237 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00003238
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003239 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00003240 CmdArgs.push_back("-analyzer-checker=osx");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003241
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00003242 CmdArgs.push_back("-analyzer-checker=deadcode");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003243
Artem Belevichba558952015-05-06 18:20:23 +00003244 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00003245 CmdArgs.push_back("-analyzer-checker=cplusplus");
3246
Nico Webere8e53112014-05-11 01:04:02 +00003247 // Enable the following experimental checkers for testing.
3248 CmdArgs.push_back(
3249 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00003250 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
3251 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003252 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
Ted Kremenek37e96522012-01-26 02:27:38 +00003253 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
3254 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003255 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003256
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003257 // Set the output format. The default is plist, for (lame) historical
3258 // reasons.
3259 CmdArgs.push_back("-analyzer-output");
3260 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00003261 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003262 else
3263 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003264
Ted Kremenekfe449a22010-03-22 22:32:05 +00003265 // Disable the presentation of standard compiler warnings when
3266 // using --analyze. We only want to show static analyzer diagnostics
3267 // or frontend errors.
3268 CmdArgs.push_back("-w");
3269
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003270 // Add -Xanalyzer arguments when running as analyzer.
3271 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00003272 }
3273
Daniel Dunbar4eadb602009-09-10 01:21:12 +00003274 CheckCodeGenerationOptions(D, Args);
3275
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003276 llvm::Reloc::Model RelocationModel;
3277 unsigned PICLevel;
3278 bool IsPIE;
3279 std::tie(RelocationModel, PICLevel, IsPIE) =
3280 ParsePICArgs(getToolChain(), Triple, Args);
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003281
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003282 const char *RMName = RelocationModelName(RelocationModel);
3283 if (RMName) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003284 CmdArgs.push_back("-mrelocation-model");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003285 CmdArgs.push_back(RMName);
3286 }
3287 if (PICLevel > 0) {
3288 CmdArgs.push_back("-pic-level");
3289 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
3290 if (IsPIE) {
3291 CmdArgs.push_back("-pie-level");
3292 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003293 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003294 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003295
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003296 CmdArgs.push_back("-mthread-model");
3297 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3298 CmdArgs.push_back(A->getValue());
3299 else
3300 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3301
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003302 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3303
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003304 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3305 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003306 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003307
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003308 // LLVM Code Generator Options.
3309
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003310 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3311 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003312 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3313 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003314 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003315 CmdArgs.push_back(A->getValue());
3316 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003317 }
3318 }
3319
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003320 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3321 StringRef v = A->getValue();
3322 CmdArgs.push_back("-mllvm");
3323 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3324 A->claim();
3325 }
3326
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003327 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3328 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003329 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003330 }
3331
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003332 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3333 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003334 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00003335 D.Diag(diag::err_drv_unsupported_opt_for_target)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003336 << A->getSpelling() << getToolChain().getTriple().str();
John McCall1fe2a8c2013-06-18 02:46:29 +00003337 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3338 CmdArgs.push_back("-fpcc-struct-return");
3339 } else {
3340 assert(A->getOption().matches(options::OPT_freg_struct_return));
3341 CmdArgs.push_back("-freg-struct-return");
3342 }
3343 }
3344
Roman Divacky65b88cd2011-03-01 17:40:53 +00003345 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
3346 CmdArgs.push_back("-mrtd");
3347
Rafael Espindola224dd632011-12-14 21:02:23 +00003348 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003349 CmdArgs.push_back("-mdisable-fp-elim");
3350 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3351 options::OPT_fno_zero_initialized_in_bss))
3352 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003353
3354 bool OFastEnabled = isOptimizationLevelFast(Args);
3355 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3356 // enabled. This alias option is being used to simplify the hasFlag logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003357 OptSpecifier StrictAliasingAliasOption =
3358 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003359 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3360 // doesn't do any TBAA.
3361 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003362 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003363 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003364 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003365 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3366 options::OPT_fno_struct_path_tbaa))
3367 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003368 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3369 false))
3370 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00003371 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3372 options::OPT_fno_optimize_sibling_calls))
3373 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003374
Eric Christopher006208c2013-04-04 06:29:47 +00003375 // Handle segmented stacks.
3376 if (Args.hasArg(options::OPT_fsplit_stack))
3377 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003378
3379 // If -Ofast is the optimization level, then -ffast-math should be enabled.
3380 // This alias option is being used to simplify the getLastArg logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003381 OptSpecifier FastMathAliasOption =
3382 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
3383
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003384 // Handle various floating point optimization flags, mapping them to the
3385 // appropriate LLVM code generation flags. The pattern for all of these is to
3386 // default off the codegen optimizations, and if any flag enables them and no
3387 // flag disables them after the flag enabling them, enable the codegen
3388 // optimization. This is complicated by several "umbrella" flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003389 if (Arg *A = Args.getLastArg(
3390 options::OPT_ffast_math, FastMathAliasOption,
3391 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3392 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
3393 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003394 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3395 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003396 A->getOption().getID() != options::OPT_fhonor_infinities)
3397 CmdArgs.push_back("-menable-no-infs");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003398 if (Arg *A = Args.getLastArg(
3399 options::OPT_ffast_math, FastMathAliasOption,
3400 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3401 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
3402 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003403 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3404 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003405 A->getOption().getID() != options::OPT_fhonor_nans)
3406 CmdArgs.push_back("-menable-no-nans");
3407
Benjamin Kramerc242ef22012-05-02 14:55:48 +00003408 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3409 bool MathErrno = getToolChain().IsMathErrnoDefault();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003410 if (Arg *A =
3411 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3412 options::OPT_fno_fast_math, options::OPT_fmath_errno,
3413 options::OPT_fno_math_errno)) {
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00003414 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3415 // However, turning *off* -ffast_math merely restores the toolchain default
3416 // (which may be false).
3417 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3418 A->getOption().getID() == options::OPT_ffast_math ||
3419 A->getOption().getID() == options::OPT_Ofast)
3420 MathErrno = false;
3421 else if (A->getOption().getID() == options::OPT_fmath_errno)
3422 MathErrno = true;
3423 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003424 if (MathErrno)
3425 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003426
3427 // There are several flags which require disabling very specific
3428 // optimizations. Any of these being disabled forces us to turn off the
3429 // entire set of LLVM optimizations, so collect them through all the flag
3430 // madness.
3431 bool AssociativeMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003432 if (Arg *A = Args.getLastArg(
3433 options::OPT_ffast_math, FastMathAliasOption,
3434 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3435 options::OPT_fno_unsafe_math_optimizations,
3436 options::OPT_fassociative_math, options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003437 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3438 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003439 A->getOption().getID() != options::OPT_fno_associative_math)
3440 AssociativeMath = true;
3441 bool ReciprocalMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003442 if (Arg *A = Args.getLastArg(
3443 options::OPT_ffast_math, FastMathAliasOption,
3444 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3445 options::OPT_fno_unsafe_math_optimizations,
3446 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003447 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3448 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003449 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3450 ReciprocalMath = true;
3451 bool SignedZeros = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003452 if (Arg *A = Args.getLastArg(
3453 options::OPT_ffast_math, FastMathAliasOption,
3454 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3455 options::OPT_fno_unsafe_math_optimizations,
3456 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003457 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3458 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003459 A->getOption().getID() != options::OPT_fsigned_zeros)
3460 SignedZeros = false;
3461 bool TrappingMath = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003462 if (Arg *A = Args.getLastArg(
3463 options::OPT_ffast_math, FastMathAliasOption,
3464 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3465 options::OPT_fno_unsafe_math_optimizations,
3466 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003467 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3468 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003469 A->getOption().getID() != options::OPT_ftrapping_math)
3470 TrappingMath = false;
3471 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3472 !TrappingMath)
3473 CmdArgs.push_back("-menable-unsafe-fp-math");
3474
Sanjay Patel76c9e092015-01-23 16:40:50 +00003475 if (!SignedZeros)
3476 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003477
Sanjay Patel359b1052015-04-09 15:03:23 +00003478 if (ReciprocalMath)
3479 CmdArgs.push_back("-freciprocal-math");
3480
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003481 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003482 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003483 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003484 options::OPT_ffp_contract)) {
3485 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003486 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003487 if (Val == "fast" || Val == "on" || Val == "off") {
3488 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3489 } else {
3490 D.Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003491 << A->getOption().getName() << Val;
Lang Hamesaa53b932012-07-06 00:59:19 +00003492 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003493 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3494 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003495 // If fast-math is set then set the fp-contract mode to fast.
3496 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3497 }
3498 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003499
Sanjay Patel2987c292015-06-11 14:53:41 +00003500 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00003501
Bob Wilson6a039162012-07-19 03:52:53 +00003502 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3503 // and if we find them, tell the frontend to provide the appropriate
3504 // preprocessor macros. This is distinct from enabling any optimizations as
3505 // these options induce language changes which must survive serialization
3506 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003507 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3508 options::OPT_fno_fast_math))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003509 if (!A->getOption().matches(options::OPT_fno_fast_math))
3510 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003511 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3512 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003513 if (A->getOption().matches(options::OPT_ffinite_math_only))
3514 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003515
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003516 // Decide whether to use verbose asm. Verbose assembly is the default on
3517 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003518 bool IsIntegratedAssemblerDefault =
3519 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003520 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003521 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003522 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003523 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003524
Rafael Espindolab8a12932015-05-22 20:44:03 +00003525 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3526 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003527 CmdArgs.push_back("-no-integrated-as");
3528
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003529 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3530 CmdArgs.push_back("-mdebug-pass");
3531 CmdArgs.push_back("Structure");
3532 }
3533 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3534 CmdArgs.push_back("-mdebug-pass");
3535 CmdArgs.push_back("Arguments");
3536 }
3537
John McCall8517abc2010-02-19 02:45:38 +00003538 // Enable -mconstructor-aliases except on darwin, where we have to
3539 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003540 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003541 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003542
John McCall7ef5cb32011-03-18 02:56:14 +00003543 // Darwin's kernel doesn't support guard variables; just die if we
3544 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003545 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003546 CmdArgs.push_back("-fforbid-guard-variables");
3547
Douglas Gregordbe39272011-02-01 15:15:22 +00003548 if (Args.hasArg(options::OPT_mms_bitfields)) {
3549 CmdArgs.push_back("-mms-bitfields");
3550 }
John McCall8517abc2010-02-19 02:45:38 +00003551
Daniel Dunbar306945d2009-09-16 06:17:29 +00003552 // This is a coarse approximation of what llvm-gcc actually does, both
3553 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3554 // complicated ways.
3555 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003556 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3557 options::OPT_fno_asynchronous_unwind_tables,
3558 (getToolChain().IsUnwindTablesDefault() ||
3559 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3560 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003561 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3562 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003563 CmdArgs.push_back("-munwind-tables");
3564
Chandler Carruth05fb5852012-11-21 23:40:23 +00003565 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003566
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003567 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3568 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003569 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003570 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003571
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003572 // FIXME: Handle -mtune=.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003573 (void)Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003574
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003575 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003576 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003577 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003578 }
3579
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003580 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00003581 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003582 if (!CPU.empty()) {
3583 CmdArgs.push_back("-target-cpu");
3584 CmdArgs.push_back(Args.MakeArgString(CPU));
3585 }
3586
Rafael Espindolaeb265472013-08-21 21:59:03 +00003587 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3588 CmdArgs.push_back("-mfpmath");
3589 CmdArgs.push_back(A->getValue());
3590 }
3591
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003592 // Add the target features
John Brawn94fd9632015-05-21 12:19:49 +00003593 getTargetFeatures(D, Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003594
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003595 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003596 switch (getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003597 default:
3598 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003599
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003600 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003601 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003602 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003603 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003604 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003605 break;
3606
Tim Northover573cbee2014-05-24 12:52:07 +00003607 case llvm::Triple::aarch64:
3608 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003609 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003610 break;
3611
Eric Christopher0b26a612010-03-02 02:41:08 +00003612 case llvm::Triple::mips:
3613 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003614 case llvm::Triple::mips64:
3615 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003616 AddMIPSTargetArgs(Args, CmdArgs);
3617 break;
3618
Ulrich Weigand8afad612014-07-28 13:17:52 +00003619 case llvm::Triple::ppc:
3620 case llvm::Triple::ppc64:
3621 case llvm::Triple::ppc64le:
3622 AddPPCTargetArgs(Args, CmdArgs);
3623 break;
3624
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003625 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00003626 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00003627 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003628 AddSparcTargetArgs(Args, CmdArgs);
3629 break;
3630
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003631 case llvm::Triple::x86:
3632 case llvm::Triple::x86_64:
3633 AddX86TargetArgs(Args, CmdArgs);
3634 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003635
3636 case llvm::Triple::hexagon:
3637 AddHexagonTargetArgs(Args, CmdArgs);
3638 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003639 }
3640
Hans Wennborg75958c42013-08-08 00:17:41 +00003641 // Add clang-cl arguments.
3642 if (getToolChain().getDriver().IsCLMode())
3643 AddClangCLArgs(Args, CmdArgs);
3644
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003645 // Pass the linker version in use.
3646 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3647 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003648 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003649 }
3650
Eric Christopherb7d97e92013-04-03 01:58:53 +00003651 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003652 CmdArgs.push_back("-momit-leaf-frame-pointer");
3653
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003654 // Explicitly error on some things we know we don't support and can't just
3655 // ignore.
Artem Belevichba558952015-05-06 18:20:23 +00003656 types::ID InputType = Input.getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003657 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3658 Arg *Unsupported;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003659 if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003660 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003661 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3662 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003663 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003664 << Unsupported->getOption().getName();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003665 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003666 }
3667
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003668 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003669 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003670 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003671 CmdArgs.push_back("-header-include-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003672 CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
3673 : "-");
Daniel Dunbarac540b32011-02-02 21:11:35 +00003674 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003675 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003676 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003677
Chad Rosierbe10f982011-08-02 17:58:04 +00003678 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003679 CmdArgs.push_back("-diagnostic-log-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003680 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
3681 : "-");
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003682 }
3683
Manman Ren17bdb0f2013-11-20 20:22:14 +00003684 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3685 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003686 Args.ClaimAllArgs(options::OPT_g_Group);
David Blaikiece3e7a62015-07-30 21:42:22 +00003687 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003688 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikiece3e7a62015-07-30 21:42:22 +00003689 if ((A->getOption().matches(options::OPT_gline_tables_only) ||
3690 A->getOption().matches(options::OPT_g1)) &&
3691 (!SplitDwarfArg || A->getIndex() > SplitDwarfArg->getIndex())) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003692 // FIXME: we should support specifying dwarf version with
3693 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003694 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003695 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003696 const llvm::Triple &Triple = getToolChain().getTriple();
3697 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003698 Triple.getOS() == llvm::Triple::FreeBSD ||
3699 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003700 CmdArgs.push_back("-gdwarf-2");
David Blaikiece3e7a62015-07-30 21:42:22 +00003701 SplitDwarfArg = nullptr;
Manman Ren17bdb0f2013-11-20 20:22:14 +00003702 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003703 CmdArgs.push_back("-gdwarf-2");
3704 else if (A->getOption().matches(options::OPT_gdwarf_3))
3705 CmdArgs.push_back("-gdwarf-3");
3706 else if (A->getOption().matches(options::OPT_gdwarf_4))
3707 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003708 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003709 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003710 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003711 const llvm::Triple &Triple = getToolChain().getTriple();
3712 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003713 Triple.getOS() == llvm::Triple::FreeBSD ||
3714 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003715 CmdArgs.push_back("-gdwarf-2");
3716 else
3717 CmdArgs.push_back("-g");
3718 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003719 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003720
Reid Kleckner124955a2015-08-05 18:51:13 +00003721 // Forward -gcodeview.
3722 Args.AddLastArg(CmdArgs, options::OPT_gcodeview);
3723
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003724 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3725 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003726 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3727 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003728 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003729
Eric Christopher138c32b2013-09-13 22:37:55 +00003730 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003731 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3732 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003733 // FIXME: Currently only works on Linux.
David Blaikiece3e7a62015-07-30 21:42:22 +00003734 if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003735 CmdArgs.push_back("-g");
3736 CmdArgs.push_back("-backend-option");
3737 CmdArgs.push_back("-split-dwarf=Enable");
3738 }
3739
Eric Christopher138c32b2013-09-13 22:37:55 +00003740 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3741 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3742 CmdArgs.push_back("-backend-option");
3743 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3744 }
Eric Christophereec89c22013-06-18 00:03:50 +00003745
Eric Christopher0d403d22014-02-14 01:27:03 +00003746 // -gdwarf-aranges turns on the emission of the aranges section in the
3747 // backend.
3748 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3749 CmdArgs.push_back("-backend-option");
3750 CmdArgs.push_back("-generate-arange-section");
3751 }
3752
David Blaikief36d9ba2014-01-27 18:52:43 +00003753 if (Args.hasFlag(options::OPT_fdebug_types_section,
3754 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003755 CmdArgs.push_back("-backend-option");
3756 CmdArgs.push_back("-generate-type-units");
3757 }
Eric Christophereec89c22013-06-18 00:03:50 +00003758
Ed Schouten6e576152015-03-26 17:50:28 +00003759 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3760 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3761
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003762 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003763 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003764 CmdArgs.push_back("-ffunction-sections");
3765 }
3766
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003767 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3768 UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003769 CmdArgs.push_back("-fdata-sections");
3770 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003771
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003772 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00003773 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003774 CmdArgs.push_back("-fno-unique-section-names");
3775
Chris Lattner3c77a352010-06-22 00:03:40 +00003776 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3777
Diego Novilloa0545962015-07-10 18:00:07 +00003778 addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
Nick Lewycky480cb992011-05-04 20:46:58 +00003779
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003780 // Pass options for controlling the default header search paths.
3781 if (Args.hasArg(options::OPT_nostdinc)) {
3782 CmdArgs.push_back("-nostdsysteminc");
3783 CmdArgs.push_back("-nobuiltininc");
3784 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003785 if (Args.hasArg(options::OPT_nostdlibinc))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003786 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003787 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3788 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3789 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003790
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003791 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003792 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003793 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003794
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003795 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3796
Ted Kremenekf7639e12012-03-06 20:06:33 +00003797 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003798 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003799 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003800 options::OPT_ccc_arcmt_modify,
3801 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003802 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003803 switch (A->getOption().getID()) {
3804 default:
3805 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003806 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003807 CmdArgs.push_back("-arcmt-check");
3808 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003809 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003810 CmdArgs.push_back("-arcmt-modify");
3811 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003812 case options::OPT_ccc_arcmt_migrate:
3813 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003814 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003815 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003816
3817 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3818 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003819 break;
John McCalld70fb982011-06-15 23:25:17 +00003820 }
3821 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003822 } else {
3823 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3824 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3825 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003826 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003827
Ted Kremenekf7639e12012-03-06 20:06:33 +00003828 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3829 if (ARCMTEnabled) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003830 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
3831 << "-ccc-arcmt-migrate";
Ted Kremenekf7639e12012-03-06 20:06:33 +00003832 }
3833 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003834 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003835
3836 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003837 options::OPT_objcmt_migrate_subscripting,
3838 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003839 // None specified, means enable them all.
3840 CmdArgs.push_back("-objcmt-migrate-literals");
3841 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003842 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003843 } else {
3844 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3845 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003846 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003847 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003848 } else {
3849 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3850 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3851 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3852 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3853 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3854 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00003855 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003856 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3857 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3858 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3859 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3860 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3861 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3862 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003863 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003864 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003865 }
3866
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003867 // Add preprocessing options like -I, -D, etc. if we are using the
3868 // preprocessor.
3869 //
3870 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003871 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003872 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003873
Rafael Espindolaa7431922011-07-21 23:40:37 +00003874 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3875 // that "The compiler can only warn and ignore the option if not recognized".
3876 // When building with ccache, it will pass -D options to clang even on
3877 // preprocessed inputs and configure concludes that -fPIC is not supported.
3878 Args.ClaimAllArgs(options::OPT_D);
3879
Alp Toker7874bdc2013-11-15 20:40:58 +00003880 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003881 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3882 if (A->getOption().matches(options::OPT_O4)) {
3883 CmdArgs.push_back("-O3");
3884 D.Diag(diag::warn_O4_is_O3);
3885 } else {
3886 A->render(Args, CmdArgs);
3887 }
3888 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003889
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003890 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00003891 for (const Arg *A :
3892 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3893 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Douglas Katzman8b50e012015-08-05 18:03:47 +00003894 A->claim();
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003895 }
3896
Rafael Espindola577637a2015-01-03 00:06:04 +00003897 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003898
Richard Smith3be1cb22014-08-07 00:24:21 +00003899 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003900 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003901 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3902 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003903 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003904 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003905
3906 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003907 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003908 //
3909 // If a std is supplied, only add -trigraphs if it follows the
3910 // option.
David Majnemer8db91762015-05-18 04:49:30 +00003911 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003912 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3913 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003914 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003915 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003916 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003917 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003918 else
3919 Std->render(Args, CmdArgs);
3920
Nico Weber00721502014-12-23 22:32:37 +00003921 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003922 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003923 options::OPT_ftrigraphs,
3924 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003925 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003926 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003927 } else {
3928 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003929 //
3930 // FIXME: Clang doesn't correctly handle -std= when the input language
3931 // doesn't match. For the time being just ignore this for C++ inputs;
3932 // eventually we want to do all the standard defaulting here instead of
3933 // splitting it between the driver and clang -cc1.
3934 if (!types::isCXX(InputType))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003935 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
3936 /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003937 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00003938 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00003939
Nico Weber00721502014-12-23 22:32:37 +00003940 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3941 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003942 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003943
Richard Smith282b4492013-09-04 22:50:31 +00003944 // GCC's behavior for -Wwrite-strings is a bit strange:
3945 // * In C, this "warning flag" changes the types of string literals from
3946 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3947 // for the discarded qualifier.
3948 // * In C++, this is just a normal warning flag.
3949 //
3950 // Implementing this warning correctly in C is hard, so we follow GCC's
3951 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3952 // a non-const char* in C, rather than using this crude hack.
3953 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003954 // FIXME: This should behave just like a warning flag, and thus should also
3955 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3956 Arg *WriteStrings =
3957 Args.getLastArg(options::OPT_Wwrite_strings,
3958 options::OPT_Wno_write_strings, options::OPT_w);
3959 if (WriteStrings &&
3960 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003961 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003962 }
3963
Chandler Carruth61fbf622011-04-23 09:27:53 +00003964 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003965 // during C++ compilation, which it is by default. GCC keeps this define even
3966 // in the presence of '-w', match this behavior bug-for-bug.
3967 if (types::isCXX(InputType) &&
3968 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3969 true)) {
3970 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003971 }
3972
Chandler Carruthe0391482010-05-22 02:21:53 +00003973 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3974 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3975 if (Asm->getOption().matches(options::OPT_fasm))
3976 CmdArgs.push_back("-fgnu-keywords");
3977 else
3978 CmdArgs.push_back("-fno-gnu-keywords");
3979 }
3980
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003981 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3982 CmdArgs.push_back("-fno-dwarf-directory-asm");
3983
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003984 if (ShouldDisableAutolink(Args, getToolChain()))
3985 CmdArgs.push_back("-fno-autolink");
3986
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003987 // Add in -fdebug-compilation-dir if necessary.
3988 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003989
Richard Smith9a568822011-11-21 19:36:32 +00003990 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3991 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003992 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003993 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003994 }
3995
Richard Smith79c927b2013-11-06 19:31:51 +00003996 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3997 CmdArgs.push_back("-foperator-arrow-depth");
3998 CmdArgs.push_back(A->getValue());
3999 }
4000
Richard Smith9a568822011-11-21 19:36:32 +00004001 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4002 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004003 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00004004 }
4005
Richard Smitha3d3bd22013-05-08 02:12:03 +00004006 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4007 CmdArgs.push_back("-fconstexpr-steps");
4008 CmdArgs.push_back(A->getValue());
4009 }
4010
Richard Smithb3a14522013-02-22 01:59:51 +00004011 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4012 CmdArgs.push_back("-fbracket-depth");
4013 CmdArgs.push_back(A->getValue());
4014 }
4015
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00004016 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4017 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004018 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004019 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004020 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
4021 } else
4022 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00004023 }
4024
Michael J. Spencer929fccd2012-10-22 22:13:48 +00004025 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00004026 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00004027
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004028 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4029 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00004030 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004031 }
David Chisnall5778fce2009-08-31 16:41:57 +00004032
Chris Lattnere23003d2010-01-09 21:54:33 +00004033 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4034 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00004035 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00004036 }
4037
Chris Lattnerb35583d2010-04-07 20:49:23 +00004038 CmdArgs.push_back("-ferror-limit");
4039 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00004040 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00004041 else
4042 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00004043
Chandler Carrutha77a7272010-05-06 04:55:18 +00004044 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4045 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004046 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004047 }
4048
4049 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4050 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004051 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004052 }
4053
Richard Smithf6f003a2011-12-16 19:06:07 +00004054 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4055 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004056 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00004057 }
4058
Nick Lewycky24653262014-12-16 21:39:02 +00004059 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4060 CmdArgs.push_back("-fspell-checking-limit");
4061 CmdArgs.push_back(A->getValue());
4062 }
4063
Daniel Dunbar2c978472009-11-04 06:24:47 +00004064 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00004065 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00004066 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004067 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00004068 } else {
4069 // If -fmessage-length=N was not specified, determine whether this is a
4070 // terminal and, if so, implicitly define -fmessage-length appropriately.
4071 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004072 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00004073 }
4074
John McCallb4a99d32013-02-19 01:57:35 +00004075 // -fvisibility= and -fvisibility-ms-compat are of a piece.
4076 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4077 options::OPT_fvisibility_ms_compat)) {
4078 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4079 CmdArgs.push_back("-fvisibility");
4080 CmdArgs.push_back(A->getValue());
4081 } else {
4082 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4083 CmdArgs.push_back("-fvisibility");
4084 CmdArgs.push_back("hidden");
4085 CmdArgs.push_back("-ftype-visibility");
4086 CmdArgs.push_back("default");
4087 }
Daniel Dunbare357d562009-12-03 18:42:11 +00004088 }
4089
Douglas Gregor08329632010-06-15 17:05:35 +00004090 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004091
Hans Wennborgf60f6af2012-06-28 08:01:44 +00004092 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4093
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004094 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00004095 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
4096 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004097 CmdArgs.push_back("-ffreestanding");
4098
Daniel Dunbare357d562009-12-03 18:42:11 +00004099 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004100 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004101 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00004102 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
4103 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00004104 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004105 // Emulated TLS is enabled by default on Android, and can be enabled manually
4106 // with -femulated-tls.
4107 bool EmulatedTLSDefault = Triple.getEnvironment() == llvm::Triple::Android;
4108 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
4109 EmulatedTLSDefault))
4110 CmdArgs.push_back("-femulated-tls");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004111 // AltiVec-like language extensions aren't relevant for assembling.
4112 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) {
Bill Schmidtb3b804e2013-07-03 15:36:02 +00004113 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004114 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4115 }
Richard Trieu91844232012-06-26 18:18:47 +00004116 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4117 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00004118
Alexey Bataevdb390212015-05-20 04:24:19 +00004119 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004120 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4121 options::OPT_fno_openmp, false))
4122 switch (getOpenMPRuntime(getToolChain(), Args)) {
4123 case OMPRT_OMP:
4124 case OMPRT_IOMP5:
4125 // Clang can generate useful OpenMP code for these two runtime libraries.
4126 CmdArgs.push_back("-fopenmp");
Samuel Antaof8b50122015-07-13 22:54:53 +00004127
4128 // If no option regarding the use of TLS in OpenMP codegeneration is
4129 // given, decide a default based on the target. Otherwise rely on the
4130 // options and pass the right information to the frontend.
4131 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
4132 options::OPT_fnoopenmp_use_tls,
4133 getToolChain().getArch() == llvm::Triple::ppc ||
4134 getToolChain().getArch() == llvm::Triple::ppc64 ||
4135 getToolChain().getArch() == llvm::Triple::ppc64le))
4136 CmdArgs.push_back("-fnoopenmp-use-tls");
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004137 break;
4138 default:
4139 // By default, if Clang doesn't know how to generate useful OpenMP code
4140 // for a specific runtime library, we just don't pass the '-fopenmp' flag
4141 // down to the actual compilation.
4142 // FIXME: It would be better to have a mode which *only* omits IR
4143 // generation based on the OpenMP support so that we get consistent
4144 // semantic analysis, etc.
4145 break;
4146 }
Alexey Bataevdb390212015-05-20 04:24:19 +00004147
Peter Collingbourne32701642013-11-01 18:16:25 +00004148 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
Peter Collingbourne581f4382015-07-02 01:48:12 +00004149 Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
Richard Smith52be6192012-11-05 22:04:41 +00004150
Eric Christopher459d2712013-02-19 06:16:53 +00004151 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004152 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4153 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4154 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4155 Arch == llvm::Triple::ppc64le))
4156 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4157 << "ppc/ppc64/ppc64le";
4158 }
Chad Rosier864dfe12012-03-13 23:45:51 +00004159
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004160 // -fzvector is incompatible with -faltivec.
4161 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4162 if (Args.hasArg(options::OPT_faltivec))
4163 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4164 << "-faltivec";
4165
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004166 if (getToolChain().SupportsProfiling())
4167 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00004168
4169 // -flax-vector-conversions is default.
4170 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4171 options::OPT_fno_lax_vector_conversions))
4172 CmdArgs.push_back("-fno-lax-vector-conversions");
4173
John Brawna7b4ec02015-08-10 11:11:28 +00004174 if (Args.getLastArg(options::OPT_fapple_kext) ||
4175 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004176 CmdArgs.push_back("-fapple-kext");
4177
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00004178 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00004179 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00004180 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004181 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4182 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00004183
4184 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4185 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00004186 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00004187 }
4188
Bob Wilson14adb362012-02-03 06:27:22 +00004189 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00004190
Chandler Carruth6e501032011-03-27 00:04:55 +00004191 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4192 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004193 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
Chandler Carruth6e501032011-03-27 00:04:55 +00004194 if (A->getOption().matches(options::OPT_fwrapv))
4195 CmdArgs.push_back("-fwrapv");
4196 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4197 options::OPT_fno_strict_overflow)) {
4198 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4199 CmdArgs.push_back("-fwrapv");
4200 }
Hal Finkelce0697f2013-11-17 16:03:29 +00004201
4202 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4203 options::OPT_fno_reroll_loops))
4204 if (A->getOption().matches(options::OPT_freroll_loops))
4205 CmdArgs.push_back("-freroll-loops");
4206
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004207 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00004208 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4209 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004210
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004211 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4212
Daniel Dunbar4930e332009-11-17 08:07:36 +00004213 // -stack-protector=0 is default.
4214 unsigned StackProtectorLevel = 0;
Peter Collingbournec4122c12015-06-15 21:08:13 +00004215 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4216 Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4217 Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4218 Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4219 Args.ClaimAllArgs(options::OPT_fstack_protector);
4220 } else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004221 options::OPT_fstack_protector_all,
4222 options::OPT_fstack_protector_strong,
4223 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004224 if (A->getOption().matches(options::OPT_fstack_protector)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004225 StackProtectorLevel = std::max<unsigned>(
4226 LangOptions::SSPOn,
4227 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
Rafael Espindolace5c6092014-05-22 22:57:39 +00004228 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004229 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004230 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004231 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004232 } else {
4233 StackProtectorLevel =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004234 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
Nico Weberdd473632011-08-23 07:38:27 +00004235 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004236 if (StackProtectorLevel) {
4237 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004238 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004239 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004240
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004241 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004242 for (const Arg *A : Args.filtered(options::OPT__param)) {
4243 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004244 if (Str.startswith("ssp-buffer-size=")) {
4245 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004246 CmdArgs.push_back("-stack-protector-buffer-size");
4247 // FIXME: Verify the argument is a valid integer.
4248 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004249 }
Sean Silva14facf32015-06-09 01:57:17 +00004250 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004251 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004252 }
4253
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004254 // Translate -mstackrealign
4255 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4256 false)) {
4257 CmdArgs.push_back("-backend-option");
4258 CmdArgs.push_back("-force-align-stack");
4259 }
4260 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004261 false)) {
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004262 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
4263 }
4264
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004265 if (Args.hasArg(options::OPT_mstack_alignment)) {
4266 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4267 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00004268 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004269
Hans Wennborg77dc2362015-01-20 19:45:50 +00004270 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4271 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4272
4273 if (!Size.empty())
4274 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4275 else
4276 CmdArgs.push_back("-mstack-probe-size=0");
4277 }
4278
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004279 if (getToolChain().getArch() == llvm::Triple::aarch64 ||
4280 getToolChain().getArch() == llvm::Triple::aarch64_be)
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004281 CmdArgs.push_back("-fallow-half-arguments-and-returns");
4282
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004283 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4284 options::OPT_mno_restrict_it)) {
4285 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4286 CmdArgs.push_back("-backend-option");
4287 CmdArgs.push_back("-arm-restrict-it");
4288 } else {
4289 CmdArgs.push_back("-backend-option");
4290 CmdArgs.push_back("-arm-no-restrict-it");
4291 }
James Y Knight2db38f32015-08-15 03:45:25 +00004292 } else if (Triple.isOSWindows() &&
4293 (Triple.getArch() == llvm::Triple::arm ||
4294 Triple.getArch() == llvm::Triple::thumb)) {
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00004295 // Windows on ARM expects restricted IT blocks
4296 CmdArgs.push_back("-backend-option");
4297 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004298 }
4299
Daniel Dunbard18049a2009-04-07 21:16:11 +00004300 // Forward -f options with positive and negative forms; we translate
4301 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00004302 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4303 StringRef fname = A->getValue();
4304 if (!llvm::sys::fs::exists(fname))
4305 D.Diag(diag::err_drv_no_such_file) << fname;
4306 else
4307 A->render(Args, CmdArgs);
4308 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004309
John Brawna7b4ec02015-08-10 11:11:28 +00004310 // -fbuiltin is default unless -mkernel is used
4311 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
4312 !Args.hasArg(options::OPT_mkernel)))
Daniel Dunbar484afa22009-11-19 04:55:23 +00004313 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00004314
Nuno Lopes13c88c72009-12-16 16:59:22 +00004315 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4316 options::OPT_fno_assume_sane_operator_new))
4317 CmdArgs.push_back("-fno-assume-sane-operator-new");
4318
Daniel Dunbar4930e332009-11-17 08:07:36 +00004319 // -fblocks=0 is default.
4320 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00004321 getToolChain().IsBlocksDefault()) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004322 (Args.hasArg(options::OPT_fgnu_runtime) &&
4323 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4324 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00004325 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00004326
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004327 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
John McCall7959fee2011-09-09 20:41:01 +00004328 !getToolChain().hasBlocksRuntime())
4329 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00004330 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004331
Richard Smith47972af2015-06-16 00:08:24 +00004332 // -fmodules enables the use of precompiled modules (off by default).
Richard Smithffb65082014-09-30 23:10:19 +00004333 // Users can pass -fno-cxx-modules to turn off modules support for
Richard Smith47972af2015-06-16 00:08:24 +00004334 // C++/Objective-C++ programs.
Douglas Gregorc60437f2013-01-16 01:23:41 +00004335 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00004336 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004337 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4338 options::OPT_fno_cxx_modules, true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00004339 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00004340 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00004341 HaveModules = true;
4342 }
4343 }
4344
Richard Smith47972af2015-06-16 00:08:24 +00004345 // -fmodule-maps enables implicit reading of module map files. By default,
4346 // this is enabled if we are using precompiled modules.
Richard Smithcf18b792015-06-16 00:20:23 +00004347 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4348 options::OPT_fno_implicit_module_maps, HaveModules)) {
Richard Smith47972af2015-06-16 00:08:24 +00004349 CmdArgs.push_back("-fimplicit-module-maps");
Daniel Jasper07e6c402013-08-05 20:26:17 +00004350 }
4351
Daniel Jasperac42b752013-10-21 06:34:34 +00004352 // -fmodules-decluse checks that modules used are declared so (off by
4353 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004354 if (Args.hasFlag(options::OPT_fmodules_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004355 options::OPT_fno_modules_decluse, false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00004356 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004357 }
4358
Daniel Jasper962b38e2014-04-11 11:47:45 +00004359 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4360 // all #included headers are part of modules.
4361 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004362 options::OPT_fno_modules_strict_decluse, false)) {
Daniel Jasper962b38e2014-04-11 11:47:45 +00004363 CmdArgs.push_back("-fmodules-strict-decluse");
4364 }
4365
Manuel Klimekd2e8b042015-02-20 11:44:41 +00004366 // -fno-implicit-modules turns off implicitly compiling modules on demand.
4367 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4368 options::OPT_fno_implicit_modules)) {
4369 CmdArgs.push_back("-fno-implicit-modules");
4370 }
4371
Daniel Jasperac42b752013-10-21 06:34:34 +00004372 // -fmodule-name specifies the module that is currently being built (or
4373 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00004374 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00004375
Richard Smith9887d792014-10-17 01:42:53 +00004376 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00004377 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00004378 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00004379
Richard Smithe842a472014-10-22 02:05:46 +00004380 // -fmodule-file can be used to specify files containing precompiled modules.
4381 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4382
4383 // -fmodule-cache-path specifies where our implicitly-built module files
4384 // should be written.
Diego Novilloa0545962015-07-10 18:00:07 +00004385 SmallString<128> Path;
Justin Bognera88f0122014-06-20 22:59:50 +00004386 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
Daniel Jasper7450f912015-07-10 08:25:54 +00004387 Path = A->getValue();
Justin Bognera88f0122014-06-20 22:59:50 +00004388 if (HaveModules) {
4389 if (C.isForDiagnostics()) {
4390 // When generating crash reports, we want to emit the modules along with
4391 // the reproduction sources, so we ignore any provided module path.
Daniel Jasper7450f912015-07-10 08:25:54 +00004392 Path = Output.getFilename();
4393 llvm::sys::path::replace_extension(Path, ".cache");
4394 llvm::sys::path::append(Path, "modules");
4395 } else if (Path.empty()) {
Justin Bognera88f0122014-06-20 22:59:50 +00004396 // No module path was provided: use the default.
Renato Golin7c542b42015-07-27 23:44:45 +00004397 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Path);
Daniel Jasper7450f912015-07-10 08:25:54 +00004398 llvm::sys::path::append(Path, "org.llvm.clang.");
4399 appendUserToPath(Path);
4400 llvm::sys::path::append(Path, "ModuleCache");
Justin Bognera88f0122014-06-20 22:59:50 +00004401 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004402 const char Arg[] = "-fmodules-cache-path=";
Daniel Jasper7450f912015-07-10 08:25:54 +00004403 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
4404 CmdArgs.push_back(Args.MakeArgString(Path));
Justin Bognera88f0122014-06-20 22:59:50 +00004405 }
4406
4407 // When building modules and generating crashdumps, we need to dump a module
4408 // dependency VFS alongside the output.
4409 if (HaveModules && C.isForDiagnostics()) {
4410 SmallString<128> VFSDir(Output.getFilename());
4411 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004412 // Add the cache directory as a temp so the crash diagnostics pick it up.
4413 C.addTempFile(Args.MakeArgString(VFSDir));
4414
Justin Bognera88f0122014-06-20 22:59:50 +00004415 llvm::sys::path::append(VFSDir, "vfs");
4416 CmdArgs.push_back("-module-dependency-dir");
4417 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004418 }
4419
Richard Smith9887d792014-10-17 01:42:53 +00004420 if (HaveModules)
4421 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004422
Douglas Gregor35b04d62013-02-07 19:01:24 +00004423 // Pass through all -fmodules-ignore-macro arguments.
4424 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004425 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4426 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004427
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004428 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4429
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004430 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4431 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4432 D.Diag(diag::err_drv_argument_not_allowed_with)
4433 << A->getAsString(Args) << "-fbuild-session-timestamp";
4434
4435 llvm::sys::fs::file_status Status;
4436 if (llvm::sys::fs::status(A->getValue(), Status))
4437 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004438 CmdArgs.push_back(Args.MakeArgString(
4439 "-fbuild-session-timestamp=" +
4440 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004441 }
4442
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004443 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004444 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4445 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004446 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4447
4448 Args.AddLastArg(CmdArgs,
4449 options::OPT_fmodules_validate_once_per_build_session);
4450 }
4451
Ben Langmuirdcf73862014-03-12 00:06:17 +00004452 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4453
John McCalldfea9982010-04-09 19:12:06 +00004454 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004455 if (Args.hasFlag(options::OPT_fno_access_control,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004456 options::OPT_faccess_control, false))
John McCall3155f572010-04-09 19:03:51 +00004457 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004458
Anders Carlssond470fef2010-11-21 00:09:52 +00004459 // -felide-constructors is the default.
4460 if (Args.hasFlag(options::OPT_fno_elide_constructors,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004461 options::OPT_felide_constructors, false))
Anders Carlssond470fef2010-11-21 00:09:52 +00004462 CmdArgs.push_back("-fno-elide-constructors");
4463
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004464 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004465
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004466 if (KernelOrKext || (types::isCXX(InputType) &&
4467 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4468 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004469 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004470
Tony Linthicum76329bf2011-12-12 21:14:55 +00004471 // -fshort-enums=0 is default for all architectures except Hexagon.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004472 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4473 getToolChain().getArch() == llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004474 CmdArgs.push_back("-fshort-enums");
4475
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004476 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00004477 if (Arg *A = Args.getLastArg(
4478 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4479 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4480 if (A->getOption().matches(options::OPT_funsigned_char) ||
4481 A->getOption().matches(options::OPT_fno_signed_char)) {
4482 CmdArgs.push_back("-fno-signed-char");
4483 }
4484 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004485 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00004486 }
Eli Friedman327f0b52009-06-05 07:21:14 +00004487
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004488 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004489 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4490 options::OPT_fno_use_cxa_atexit,
4491 !IsWindowsCygnus && !IsWindowsGNU &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004492 getToolChain().getArch() != llvm::Triple::hexagon &&
4493 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004494 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004495 CmdArgs.push_back("-fno-use-cxa-atexit");
4496
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004497 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004498 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004499 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004500 CmdArgs.push_back("-fms-extensions");
4501
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004502 // -fno-use-line-directives is default.
4503 if (Args.hasFlag(options::OPT_fuse_line_directives,
4504 options::OPT_fno_use_line_directives, false))
4505 CmdArgs.push_back("-fuse-line-directives");
4506
Francois Pichet1b4f1632011-09-17 04:32:15 +00004507 // -fms-compatibility=0 is default.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004508 if (Args.hasFlag(options::OPT_fms_compatibility,
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004509 options::OPT_fno_ms_compatibility,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004510 (IsWindowsMSVC &&
4511 Args.hasFlag(options::OPT_fms_extensions,
4512 options::OPT_fno_ms_extensions, true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004513 CmdArgs.push_back("-fms-compatibility");
4514
David Majnemerc371ff02015-03-22 08:39:22 +00004515 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00004516 VersionTuple MSVT = visualstudio::getMSVCVersion(
4517 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4518 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00004519 CmdArgs.push_back(
4520 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004521
David Majnemer8db91762015-05-18 04:49:30 +00004522 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4523 if (ImplyVCPPCXXVer) {
4524 if (IsMSVC2015Compatible)
4525 CmdArgs.push_back("-std=c++14");
4526 else
4527 CmdArgs.push_back("-std=c++11");
4528 }
4529
Eric Christopher5ecce122013-02-18 00:38:31 +00004530 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004531 if (Args.hasFlag(options::OPT_fborland_extensions,
4532 options::OPT_fno_borland_extensions, false))
4533 CmdArgs.push_back("-fborland-extensions");
4534
David Majnemerc371ff02015-03-22 08:39:22 +00004535 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4536 // than 19.
4537 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4538 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00004539 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00004540 CmdArgs.push_back("-fno-threadsafe-statics");
4541
Francois Pichet02744872011-09-01 16:38:08 +00004542 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4543 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004544 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004545 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004546 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004547
Chandler Carruthe03aa552010-04-17 20:17:31 +00004548 // -fgnu-keywords default varies depending on language; only pass if
4549 // specified.
4550 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004551 options::OPT_fno_gnu_keywords))
4552 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004553
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004554 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
Rafael Espindola922a6242011-06-02 17:30:53 +00004555 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004556 CmdArgs.push_back("-fgnu89-inline");
4557
Chad Rosier9c76d242012-03-15 22:31:42 +00004558 if (Args.hasArg(options::OPT_fno_inline))
4559 CmdArgs.push_back("-fno-inline");
4560
Chad Rosier64d6be92012-03-06 21:17:19 +00004561 if (Args.hasArg(options::OPT_fno_inline_functions))
4562 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004563
John McCall5fb5df92012-06-20 06:18:46 +00004564 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004565
John McCall5fb5df92012-06-20 06:18:46 +00004566 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004567 // legacy is the default. Except for deployment taget of 10.5,
4568 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4569 // gets ignored silently.
4570 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004571 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4572 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004573 objcRuntime.isLegacyDispatchDefaultForArch(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004574 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004575 if (getToolChain().UseObjCMixedDispatch())
4576 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4577 else
4578 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4579 }
4580 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004581
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004582 // When ObjectiveC legacy runtime is in effect on MacOSX,
4583 // turn on the option to do Array/Dictionary subscripting
4584 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004585 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004586 getToolChain().getTriple().isMacOSX() &&
4587 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4588 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004589 objcRuntime.isNeXTFamily())
4590 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004591
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004592 // -fencode-extended-block-signature=1 is default.
4593 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4594 CmdArgs.push_back("-fencode-extended-block-signature");
4595 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004596
John McCall24fc0de2011-07-06 00:26:06 +00004597 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4598 // NOTE: This logic is duplicated in ToolChains.cpp.
4599 bool ARC = isObjCAutoRefCount(Args);
4600 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004601 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004602
John McCall24fc0de2011-07-06 00:26:06 +00004603 CmdArgs.push_back("-fobjc-arc");
4604
Chandler Carruth491db322011-11-04 07:34:47 +00004605 // FIXME: It seems like this entire block, and several around it should be
4606 // wrapped in isObjC, but for now we just use it here as this is where it
4607 // was being used previously.
4608 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4609 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4610 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4611 else
4612 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4613 }
4614
John McCall24fc0de2011-07-06 00:26:06 +00004615 // Allow the user to enable full exceptions code emission.
4616 // We define off for Objective-CC, on for Objective-C++.
4617 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4618 options::OPT_fno_objc_arc_exceptions,
4619 /*default*/ types::isCXX(InputType)))
4620 CmdArgs.push_back("-fobjc-arc-exceptions");
4621 }
4622
4623 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4624 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004625 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004626 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004627
John McCall24fc0de2011-07-06 00:26:06 +00004628 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4629 // takes precedence.
4630 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4631 if (!GCArg)
4632 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4633 if (GCArg) {
4634 if (ARC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004635 D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00004636 } else if (getToolChain().SupportsObjCGC()) {
4637 GCArg->render(Args, CmdArgs);
4638 } else {
4639 // FIXME: We should move this to a hard error.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004640 D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00004641 }
4642 }
4643
Bob Wilsonb111ec92015-03-02 19:01:14 +00004644 if (Args.hasFlag(options::OPT_fapplication_extension,
4645 options::OPT_fno_application_extension, false))
4646 CmdArgs.push_back("-fapplication-extension");
4647
Reid Klecknerc542d372014-06-27 17:02:02 +00004648 // Handle GCC-style exception args.
4649 if (!C.getDriver().IsCLMode())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004650 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
4651 CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004652
4653 if (getToolChain().UseSjLjExceptions())
4654 CmdArgs.push_back("-fsjlj-exceptions");
4655
4656 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004657 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4658 options::OPT_fno_assume_sane_operator_new))
4659 CmdArgs.push_back("-fno-assume-sane-operator-new");
4660
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004661 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4662 // most platforms.
4663 if (Args.hasFlag(options::OPT_fsized_deallocation,
4664 options::OPT_fno_sized_deallocation, false))
4665 CmdArgs.push_back("-fsized-deallocation");
4666
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004667 // -fconstant-cfstrings is default, and may be subject to argument translation
4668 // on Darwin.
4669 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4670 options::OPT_fno_constant_cfstrings) ||
4671 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4672 options::OPT_mno_constant_cfstrings))
4673 CmdArgs.push_back("-fno-constant-cfstrings");
4674
John Thompsoned4e2952009-11-05 20:14:16 +00004675 // -fshort-wchar default varies depending on platform; only
4676 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004677 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4678 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004679 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004680
Hans Wennborg28c96312013-07-31 23:39:13 +00004681 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004682 if (Args.hasFlag(options::OPT_fpascal_strings,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004683 options::OPT_fno_pascal_strings, false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004684 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004685
Daniel Dunbar096ed292011-10-05 21:04:55 +00004686 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4687 // -fno-pack-struct doesn't apply to -fpack-struct=.
4688 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004689 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004690 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004691 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004692 } else if (Args.hasFlag(options::OPT_fpack_struct,
4693 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004694 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004695 }
4696
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004697 // Handle -fmax-type-align=N and -fno-type-align
4698 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4699 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4700 if (!SkipMaxTypeAlign) {
4701 std::string MaxTypeAlignStr = "-fmax-type-align=";
4702 MaxTypeAlignStr += A->getValue();
4703 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4704 }
4705 } else if (getToolChain().getTriple().isOSDarwin()) {
4706 if (!SkipMaxTypeAlign) {
4707 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4708 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4709 }
4710 }
4711
John Brawna7b4ec02015-08-10 11:11:28 +00004712 // -fcommon is the default unless compiling kernel code or the target says so
4713 bool NoCommonDefault =
4714 KernelOrKext || isNoCommonDefault(getToolChain().getTriple());
4715 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
4716 !NoCommonDefault))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004717 CmdArgs.push_back("-fno-common");
4718
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004719 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004720 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004721 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004722 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004723 D.Diag(diag::warn_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004724 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004725
Daniel Dunbar6358d682010-10-15 22:30:42 +00004726 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004727 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004728 D.Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004729 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
Daniel Dunbar6358d682010-10-15 22:30:42 +00004730
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004731 // -finput_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004732 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4733 StringRef value = inputCharset->getValue();
4734 if (value != "UTF-8")
4735 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4736 << value;
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004737 }
4738
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004739 // -fexec_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004740 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4741 StringRef value = execCharset->getValue();
4742 if (value != "UTF-8")
4743 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4744 << value;
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004745 }
4746
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004747 // -fcaret-diagnostics is default.
4748 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4749 options::OPT_fno_caret_diagnostics, true))
4750 CmdArgs.push_back("-fno-caret-diagnostics");
4751
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004752 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004753 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004754 options::OPT_fno_diagnostics_fixit_info))
4755 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004756
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004757 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004758 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004759 options::OPT_fno_diagnostics_show_option))
4760 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004761
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004762 if (const Arg *A =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004763 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004764 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004765 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004766 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004767
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004768 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
Douglas Gregor643c9222011-05-21 17:07:29 +00004769 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004770 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004771 }
4772
Chandler Carruthb6766f02011-03-27 01:50:55 +00004773 if (Arg *A = Args.getLastArg(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004774 options::OPT_fdiagnostics_show_note_include_stack,
4775 options::OPT_fno_diagnostics_show_note_include_stack)) {
Chandler Carruthb6766f02011-03-27 01:50:55 +00004776 if (A->getOption().matches(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004777 options::OPT_fdiagnostics_show_note_include_stack))
Chandler Carruthb6766f02011-03-27 01:50:55 +00004778 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4779 else
4780 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4781 }
4782
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004783 // Color diagnostics are the default, unless the terminal doesn't support
4784 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004785 // Support both clang's -f[no-]color-diagnostics and gcc's
4786 // -f[no-]diagnostics-colors[=never|always|auto].
4787 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004788 for (const auto &Arg : Args) {
4789 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004790 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4791 !O.matches(options::OPT_fdiagnostics_color) &&
4792 !O.matches(options::OPT_fno_color_diagnostics) &&
4793 !O.matches(options::OPT_fno_diagnostics_color) &&
4794 !O.matches(options::OPT_fdiagnostics_color_EQ))
4795 continue;
4796
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004797 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004798 if (O.matches(options::OPT_fcolor_diagnostics) ||
4799 O.matches(options::OPT_fdiagnostics_color)) {
4800 ShowColors = Colors_On;
4801 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4802 O.matches(options::OPT_fno_diagnostics_color)) {
4803 ShowColors = Colors_Off;
4804 } else {
4805 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004806 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004807 if (value == "always")
4808 ShowColors = Colors_On;
4809 else if (value == "never")
4810 ShowColors = Colors_Off;
4811 else if (value == "auto")
4812 ShowColors = Colors_Auto;
4813 else
4814 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004815 << ("-fdiagnostics-color=" + value).str();
Nico Weber7e2da792013-04-17 21:52:44 +00004816 }
4817 }
4818 if (ShowColors == Colors_On ||
4819 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004820 CmdArgs.push_back("-fcolor-diagnostics");
4821
Nico Rieck7857d462013-09-11 00:38:02 +00004822 if (Args.hasArg(options::OPT_fansi_escape_codes))
4823 CmdArgs.push_back("-fansi-escape-codes");
4824
Daniel Dunbardb097022009-06-08 21:13:54 +00004825 if (!Args.hasFlag(options::OPT_fshow_source_location,
4826 options::OPT_fno_show_source_location))
4827 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004828
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004829 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
Douglas Gregor643c9222011-05-21 17:07:29 +00004830 true))
4831 CmdArgs.push_back("-fno-show-column");
4832
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004833 if (!Args.hasFlag(options::OPT_fspell_checking,
4834 options::OPT_fno_spell_checking))
4835 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004836
Chad Rosierc8e56e82012-12-05 21:08:21 +00004837 // -fno-asm-blocks is default.
4838 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4839 false))
4840 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004841
Steven Wucb0d13f2015-01-16 23:05:28 +00004842 // -fgnu-inline-asm is default.
4843 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4844 options::OPT_fno_gnu_inline_asm, true))
4845 CmdArgs.push_back("-fno-gnu-inline-asm");
4846
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004847 // Enable vectorization per default according to the optimization level
4848 // selected. For optimization levels that want vectorization we use the alias
4849 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004850 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004851 OptSpecifier VectorizeAliasOption =
4852 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004853 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004854 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004855 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004856
Chad Rosier136d67d2014-04-28 19:30:57 +00004857 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004858 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004859 OptSpecifier SLPVectAliasOption =
4860 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
Chad Rosier136d67d2014-04-28 19:30:57 +00004861 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004862 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004863 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004864
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004865 // -fno-slp-vectorize-aggressive is default.
4866 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004867 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004868 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004869
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004870 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4871 A->render(Args, CmdArgs);
4872
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004873 // -fdollars-in-identifiers default varies depending on platform and
4874 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004875 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004876 options::OPT_fno_dollars_in_identifiers)) {
4877 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004878 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004879 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004880 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004881 }
4882
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004883 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4884 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004885 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004886 options::OPT_fno_unit_at_a_time)) {
4887 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004888 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004889 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004890
Eli Friedman055c9702011-11-02 01:53:16 +00004891 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4892 options::OPT_fno_apple_pragma_pack, false))
4893 CmdArgs.push_back("-fapple-pragma-pack");
4894
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004895 // le32-specific flags:
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004896 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4897 // by default.
4898 if (getToolChain().getArch() == llvm::Triple::le32) {
4899 CmdArgs.push_back("-fno-math-builtin");
4900 }
4901
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004902// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
4903//
4904// FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004905#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004906 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004907 (getToolChain().getArch() == llvm::Triple::arm ||
4908 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004909 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4910 CmdArgs.push_back("-fno-builtin-strcat");
4911 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4912 CmdArgs.push_back("-fno-builtin-strcpy");
4913 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004914#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004915
Justin Bognera88f0122014-06-20 22:59:50 +00004916 // Enable rewrite includes if the user's asked for it or if we're generating
4917 // diagnostics.
4918 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4919 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004920 if (Args.hasFlag(options::OPT_frewrite_includes,
4921 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004922 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004923 CmdArgs.push_back("-frewrite-includes");
4924
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004925 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004926 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004927 options::OPT_traditional_cpp)) {
4928 if (isa<PreprocessJobAction>(JA))
4929 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004930 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004931 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004932 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004933
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004934 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004935 Args.AddLastArg(CmdArgs, options::OPT_dD);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004936
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004937 // Handle serialized diagnostics.
4938 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4939 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004940 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004941 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004942
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004943 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4944 CmdArgs.push_back("-fretain-comments-from-system-headers");
4945
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004946 // Forward -fcomment-block-commands to -cc1.
4947 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004948 // Forward -fparse-all-comments to -cc1.
4949 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004950
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004951 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4952 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004953 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Sean Silva14facf32015-06-09 01:57:17 +00004954 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
4955 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004956
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004957 // We translate this by hand to the -cc1 argument, since nightly test uses
4958 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00004959 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004960 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004961 } else
Sean Silva14facf32015-06-09 01:57:17 +00004962 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004963 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004964
Bob Wilson23a55f12014-12-21 07:00:00 +00004965 // With -save-temps, we want to save the unoptimized bitcode output from the
Steven Wu546a1962015-07-17 20:09:56 +00004966 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated
4967 // by the frontend.
4968 if (C.getDriver().isSaveTempsEnabled() && isa<CompileJobAction>(JA))
4969 CmdArgs.push_back("-disable-llvm-passes");
Bob Wilson23a55f12014-12-21 07:00:00 +00004970
Daniel Dunbard67a3222009-03-30 06:36:42 +00004971 if (Output.getType() == types::TY_Dependencies) {
4972 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004973 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004974 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004975 CmdArgs.push_back(Output.getFilename());
4976 } else {
4977 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004978 }
4979
Artem Belevich0ff05cd2015-07-13 23:27:56 +00004980 addDashXForInput(Args, Input, CmdArgs);
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004981
Artem Belevich0ff05cd2015-07-13 23:27:56 +00004982 if (Input.isFilename())
4983 CmdArgs.push_back(Input.getFilename());
4984 else
4985 Input.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004986
Chris Lattnere9d7d782009-11-03 19:50:27 +00004987 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4988
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004989 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004990
4991 // Optionally embed the -cc1 level arguments into the debug info, for build
4992 // analysis.
4993 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004994 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004995 for (const auto &Arg : Args)
4996 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004997
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004998 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004999 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005000 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005001 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005002 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005003 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005004 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005005 }
5006 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005007 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005008 }
5009
Eric Christopherd3804002013-02-22 20:12:52 +00005010 // Add the split debug info name to the command lines here so we
5011 // can propagate it to the backend.
David Blaikiece3e7a62015-07-30 21:42:22 +00005012 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005013 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5014 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00005015 const char *SplitDwarfOut;
5016 if (SplitDwarf) {
5017 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00005018 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00005019 CmdArgs.push_back(SplitDwarfOut);
5020 }
5021
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005022 // Host-side cuda compilation receives device-side outputs as Inputs[1...].
5023 // Include them with -fcuda-include-gpubinary.
5024 if (IsCuda && Inputs.size() > 1)
Artem Belevich5bde4e02015-07-20 20:02:54 +00005025 for (auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005026 CmdArgs.push_back("-fcuda-include-gpubinary");
Artem Belevich5bde4e02015-07-20 20:02:54 +00005027 CmdArgs.push_back(I->getFilename());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005028 }
5029
Eric Christopherd3804002013-02-22 20:12:52 +00005030 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00005031 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00005032 Output.getType() == types::TY_Object &&
5033 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00005034 auto CLCommand =
5035 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
Justin Bognerd3371d82015-07-17 03:35:54 +00005036 C.addCommand(llvm::make_unique<FallbackCommand>(
5037 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005038 } else {
Justin Bognerd3371d82015-07-17 03:35:54 +00005039 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005040 }
5041
Eric Christopherf1545832013-02-22 23:50:16 +00005042 // Handle the debug info splitting at object creation time if we're
5043 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00005044 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00005045 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00005046 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00005047
Roman Divacky178e01602011-02-10 16:52:03 +00005048 if (Arg *A = Args.getLastArg(options::OPT_pg))
5049 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005050 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
5051 << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005052
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005053 // Claim some arguments which clang supports automatically.
5054
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00005055 // -fpch-preprocess is used with gcc to add a special marker in the output to
5056 // include the PCH file. Clang's PTH solution is completely transparent, so we
5057 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005058 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005059
Daniel Dunbar17731772009-03-23 19:03:36 +00005060 // Claim some arguments which clang doesn't support, but we don't
5061 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00005062 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5063 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00005064
Rafael Espindolab0092d72013-09-04 19:37:35 +00005065 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00005066 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005067}
5068
John McCall5fb5df92012-06-20 06:18:46 +00005069/// Add options related to the Objective-C runtime/ABI.
5070///
5071/// Returns true if the runtime is non-fragile.
5072ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
5073 ArgStringList &cmdArgs,
5074 RewriteKind rewriteKind) const {
5075 // Look for the controlling runtime option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005076 Arg *runtimeArg =
5077 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5078 options::OPT_fobjc_runtime_EQ);
John McCall5fb5df92012-06-20 06:18:46 +00005079
5080 // Just forward -fobjc-runtime= to the frontend. This supercedes
5081 // options about fragility.
5082 if (runtimeArg &&
5083 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5084 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00005085 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005086 if (runtime.tryParse(value)) {
5087 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005088 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005089 }
5090
5091 runtimeArg->render(args, cmdArgs);
5092 return runtime;
5093 }
5094
5095 // Otherwise, we'll need the ABI "version". Version numbers are
5096 // slightly confusing for historical reasons:
5097 // 1 - Traditional "fragile" ABI
5098 // 2 - Non-fragile ABI, version 1
5099 // 3 - Non-fragile ABI, version 2
5100 unsigned objcABIVersion = 1;
5101 // If -fobjc-abi-version= is present, use that to set the version.
5102 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005103 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005104 if (value == "1")
5105 objcABIVersion = 1;
5106 else if (value == "2")
5107 objcABIVersion = 2;
5108 else if (value == "3")
5109 objcABIVersion = 3;
5110 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005111 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
John McCall5fb5df92012-06-20 06:18:46 +00005112 } else {
5113 // Otherwise, determine if we are using the non-fragile ABI.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005114 bool nonFragileABIIsDefault =
5115 (rewriteKind == RK_NonFragile ||
5116 (rewriteKind == RK_None &&
5117 getToolChain().IsObjCNonFragileABIDefault()));
John McCall5fb5df92012-06-20 06:18:46 +00005118 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5119 options::OPT_fno_objc_nonfragile_abi,
5120 nonFragileABIIsDefault)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005121// Determine the non-fragile ABI version to use.
John McCall5fb5df92012-06-20 06:18:46 +00005122#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5123 unsigned nonFragileABIVersion = 1;
5124#else
5125 unsigned nonFragileABIVersion = 2;
5126#endif
5127
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005128 if (Arg *abiArg =
5129 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005130 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005131 if (value == "1")
5132 nonFragileABIVersion = 1;
5133 else if (value == "2")
5134 nonFragileABIVersion = 2;
5135 else
5136 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005137 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005138 }
5139
5140 objcABIVersion = 1 + nonFragileABIVersion;
5141 } else {
5142 objcABIVersion = 1;
5143 }
5144 }
5145
5146 // We don't actually care about the ABI version other than whether
5147 // it's non-fragile.
5148 bool isNonFragile = objcABIVersion != 1;
5149
5150 // If we have no runtime argument, ask the toolchain for its default runtime.
5151 // However, the rewriter only really supports the Mac runtime, so assume that.
5152 ObjCRuntime runtime;
5153 if (!runtimeArg) {
5154 switch (rewriteKind) {
5155 case RK_None:
5156 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5157 break;
5158 case RK_Fragile:
5159 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5160 break;
5161 case RK_NonFragile:
5162 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5163 break;
5164 }
5165
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005166 // -fnext-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005167 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5168 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005169 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00005170 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5171
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005172 // Otherwise, build for a generic macosx port.
John McCall5fb5df92012-06-20 06:18:46 +00005173 } else {
5174 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5175 }
5176
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005177 // -fgnu-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005178 } else {
5179 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00005180 // Legacy behaviour is to target the gnustep runtime if we are i
5181 // non-fragile mode or the GCC runtime in fragile mode.
5182 if (isNonFragile)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005183 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6));
David Chisnall314896c2012-07-04 10:37:03 +00005184 else
5185 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00005186 }
5187
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005188 cmdArgs.push_back(
5189 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
John McCall5fb5df92012-06-20 06:18:46 +00005190 return runtime;
5191}
5192
Reid Klecknerc542d372014-06-27 17:02:02 +00005193static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5194 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5195 I += HaveDash;
5196 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00005197}
Reid Klecknerc542d372014-06-27 17:02:02 +00005198
5199struct EHFlags {
5200 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
5201 bool Synch;
5202 bool Asynch;
5203 bool NoExceptC;
5204};
5205
5206/// /EH controls whether to run destructor cleanups when exceptions are
5207/// thrown. There are three modifiers:
5208/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5209/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5210/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
5211/// - c: Assume that extern "C" functions are implicitly noexcept. This
5212/// modifier is an optimization, so we ignore it for now.
5213/// The default is /EHs-c-, meaning cleanups are disabled.
5214static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5215 EHFlags EH;
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005216
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005217 std::vector<std::string> EHArgs =
5218 Args.getAllArgValues(options::OPT__SLASH_EH);
Reid Klecknerc542d372014-06-27 17:02:02 +00005219 for (auto EHVal : EHArgs) {
5220 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
5221 switch (EHVal[I]) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005222 case 'a':
5223 EH.Asynch = maybeConsumeDash(EHVal, I);
5224 continue;
5225 case 'c':
5226 EH.NoExceptC = maybeConsumeDash(EHVal, I);
5227 continue;
5228 case 's':
5229 EH.Synch = maybeConsumeDash(EHVal, I);
5230 continue;
5231 default:
5232 break;
Reid Klecknerc542d372014-06-27 17:02:02 +00005233 }
5234 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
5235 break;
5236 }
5237 }
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005238
Reid Kleckner5c6efed2015-07-14 18:16:48 +00005239 // FIXME: Disable C++ EH completely, until it becomes more reliable. Users
5240 // can use -Xclang to manually enable C++ EH until then.
5241 EH = EHFlags();
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005242
Reid Klecknerc542d372014-06-27 17:02:02 +00005243 return EH;
5244}
5245
Hans Wennborg75958c42013-08-08 00:17:41 +00005246void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
5247 unsigned RTOptionID = options::OPT__SLASH_MT;
5248
Hans Wennborgf1a74252013-09-10 20:18:04 +00005249 if (Args.hasArg(options::OPT__SLASH_LDd))
5250 // The /LDd option implies /MTd. The dependent lib part can be overridden,
5251 // but defining _DEBUG is sticky.
5252 RTOptionID = options::OPT__SLASH_MTd;
5253
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00005254 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00005255 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00005256
David Majnemere2afb472015-07-24 06:49:13 +00005257 StringRef FlagForCRT;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005258 switch (RTOptionID) {
5259 case options::OPT__SLASH_MD:
5260 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00005261 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005262 CmdArgs.push_back("-D_MT");
5263 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00005264 FlagForCRT = "--dependent-lib=msvcrt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005265 break;
5266 case options::OPT__SLASH_MDd:
5267 CmdArgs.push_back("-D_DEBUG");
5268 CmdArgs.push_back("-D_MT");
5269 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00005270 FlagForCRT = "--dependent-lib=msvcrtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005271 break;
5272 case options::OPT__SLASH_MT:
5273 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00005274 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005275 CmdArgs.push_back("-D_MT");
David Majnemere2afb472015-07-24 06:49:13 +00005276 FlagForCRT = "--dependent-lib=libcmt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005277 break;
5278 case options::OPT__SLASH_MTd:
5279 CmdArgs.push_back("-D_DEBUG");
5280 CmdArgs.push_back("-D_MT");
David Majnemere2afb472015-07-24 06:49:13 +00005281 FlagForCRT = "--dependent-lib=libcmtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005282 break;
5283 default:
5284 llvm_unreachable("Unexpected option ID.");
Hans Wennborg75958c42013-08-08 00:17:41 +00005285 }
5286
David Majnemere2afb472015-07-24 06:49:13 +00005287 if (Args.hasArg(options::OPT__SLASH_Zl)) {
5288 CmdArgs.push_back("-D_VC_NODEFAULTLIB");
5289 } else {
5290 CmdArgs.push_back(FlagForCRT.data());
5291
5292 // This provides POSIX compatibility (maps 'open' to '_open'), which most
5293 // users want. The /Za flag to cl.exe turns this off, but it's not
5294 // implemented in clang.
5295 CmdArgs.push_back("--dependent-lib=oldnames");
5296 }
Hans Wennborg614f7072013-08-08 19:54:30 +00005297
Hans Wennborg8858a032014-07-21 23:42:07 +00005298 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
5299 // would produce interleaved output, so ignore /showIncludes in such cases.
5300 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5301 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5302 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00005303
David Majnemerf6072342014-07-01 22:24:56 +00005304 // This controls whether or not we emit RTTI data for polymorphic types.
5305 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5306 /*default=*/false))
5307 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00005308
Reid Kleckner124955a2015-08-05 18:51:13 +00005309 // Emit CodeView if -Z7 is present.
5310 bool EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
5311 bool EmitDwarf = Args.hasArg(options::OPT_gdwarf);
5312 // If we are emitting CV but not DWARF, don't build information that LLVM
5313 // can't yet process.
5314 if (EmitCodeView && !EmitDwarf)
5315 CmdArgs.push_back("-gline-tables-only");
5316 if (EmitCodeView)
5317 CmdArgs.push_back("-gcodeview");
5318
Reid Klecknerc542d372014-06-27 17:02:02 +00005319 const Driver &D = getToolChain().getDriver();
5320 EHFlags EH = parseClangCLEHFlags(D, Args);
5321 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005322 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00005323 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005324 CmdArgs.push_back("-fexceptions");
5325 }
Reid Klecknerc542d372014-06-27 17:02:02 +00005326
Hans Wennborge50cec32014-06-13 20:59:54 +00005327 // /EP should expand to -E -P.
5328 if (Args.hasArg(options::OPT__SLASH_EP)) {
5329 CmdArgs.push_back("-E");
5330 CmdArgs.push_back("-P");
5331 }
5332
David Majnemera5b195a2015-02-14 01:35:12 +00005333 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005334 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5335 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00005336 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5337 else
5338 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5339
5340 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5341 VolatileOptionID = A->getOption().getID();
5342
5343 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5344 CmdArgs.push_back("-fms-volatile");
5345
David Majnemer86c318f2014-02-11 21:05:00 +00005346 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5347 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5348 if (MostGeneralArg && BestCaseArg)
5349 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5350 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5351
5352 if (MostGeneralArg) {
5353 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5354 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5355 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5356
5357 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5358 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5359 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5360 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5361 << FirstConflict->getAsString(Args)
5362 << SecondConflict->getAsString(Args);
5363
5364 if (SingleArg)
5365 CmdArgs.push_back("-fms-memptr-rep=single");
5366 else if (MultipleArg)
5367 CmdArgs.push_back("-fms-memptr-rep=multiple");
5368 else
5369 CmdArgs.push_back("-fms-memptr-rep=virtual");
5370 }
5371
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00005372 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5373 A->render(Args, CmdArgs);
5374
Hans Wennborg81f74482013-09-10 01:07:07 +00005375 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5376 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00005377 if (Args.hasArg(options::OPT__SLASH_fallback))
5378 CmdArgs.push_back("msvc-fallback");
5379 else
5380 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00005381 }
Hans Wennborg75958c42013-08-08 00:17:41 +00005382}
5383
Douglas Katzman95354292015-06-23 20:42:09 +00005384visualstudio::Compiler *Clang::getCLFallback() const {
Hans Wennborg1da044a2014-06-26 19:59:02 +00005385 if (!CLFallback)
Douglas Katzman95354292015-06-23 20:42:09 +00005386 CLFallback.reset(new visualstudio::Compiler(getToolChain()));
Hans Wennborg1da044a2014-06-26 19:59:02 +00005387 return CLFallback.get();
5388}
5389
Daniel Sanders7f933f42015-01-30 17:35:23 +00005390void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5391 ArgStringList &CmdArgs) const {
5392 StringRef CPUName;
5393 StringRef ABIName;
5394 const llvm::Triple &Triple = getToolChain().getTriple();
5395 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5396
5397 CmdArgs.push_back("-target-abi");
5398 CmdArgs.push_back(ABIName.data());
5399}
5400
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005401void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005402 const InputInfo &Output, const InputInfoList &Inputs,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005403 const ArgList &Args,
5404 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005405 ArgStringList CmdArgs;
5406
5407 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5408 const InputInfo &Input = Inputs[0];
5409
James Y Knight2db38f32015-08-15 03:45:25 +00005410 std::string TripleStr =
5411 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
5412 const llvm::Triple Triple(TripleStr);
5413
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005414 // Don't warn about "clang -w -c foo.s"
5415 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005416 // and "clang -emit-llvm -c foo.s"
5417 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005418
Rafael Espindola577637a2015-01-03 00:06:04 +00005419 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005420
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005421 // Invoke ourselves in -cc1as mode.
5422 //
5423 // FIXME: Implement custom jobs for internal actions.
5424 CmdArgs.push_back("-cc1as");
5425
5426 // Add the "effective" target triple.
5427 CmdArgs.push_back("-triple");
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005428 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5429
5430 // Set the output mode, we currently only expect to be used as a real
5431 // assembler.
5432 CmdArgs.push_back("-filetype");
5433 CmdArgs.push_back("obj");
5434
Eric Christopher45f2e712012-12-18 00:31:10 +00005435 // Set the main file name, so that debug info works even with
5436 // -save-temps or preprocessed assembly.
5437 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00005438 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00005439
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005440 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00005441 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005442 if (!CPU.empty()) {
5443 CmdArgs.push_back("-target-cpu");
5444 CmdArgs.push_back(Args.MakeArgString(CPU));
5445 }
5446
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005447 // Add the target features
5448 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00005449 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005450
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005451 // Ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005452 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005453
Jim Grosbachc78c2bc2015-06-23 18:20:13 +00005454 // Pass along any -I options so we get proper .include search paths.
5455 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5456
Eric Christopherfc3ee562012-01-10 00:38:01 +00005457 // Determine the original source input.
5458 const Action *SourceAction = &JA;
5459 while (SourceAction->getKind() != Action::InputClass) {
5460 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5461 SourceAction = SourceAction->getInputs()[0];
5462 }
5463
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005464 // Forward -g and handle debug info related flags, assuming we are dealing
5465 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005466 if (SourceAction->getType() == types::TY_Asm ||
5467 SourceAction->getType() == types::TY_PP_Asm) {
5468 Args.ClaimAllArgs(options::OPT_g_Group);
5469 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5470 if (!A->getOption().matches(options::OPT_g0))
5471 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005472
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005473 if (Args.hasArg(options::OPT_gdwarf_2))
5474 CmdArgs.push_back("-gdwarf-2");
5475 if (Args.hasArg(options::OPT_gdwarf_3))
5476 CmdArgs.push_back("-gdwarf-3");
5477 if (Args.hasArg(options::OPT_gdwarf_4))
5478 CmdArgs.push_back("-gdwarf-4");
5479
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005480 // Add the -fdebug-compilation-dir flag if needed.
5481 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005482
5483 // Set the AT_producer to the clang version when using the integrated
5484 // assembler on assembly source files.
5485 CmdArgs.push_back("-dwarf-debug-producer");
5486 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Renato Golina74bbc72015-07-22 15:32:36 +00005487
5488 // And pass along -I options
5489 Args.AddAllArgs(CmdArgs, options::OPT_I);
Eric Christopherfc3ee562012-01-10 00:38:01 +00005490 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005491
James Y Knight5bdf7ab2015-08-19 15:12:02 +00005492 // Handle -fPIC et al -- the relocation-model affects the assembler
5493 // for some targets.
5494 llvm::Reloc::Model RelocationModel;
5495 unsigned PICLevel;
5496 bool IsPIE;
5497 std::tie(RelocationModel, PICLevel, IsPIE) =
5498 ParsePICArgs(getToolChain(), Triple, Args);
5499
5500 const char *RMName = RelocationModelName(RelocationModel);
5501 if (RMName) {
5502 CmdArgs.push_back("-mrelocation-model");
5503 CmdArgs.push_back(RMName);
5504 }
5505
Kevin Enderby292dc082011-12-22 19:31:58 +00005506 // Optionally embed the -cc1as level arguments into the debug info, for build
5507 // analysis.
5508 if (getToolChain().UseDwarfDebugFlags()) {
5509 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005510 for (const auto &Arg : Args)
5511 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005512
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005513 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005514 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5515 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005516 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005517 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005518 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005519 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005520 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005521 }
5522 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005523 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005524 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005525
5526 // FIXME: Add -static support, once we have it.
5527
Daniel Sanders7f933f42015-01-30 17:35:23 +00005528 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005529 switch (getToolChain().getArch()) {
Daniel Sanders7f933f42015-01-30 17:35:23 +00005530 default:
5531 break;
5532
5533 case llvm::Triple::mips:
5534 case llvm::Triple::mipsel:
5535 case llvm::Triple::mips64:
5536 case llvm::Triple::mips64el:
5537 AddMIPSTargetArgs(Args, CmdArgs);
5538 break;
5539 }
5540
David Blaikie372d9502014-01-17 03:17:40 +00005541 // Consume all the warning flags. Usually this would be handled more
5542 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5543 // doesn't handle that so rather than warning about unused flags that are
5544 // actually used, we'll lie by omission instead.
5545 // FIXME: Stop lying and consume only the appropriate driver flags
Sean Silva14facf32015-06-09 01:57:17 +00005546 for (const Arg *A : Args.filtered(options::OPT_W_Group))
5547 A->claim();
David Blaikie372d9502014-01-17 03:17:40 +00005548
David Blaikie9260ed62013-07-25 21:19:01 +00005549 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5550 getToolChain().getDriver());
5551
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005552 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005553
5554 assert(Output.isFilename() && "Unexpected lipo output.");
5555 CmdArgs.push_back("-o");
5556 CmdArgs.push_back(Output.getFilename());
5557
Daniel Dunbarb440f562010-08-02 02:38:21 +00005558 assert(Input.isFilename() && "Invalid input.");
5559 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005560
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005561 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Justin Bognerd3371d82015-07-17 03:35:54 +00005562 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christophera75018a2013-04-10 21:30:40 +00005563
5564 // Handle the debug info splitting at object creation time if we're
5565 // creating an object.
5566 // TODO: Currently only works on linux with newer objcopy.
5567 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005568 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005569 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00005570 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005571}
5572
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005573void GnuTool::anchor() {}
5574
Daniel Dunbara3246a02009-03-18 08:07:30 +00005575void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005576 const InputInfo &Output,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005577 const InputInfoList &Inputs, const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005578 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005579 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005580 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005581
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005582 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005583 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005584 // Don't forward any -g arguments to assembly steps.
5585 if (isa<AssembleJobAction>(JA) &&
5586 A->getOption().matches(options::OPT_g_Group))
5587 continue;
5588
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005589 // Don't forward any -W arguments to assembly and link steps.
5590 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5591 A->getOption().matches(options::OPT_W_Group))
5592 continue;
5593
Daniel Dunbar2da02722009-03-19 07:55:12 +00005594 // It is unfortunate that we have to claim here, as this means
5595 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005596 // platforms using a generic gcc, even if we are just using gcc
5597 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005598 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005599 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005600 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005601 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005602
Daniel Dunbar4e295052010-01-25 22:35:08 +00005603 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005604
5605 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005606 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005607 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005608 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005609 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005610 }
5611
Daniel Dunbar5716d872009-05-02 21:41:52 +00005612 // Try to force gcc to match the tool chain we want, if we recognize
5613 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005614 //
5615 // FIXME: The triple class should directly provide the information we want
5616 // here.
Douglas Katzman38857552015-08-20 18:32:26 +00005617 switch (getToolChain().getArch()) {
5618 default:
5619 break;
5620 case llvm::Triple::x86:
5621 case llvm::Triple::ppc:
Daniel Dunbar5716d872009-05-02 21:41:52 +00005622 CmdArgs.push_back("-m32");
Douglas Katzman38857552015-08-20 18:32:26 +00005623 break;
5624 case llvm::Triple::x86_64:
5625 case llvm::Triple::ppc64:
5626 case llvm::Triple::ppc64le:
Daniel Dunbar5716d872009-05-02 21:41:52 +00005627 CmdArgs.push_back("-m64");
Douglas Katzman38857552015-08-20 18:32:26 +00005628 break;
5629 case llvm::Triple::sparcel:
5630 CmdArgs.push_back("-EL");
5631 break;
5632 }
Daniel Dunbar5716d872009-05-02 21:41:52 +00005633
Daniel Dunbarb440f562010-08-02 02:38:21 +00005634 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005635 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005636 CmdArgs.push_back(Output.getFilename());
5637 } else {
5638 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005639 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005640 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005641
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005642 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005643
5644 // Only pass -x if gcc will understand it; otherwise hope gcc
5645 // understands the suffix correctly. The main use case this would go
5646 // wrong in is for linker inputs if they happened to have an odd
5647 // suffix; really the only way to get this to happen is a command
5648 // like '-x foobar a.c' which will treat a.c like a linker input.
5649 //
5650 // FIXME: For the linker case specifically, can we safely convert
5651 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005652 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005653 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005654 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5655 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005656 D.Diag(diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005657 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005658 else if (II.getType() == types::TY_AST)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005659 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005660 else if (II.getType() == types::TY_ModuleFile)
5661 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005662 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005663
Daniel Dunbara3246a02009-03-18 08:07:30 +00005664 if (types::canTypeBeUserSpecified(II.getType())) {
5665 CmdArgs.push_back("-x");
5666 CmdArgs.push_back(types::getTypeName(II.getType()));
5667 }
5668
Daniel Dunbarb440f562010-08-02 02:38:21 +00005669 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005670 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005671 else {
5672 const Arg &A = II.getInputArg();
5673
5674 // Reverse translate some rewritten options.
5675 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5676 CmdArgs.push_back("-lstdc++");
5677 continue;
5678 }
5679
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005680 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005681 A.render(Args, CmdArgs);
5682 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005683 }
5684
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005685 const std::string customGCCName = D.getCCCGenericGCCName();
5686 const char *GCCName;
5687 if (!customGCCName.empty())
5688 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005689 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005690 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005691 } else
5692 GCCName = "gcc";
5693
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005694 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00005695 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005696}
5697
Douglas Katzman95354292015-06-23 20:42:09 +00005698void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
5699 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005700 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005701}
5702
Douglas Katzman95354292015-06-23 20:42:09 +00005703void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
5704 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005705 const Driver &D = getToolChain().getDriver();
5706
Eric Christophercc7ff502015-01-29 00:56:17 +00005707 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005708 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005709 case types::TY_LLVM_IR:
5710 case types::TY_LTO_IR:
5711 case types::TY_LLVM_BC:
5712 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005713 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005714 break;
5715 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005716 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005717 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005718 case types::TY_Nothing:
5719 CmdArgs.push_back("-fsyntax-only");
5720 break;
5721 default:
5722 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005723 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005724}
5725
Douglas Katzman95354292015-06-23 20:42:09 +00005726void gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
5727 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005728 // The types are (hopefully) good enough.
5729}
5730
Tony Linthicum76329bf2011-12-12 21:14:55 +00005731// Hexagon tools start.
Douglas Katzman95354292015-06-23 20:42:09 +00005732void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
5733 ArgStringList &CmdArgs) const {}
5734void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
5735 const InputInfo &Output,
5736 const InputInfoList &Inputs,
5737 const ArgList &Args,
5738 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005739 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005740
5741 const Driver &D = getToolChain().getDriver();
5742 ArgStringList CmdArgs;
5743
5744 std::string MarchString = "-march=";
Douglas Katzman54366072015-07-27 16:53:08 +00005745 MarchString += toolchains::HexagonToolChain::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005746 CmdArgs.push_back(Args.MakeArgString(MarchString));
5747
5748 RenderExtraToolArgs(JA, CmdArgs);
5749
5750 if (Output.isFilename()) {
5751 CmdArgs.push_back("-o");
5752 CmdArgs.push_back(Output.getFilename());
5753 } else {
5754 assert(Output.isNothing() && "Unexpected output");
5755 CmdArgs.push_back("-fsyntax-only");
5756 }
5757
Douglas Katzman54366072015-07-27 16:53:08 +00005758 if (const char *v = toolchains::HexagonToolChain::GetSmallDataThreshold(Args))
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005759 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005760
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005761 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Matthew Curtise5df3812012-12-07 17:23:04 +00005762
Tony Linthicum76329bf2011-12-12 21:14:55 +00005763 // Only pass -x if gcc will understand it; otherwise hope gcc
5764 // understands the suffix correctly. The main use case this would go
5765 // wrong in is for linker inputs if they happened to have an odd
5766 // suffix; really the only way to get this to happen is a command
5767 // like '-x foobar a.c' which will treat a.c like a linker input.
5768 //
5769 // FIXME: For the linker case specifically, can we safely convert
5770 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005771 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005772 // Don't try to pass LLVM or AST inputs to a generic gcc.
5773 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5774 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5775 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005776 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005777 else if (II.getType() == types::TY_AST)
5778 D.Diag(clang::diag::err_drv_no_ast_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005779 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005780 else if (II.getType() == types::TY_ModuleFile)
5781 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005782 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005783
5784 if (II.isFilename())
5785 CmdArgs.push_back(II.getFilename());
5786 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005787 // Don't render as input, we need gcc to do the translations.
5788 // FIXME: Pranav: What is this ?
Tony Linthicum76329bf2011-12-12 21:14:55 +00005789 II.getInputArg().render(Args, CmdArgs);
5790 }
5791
5792 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005793 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00005794 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005795}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005796
Douglas Katzman95354292015-06-23 20:42:09 +00005797void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
5798 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005799 // The types are (hopefully) good enough.
5800}
5801
Douglas Katzman54366072015-07-27 16:53:08 +00005802static void
5803constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
5804 const toolchains::HexagonToolChain &ToolChain,
5805 const InputInfo &Output, const InputInfoList &Inputs,
5806 const ArgList &Args, ArgStringList &CmdArgs,
5807 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005808
Matthew Curtise689b052012-12-06 15:46:07 +00005809 const Driver &D = ToolChain.getDriver();
5810
Matthew Curtise689b052012-12-06 15:46:07 +00005811 //----------------------------------------------------------------------------
5812 //
5813 //----------------------------------------------------------------------------
5814 bool hasStaticArg = Args.hasArg(options::OPT_static);
5815 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005816 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005817 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5818 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5819 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005820 bool useG0 = false;
Matthew Curtise689b052012-12-06 15:46:07 +00005821 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005822
Matthew Curtise689b052012-12-06 15:46:07 +00005823 //----------------------------------------------------------------------------
5824 // Silence warnings for various options
5825 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005826
Matthew Curtise689b052012-12-06 15:46:07 +00005827 Args.ClaimAllArgs(options::OPT_g_Group);
5828 Args.ClaimAllArgs(options::OPT_emit_llvm);
5829 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5830 // handled somewhere else.
5831 Args.ClaimAllArgs(options::OPT_static_libgcc);
5832
5833 //----------------------------------------------------------------------------
5834 //
5835 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005836 for (const auto &Opt : ToolChain.ExtraOpts)
5837 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005838
Douglas Katzman54366072015-07-27 16:53:08 +00005839 std::string MarchString = toolchains::HexagonToolChain::GetTargetCPU(Args);
Matthew Curtisf10a5952012-12-06 14:16:43 +00005840 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005841
Matthew Curtise689b052012-12-06 15:46:07 +00005842 if (buildingLib) {
5843 CmdArgs.push_back("-shared");
5844 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5845 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005846 }
5847
Matthew Curtise689b052012-12-06 15:46:07 +00005848 if (hasStaticArg)
5849 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005850
Matthew Curtise8f80a12012-12-06 17:49:03 +00005851 if (buildPIE && !buildingLib)
5852 CmdArgs.push_back("-pie");
5853
Douglas Katzman54366072015-07-27 16:53:08 +00005854 if (const char *v =
5855 toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) {
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00005856 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Douglas Katzman54366072015-07-27 16:53:08 +00005857 useG0 = toolchains::HexagonToolChain::UsesG0(v);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005858 }
5859
Matthew Curtise689b052012-12-06 15:46:07 +00005860 //----------------------------------------------------------------------------
5861 //
5862 //----------------------------------------------------------------------------
5863 CmdArgs.push_back("-o");
5864 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005865
Matthew Curtise689b052012-12-06 15:46:07 +00005866 const std::string MarchSuffix = "/" + MarchString;
5867 const std::string G0Suffix = "/G0";
5868 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005869 const std::string RootDir =
Douglas Katzman54366072015-07-27 16:53:08 +00005870 toolchains::HexagonToolChain::GetGnuDir(D.InstalledDir, Args) + "/";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005871 const std::string StartFilesDir =
5872 RootDir + "hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00005873
5874 //----------------------------------------------------------------------------
5875 // moslib
5876 //----------------------------------------------------------------------------
5877 std::vector<std::string> oslibs;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005878 bool hasStandalone = false;
Matthew Curtise689b052012-12-06 15:46:07 +00005879
Sean Silva14facf32015-06-09 01:57:17 +00005880 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5881 A->claim();
5882 oslibs.emplace_back(A->getValue());
Matthew Curtise689b052012-12-06 15:46:07 +00005883 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005884 }
Matthew Curtise689b052012-12-06 15:46:07 +00005885 if (oslibs.empty()) {
5886 oslibs.push_back("standalone");
5887 hasStandalone = true;
5888 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005889
Matthew Curtise689b052012-12-06 15:46:07 +00005890 //----------------------------------------------------------------------------
5891 // Start Files
5892 //----------------------------------------------------------------------------
5893 if (incStdLib && incStartFiles) {
5894
5895 if (!buildingLib) {
5896 if (hasStandalone) {
5897 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005898 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
Matthew Curtise689b052012-12-06 15:46:07 +00005899 }
5900 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5901 }
5902 std::string initObj = useShared ? "/initS.o" : "/init.o";
5903 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5904 }
5905
5906 //----------------------------------------------------------------------------
5907 // Library Search Paths
5908 //----------------------------------------------------------------------------
5909 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005910 for (const auto &LibPath : LibPaths)
5911 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005912
5913 //----------------------------------------------------------------------------
5914 //
5915 //----------------------------------------------------------------------------
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00005916 Args.AddAllArgs(CmdArgs,
5917 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
5918 options::OPT_t, options::OPT_u_Group});
Matthew Curtise689b052012-12-06 15:46:07 +00005919
5920 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5921
5922 //----------------------------------------------------------------------------
5923 // Libraries
5924 //----------------------------------------------------------------------------
5925 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005926 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005927 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5928 CmdArgs.push_back("-lm");
5929 }
5930
5931 CmdArgs.push_back("--start-group");
5932
5933 if (!buildingLib) {
Douglas Katzman2675d012015-06-29 19:12:56 +00005934 for (const std::string &Lib : oslibs)
5935 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
Matthew Curtise689b052012-12-06 15:46:07 +00005936 CmdArgs.push_back("-lc");
5937 }
5938 CmdArgs.push_back("-lgcc");
5939
5940 CmdArgs.push_back("--end-group");
5941 }
5942
5943 //----------------------------------------------------------------------------
5944 // End files
5945 //----------------------------------------------------------------------------
5946 if (incStdLib && incStartFiles) {
5947 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5948 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5949 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005950}
5951
Douglas Katzman95354292015-06-23 20:42:09 +00005952void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
5953 const InputInfo &Output,
5954 const InputInfoList &Inputs,
5955 const ArgList &Args,
5956 const char *LinkingOutput) const {
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005957
Douglas Katzman54366072015-07-27 16:53:08 +00005958 const toolchains::HexagonToolChain &ToolChain =
5959 static_cast<const toolchains::HexagonToolChain &>(getToolChain());
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00005960
5961 ArgStringList CmdArgs;
5962 constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
5963 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00005964
5965 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005966 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
Justin Bognerd3371d82015-07-17 03:35:54 +00005967 CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005968}
5969// Hexagon tools end.
5970
Tom Stellard8fa33092015-07-18 01:49:05 +00005971void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
5972 const InputInfo &Output,
5973 const InputInfoList &Inputs,
5974 const ArgList &Args,
5975 const char *LinkingOutput) const {
5976
5977 std::string Linker = getToolChain().GetProgramPath(getShortName());
5978 ArgStringList CmdArgs;
5979 CmdArgs.push_back("-flavor");
5980 CmdArgs.push_back("gnu");
5981 CmdArgs.push_back("-target");
Tom Stellard1de69e82015-07-18 02:11:07 +00005982 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
Tom Stellard8fa33092015-07-18 01:49:05 +00005983 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5984 CmdArgs.push_back("-o");
5985 CmdArgs.push_back(Output.getFilename());
5986 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5987 CmdArgs, Inputs));
5988}
5989// AMDGPU tools end.
5990
Renato Golin7c542b42015-07-27 23:44:45 +00005991const std::string arm::getARMArch(StringRef Arch, const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005992 std::string MArch;
Renato Goline17c5802015-07-27 23:44:42 +00005993 if (!Arch.empty())
5994 MArch = Arch;
5995 else
Bernard Ogden31561762013-12-12 13:27:11 +00005996 MArch = Triple.getArchName();
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00005997 MArch = StringRef(MArch).lower();
John Brawn94fd9632015-05-21 12:19:49 +00005998
5999 // Handle -march=native.
6000 if (MArch == "native") {
6001 std::string CPU = llvm::sys::getHostCPUName();
6002 if (CPU != "generic") {
6003 // Translate the native cpu into the architecture suffix for that CPU.
6004 const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch);
6005 // If there is no valid architecture suffix for this CPU we don't know how
6006 // to handle it, so return no architecture.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006007 if (strcmp(Suffix, "") == 0)
John Brawn94fd9632015-05-21 12:19:49 +00006008 MArch = "";
6009 else
6010 MArch = std::string("arm") + Suffix;
6011 }
6012 }
6013
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006014 return MArch;
6015}
6016/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Renato Golin7c542b42015-07-27 23:44:45 +00006017const char *arm::getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple) {
Renato Goline17c5802015-07-27 23:44:42 +00006018 std::string MArch = getARMArch(Arch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006019 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
6020 // here means an -march=native that we can't handle, so instead return no CPU.
6021 if (MArch.empty())
6022 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00006023
John Brawna95c1a82015-05-08 12:52:18 +00006024 // We need to return an empty string here on invalid MArch values as the
6025 // various places that call this function can't cope with a null result.
6026 const char *result = Triple.getARMCPUForArch(MArch);
6027 if (result)
6028 return result;
6029 else
6030 return "";
Bernard Ogden31561762013-12-12 13:27:11 +00006031}
6032
6033/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Renato Golin7c542b42015-07-27 23:44:45 +00006034std::string arm::getARMTargetCPU(StringRef CPU, StringRef Arch,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006035 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00006036 // FIXME: Warn on inconsistent use of -mcpu and -march.
6037 // If we have -mcpu=, use that.
Renato Goline17c5802015-07-27 23:44:42 +00006038 if (!CPU.empty()) {
6039 std::string MCPU = StringRef(CPU).lower();
Bernard Ogden31561762013-12-12 13:27:11 +00006040 // Handle -mcpu=native.
6041 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00006042 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00006043 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00006044 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00006045 }
6046
Renato Goline17c5802015-07-27 23:44:42 +00006047 return getARMCPUForMArch(Arch, Triple);
Bernard Ogden31561762013-12-12 13:27:11 +00006048}
6049
6050/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006051/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00006052// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006053const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) {
Vladimir Sukharev457d3412015-08-19 14:50:18 +00006054 if (CPU == "generic")
6055 return llvm::ARMTargetParser::getSubArch(
6056 llvm::ARMTargetParser::parseArch(Arch));
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006057
Renato Golin3c007252015-05-28 15:05:53 +00006058 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
6059 if (ArchKind == llvm::ARM::AK_INVALID)
6060 return "";
6061 return llvm::ARMTargetParser::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00006062}
6063
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006064void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006065 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006066 if (Args.hasArg(options::OPT_r))
6067 return;
6068
John Brawn94fd9632015-05-21 12:19:49 +00006069 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
6070 // to generate BE-8 executables.
6071 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
6072 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006073}
6074
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006075mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
6076 return (NanEncoding)llvm::StringSwitch<int>(CPU)
6077 .Case("mips1", NanLegacy)
6078 .Case("mips2", NanLegacy)
6079 .Case("mips3", NanLegacy)
6080 .Case("mips4", NanLegacy)
6081 .Case("mips5", NanLegacy)
6082 .Case("mips32", NanLegacy)
6083 .Case("mips32r2", NanLegacy)
6084 .Case("mips32r3", NanLegacy | Nan2008)
6085 .Case("mips32r5", NanLegacy | Nan2008)
6086 .Case("mips32r6", Nan2008)
6087 .Case("mips64", NanLegacy)
6088 .Case("mips64r2", NanLegacy)
6089 .Case("mips64r3", NanLegacy | Nan2008)
6090 .Case("mips64r5", NanLegacy | Nan2008)
6091 .Case("mips64r6", Nan2008)
6092 .Default(NanLegacy);
6093}
6094
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006095bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
6096 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6097 return A && (A->getValue() == StringRef(Value));
6098}
6099
Simon Atanasyand95c67d2014-08-13 14:34:14 +00006100bool mips::isUCLibc(const ArgList &Args) {
6101 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00006102 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00006103}
6104
Daniel Sanders2bf13662014-07-10 14:40:57 +00006105bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006106 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
6107 return llvm::StringSwitch<bool>(NaNArg->getValue())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006108 .Case("2008", true)
6109 .Case("legacy", false)
6110 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006111
6112 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00006113 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006114 .Cases("mips32r6", "mips64r6", true)
6115 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006116
6117 return false;
6118}
6119
Daniel Sanders379d44b2014-07-16 11:52:23 +00006120bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
Toma Tabacu94ea6862015-06-16 13:54:13 +00006121 StringRef ABIName, StringRef FloatABI) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00006122 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00006123 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00006124 return false;
6125
6126 if (ABIName != "32")
6127 return false;
6128
Toma Tabacu94ea6862015-06-16 13:54:13 +00006129 // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is
6130 // present.
6131 if (FloatABI == "soft")
6132 return false;
6133
Daniel Sanders379d44b2014-07-16 11:52:23 +00006134 return llvm::StringSwitch<bool>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006135 .Cases("mips2", "mips3", "mips4", "mips5", true)
6136 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
6137 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
6138 .Default(false);
Daniel Sanders379d44b2014-07-16 11:52:23 +00006139}
6140
Toma Tabacu94ea6862015-06-16 13:54:13 +00006141bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple,
6142 StringRef CPUName, StringRef ABIName,
6143 StringRef FloatABI) {
6144 bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
6145
6146 // FPXX shouldn't be used if -msingle-float is present.
6147 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
6148 options::OPT_mdouble_float))
6149 if (A->getOption().matches(options::OPT_msingle_float))
6150 UseFPXX = false;
6151
6152 return UseFPXX;
6153}
6154
Tim Northover157d9112014-01-16 08:48:16 +00006155llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00006156 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
6157 // archs which Darwin doesn't use.
6158
6159 // The matching this routine does is fairly pointless, since it is neither the
6160 // complete architecture list, nor a reasonable subset. The problem is that
6161 // historically the driver driver accepts this and also ties its -march=
6162 // handling to the architecture name, so we need to be careful before removing
6163 // support for it.
6164
6165 // This code must be kept in sync with Clang's Darwin specific argument
6166 // translation.
6167
6168 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006169 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
6170 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
6171 .Case("ppc64", llvm::Triple::ppc64)
6172 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
6173 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
6174 llvm::Triple::x86)
6175 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
6176 // This is derived from the driver driver.
6177 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
6178 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
6179 .Cases("armv7s", "xscale", llvm::Triple::arm)
6180 .Case("arm64", llvm::Triple::aarch64)
6181 .Case("r600", llvm::Triple::r600)
6182 .Case("amdgcn", llvm::Triple::amdgcn)
6183 .Case("nvptx", llvm::Triple::nvptx)
6184 .Case("nvptx64", llvm::Triple::nvptx64)
6185 .Case("amdil", llvm::Triple::amdil)
6186 .Case("spir", llvm::Triple::spir)
6187 .Default(llvm::Triple::UnknownArch);
Rafael Espindoladcbf6982012-10-31 18:51:07 +00006188}
Tony Linthicum76329bf2011-12-12 21:14:55 +00006189
Tim Northover157d9112014-01-16 08:48:16 +00006190void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006191 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00006192 T.setArch(Arch);
6193
6194 if (Str == "x86_64h")
6195 T.setArchName(Str);
6196 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
6197 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00006198 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00006199 }
6200}
6201
Bob Wilsondecc03e2012-11-23 06:14:39 +00006202const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00006203 const InputInfo &Input) {
6204 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006205}
6206
Bob Wilsondecc03e2012-11-23 06:14:39 +00006207const char *Clang::getBaseInputStem(const ArgList &Args,
6208 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00006209 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006210
Chris Lattner906bb902011-01-16 08:14:11 +00006211 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00006212 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006213
6214 return Str;
6215}
6216
Bob Wilsondecc03e2012-11-23 06:14:39 +00006217const char *Clang::getDependencyFileName(const ArgList &Args,
6218 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006219 // FIXME: Think about this more.
6220 std::string Res;
6221
6222 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00006223 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006224 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00006225 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00006226 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00006227 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00006228 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006229}
6230
Douglas Katzman95354292015-06-23 20:42:09 +00006231void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6232 const InputInfo &Output,
6233 const InputInfoList &Inputs,
6234 const ArgList &Args,
6235 const char *LinkingOutput) const {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006236 const ToolChain &ToolChain = getToolChain();
6237 const Driver &D = ToolChain.getDriver();
6238 ArgStringList CmdArgs;
6239
6240 // Silence warning for "clang -g foo.o -o foo"
6241 Args.ClaimAllArgs(options::OPT_g_Group);
6242 // and "clang -emit-llvm foo.o -o foo"
6243 Args.ClaimAllArgs(options::OPT_emit_llvm);
6244 // and for "clang -w foo.o -o foo". Other warning options are already
6245 // handled somewhere else.
6246 Args.ClaimAllArgs(options::OPT_w);
6247
6248 if (!D.SysRoot.empty())
6249 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6250
6251 // CloudABI only supports static linkage.
6252 CmdArgs.push_back("-Bstatic");
6253 CmdArgs.push_back("--eh-frame-hdr");
6254 CmdArgs.push_back("--gc-sections");
6255
6256 if (Output.isFilename()) {
6257 CmdArgs.push_back("-o");
6258 CmdArgs.push_back(Output.getFilename());
6259 } else {
6260 assert(Output.isNothing() && "Invalid output.");
6261 }
6262
6263 if (!Args.hasArg(options::OPT_nostdlib) &&
6264 !Args.hasArg(options::OPT_nostartfiles)) {
6265 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
6266 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
6267 }
6268
6269 Args.AddAllArgs(CmdArgs, options::OPT_L);
6270 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
6271 for (const auto &Path : Paths)
6272 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006273 Args.AddAllArgs(CmdArgs,
6274 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6275 options::OPT_t, options::OPT_Z_Flag, options::OPT_r});
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006276
Alexey Samsonov907880e2015-06-19 19:57:46 +00006277 if (D.IsUsingLTO(Args))
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006278 AddGoldPlugin(ToolChain, Args, CmdArgs);
6279
6280 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6281
6282 if (!Args.hasArg(options::OPT_nostdlib) &&
6283 !Args.hasArg(options::OPT_nodefaultlibs)) {
6284 if (D.CCCIsCXX())
6285 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6286 CmdArgs.push_back("-lc");
6287 CmdArgs.push_back("-lcompiler_rt");
6288 }
6289
6290 if (!Args.hasArg(options::OPT_nostdlib) &&
6291 !Args.hasArg(options::OPT_nostartfiles))
6292 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6293
6294 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00006295 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006296}
6297
Douglas Katzman95354292015-06-23 20:42:09 +00006298void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6299 const InputInfo &Output,
6300 const InputInfoList &Inputs,
6301 const ArgList &Args,
6302 const char *LinkingOutput) const {
Daniel Dunbarbe220842009-03-20 16:06:39 +00006303 ArgStringList CmdArgs;
6304
6305 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6306 const InputInfo &Input = Inputs[0];
6307
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006308 // Determine the original source input.
6309 const Action *SourceAction = &JA;
6310 while (SourceAction->getKind() != Action::InputClass) {
6311 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6312 SourceAction = SourceAction->getInputs()[0];
6313 }
6314
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006315 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00006316 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00006317 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
6318 // FIXME: at run-time detect assembler capabilities or rely on version
6319 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006320 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00006321 const llvm::Triple &T(getToolChain().getTriple());
6322 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00006323 CmdArgs.push_back("-Q");
6324 }
Kevin Enderby319baa42013-11-18 23:30:29 +00006325
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006326 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00006327 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006328 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006329 if (Args.hasArg(options::OPT_gstabs))
6330 CmdArgs.push_back("--gstabs");
6331 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00006332 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006333 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006334
Daniel Dunbarbe220842009-03-20 16:06:39 +00006335 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00006336 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006337
Daniel Dunbar6d484762010-07-22 01:47:22 +00006338 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006339 if (getToolChain().getArch() == llvm::Triple::x86 ||
6340 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00006341 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6342 CmdArgs.push_back("-force_cpusubtype_ALL");
6343
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006344 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006345 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00006346 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00006347 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006348 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006349 CmdArgs.push_back("-static");
6350
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006351 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006352
6353 assert(Output.isFilename() && "Unexpected lipo output.");
6354 CmdArgs.push_back("-o");
6355 CmdArgs.push_back(Output.getFilename());
6356
Daniel Dunbarb440f562010-08-02 02:38:21 +00006357 assert(Input.isFilename() && "Invalid input.");
6358 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00006359
6360 // asm_final spec is empty.
6361
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006362 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006363 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00006364}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006365
Tim Northover157d9112014-01-16 08:48:16 +00006366void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00006367
Tim Northover157d9112014-01-16 08:48:16 +00006368void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6369 ArgStringList &CmdArgs) const {
6370 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006371
Daniel Dunbarc1964212009-03-26 16:23:12 +00006372 // Derived from darwin_arch spec.
6373 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006374 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006375
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006376 // FIXME: Is this needed anymore?
6377 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006378 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00006379}
6380
Douglas Katzman95354292015-06-23 20:42:09 +00006381bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
Bill Wendling3b2000f2012-10-02 18:02:50 +00006382 // We only need to generate a temp path for LTO if we aren't compiling object
6383 // files. When compiling source files, we run 'dsymutil' after linking. We
6384 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006385 for (const auto &Input : Inputs)
6386 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00006387 return true;
6388
6389 return false;
6390}
6391
Douglas Katzman95354292015-06-23 20:42:09 +00006392void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
6393 ArgStringList &CmdArgs,
6394 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006395 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00006396 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00006397
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006398 unsigned Version[3] = {0, 0, 0};
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006399 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6400 bool HadExtra;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006401 if (!Driver::GetReleaseVersion(A->getValue(), Version[0], Version[1],
6402 Version[2], HadExtra) ||
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006403 HadExtra)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006404 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006405 }
6406
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006407 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006408 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006409 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6410 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006411
Bob Wilson3d27dad2013-08-02 22:25:34 +00006412 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6413 CmdArgs.push_back("-export_dynamic");
6414
Bob Wilsonb111ec92015-03-02 19:01:14 +00006415 // If we are using App Extension restrictions, pass a flag to the linker
6416 // telling it that the compiled code has been audited.
6417 if (Args.hasFlag(options::OPT_fapplication_extension,
6418 options::OPT_fno_application_extension, false))
6419 CmdArgs.push_back("-application_extension");
6420
Bill Wendling313b6bf2012-11-16 23:03:00 +00006421 // If we are using LTO, then automatically create a temporary file path for
6422 // the linker to use, so that it's lifetime will extend past a possible
6423 // dsymutil step.
Alexey Samsonov907880e2015-06-19 19:57:46 +00006424 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
Bill Wendling313b6bf2012-11-16 23:03:00 +00006425 const char *TmpPath = C.getArgs().MakeArgString(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006426 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
Bill Wendling313b6bf2012-11-16 23:03:00 +00006427 C.addTempFile(TmpPath);
6428 CmdArgs.push_back("-object_path_lto");
6429 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00006430 }
6431
Daniel Dunbarc1964212009-03-26 16:23:12 +00006432 // Derived from the "link" spec.
6433 Args.AddAllArgs(CmdArgs, options::OPT_static);
6434 if (!Args.hasArg(options::OPT_static))
6435 CmdArgs.push_back("-dynamic");
6436 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6437 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6438 // here. How do we wish to handle such things?
6439 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006440
Daniel Dunbarc1964212009-03-26 16:23:12 +00006441 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00006442 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00006443 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00006444 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006445
6446 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6447 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6448 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6449
6450 Arg *A;
6451 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6452 (A = Args.getLastArg(options::OPT_current__version)) ||
6453 (A = Args.getLastArg(options::OPT_install__name)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006454 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
6455 << "-dynamiclib";
Daniel Dunbarc1964212009-03-26 16:23:12 +00006456
6457 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6458 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6459 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6460 } else {
6461 CmdArgs.push_back("-dylib");
6462
6463 Arg *A;
6464 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6465 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6466 (A = Args.getLastArg(options::OPT_client__name)) ||
6467 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6468 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6469 (A = Args.getLastArg(options::OPT_private__bundle)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006470 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
6471 << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006472
Daniel Dunbarc1964212009-03-26 16:23:12 +00006473 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6474 "-dylib_compatibility_version");
6475 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6476 "-dylib_current_version");
6477
Tim Northover157d9112014-01-16 08:48:16 +00006478 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006479
6480 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6481 "-dylib_install_name");
6482 }
6483
6484 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6485 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6486 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006487 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006488 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006489 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6490 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6491 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6492 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6493 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6494 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006495 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006496 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6497 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6498 Args.AddAllArgs(CmdArgs, options::OPT_init);
6499
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006500 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006501 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006502
Daniel Dunbarc1964212009-03-26 16:23:12 +00006503 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6504 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6505 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6506 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6507 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006508
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006509 if (const Arg *A =
6510 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6511 options::OPT_fno_pie, options::OPT_fno_PIE)) {
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006512 if (A->getOption().matches(options::OPT_fpie) ||
6513 A->getOption().matches(options::OPT_fPIE))
6514 CmdArgs.push_back("-pie");
6515 else
6516 CmdArgs.push_back("-no_pie");
6517 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006518
6519 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6520 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6521 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6522 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6523 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6524 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6525 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6526 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6527 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6528 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6529 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6530 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6531 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6532 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6533 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6534 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006535
Daniel Dunbar84384642011-05-02 21:03:47 +00006536 // Give --sysroot= preference, over the Apple specific behavior to also use
6537 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006538 StringRef sysroot = C.getSysRoot();
6539 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006540 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006541 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006542 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6543 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006544 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006545 }
6546
Daniel Dunbarc1964212009-03-26 16:23:12 +00006547 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6548 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6549 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6550 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6551 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006552 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006553 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6554 Args.AddAllArgs(CmdArgs, options::OPT_y);
6555 Args.AddLastArg(CmdArgs, options::OPT_w);
6556 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6557 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6558 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6559 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6560 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6561 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6562 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6563 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6564 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6565 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6566 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6567 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6568}
6569
Douglas Katzman95354292015-06-23 20:42:09 +00006570void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6571 const InputInfo &Output,
6572 const InputInfoList &Inputs,
6573 const ArgList &Args,
6574 const char *LinkingOutput) const {
Daniel Dunbarc1964212009-03-26 16:23:12 +00006575 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006576
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006577 // If the number of arguments surpasses the system limits, we will encode the
6578 // input files in a separate file, shortening the command line. To this end,
6579 // build a list of input file names that can be passed via a file with the
6580 // -filelist linker option.
6581 llvm::opt::ArgStringList InputFileList;
6582
Daniel Dunbarc1964212009-03-26 16:23:12 +00006583 // The logic here is derived from gcc's behavior; most of which
6584 // comes from specs (starting with link_command). Consult gcc for
6585 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006586 ArgStringList CmdArgs;
6587
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006588 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6589 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6590 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006591 for (const auto &Arg : Args)
6592 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006593 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006594 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006595 CmdArgs.push_back(Output.getFilename());
Justin Bognerd3371d82015-07-17 03:35:54 +00006596 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006597 return;
6598 }
6599
Daniel Dunbarc1964212009-03-26 16:23:12 +00006600 // I'm not sure why this particular decomposition exists in gcc, but
6601 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006602 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006603
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006604 // It seems that the 'e' option is completely ignored for dynamic executables
6605 // (the default), and with static executables, the last one wins, as expected.
6606 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
6607 options::OPT_Z_Flag, options::OPT_u_Group,
6608 options::OPT_e, options::OPT_r});
Daniel Dunbarc1964212009-03-26 16:23:12 +00006609
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006610 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6611 // members of static archive libraries which implement Objective-C classes or
6612 // categories.
6613 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6614 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006615
Daniel Dunbarc1964212009-03-26 16:23:12 +00006616 CmdArgs.push_back("-o");
6617 CmdArgs.push_back(Output.getFilename());
6618
Chad Rosier06fd3c62012-05-16 23:45:12 +00006619 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006620 !Args.hasArg(options::OPT_nostartfiles))
6621 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006622
Peter Collingbournec4122c12015-06-15 21:08:13 +00006623 // SafeStack requires its own runtime libraries
6624 // These libraries should be linked first, to make sure the
6625 // __safestack_init constructor executes before everything else
6626 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
6627 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
6628 "libclang_rt.safestack_osx.a",
6629 /*AlwaysLink=*/true);
6630 }
6631
Daniel Dunbarc1964212009-03-26 16:23:12 +00006632 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006633
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006634 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6635 options::OPT_fno_openmp, false)) {
6636 switch (getOpenMPRuntime(getToolChain(), Args)) {
6637 case OMPRT_OMP:
6638 CmdArgs.push_back("-lomp");
6639 break;
6640 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00006641 CmdArgs.push_back("-lgomp");
6642 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006643 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00006644 CmdArgs.push_back("-liomp5");
6645 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00006646 case OMPRT_Unknown:
6647 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00006648 break;
6649 }
Alexey Bataev186b28a2014-03-06 05:43:53 +00006650 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006651
Douglas Gregor9295df02012-05-15 21:00:27 +00006652 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006653 // Build the input file for -filelist (list of linker input files) in case we
6654 // need it later
6655 for (const auto &II : Inputs) {
6656 if (!II.isFilename()) {
6657 // This is a linker input argument.
6658 // We cannot mix input arguments and file names in a -filelist input, thus
6659 // we prematurely stop our list (remaining files shall be passed as
6660 // arguments).
6661 if (InputFileList.size() > 0)
6662 break;
6663
6664 continue;
6665 }
6666
6667 InputFileList.push_back(II.getFilename());
6668 }
6669
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006670 if (isObjCRuntimeLinked(Args) && !Args.hasArg(options::OPT_nostdlib) &&
Bob Wilson16d93952012-05-15 18:57:39 +00006671 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006672 // We use arclite library for both ARC and subscripting support.
6673 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6674
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006675 CmdArgs.push_back("-framework");
6676 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006677 // Link libobj.
6678 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006679 }
John McCall31168b02011-06-15 23:02:42 +00006680
Daniel Dunbarc1964212009-03-26 16:23:12 +00006681 if (LinkingOutput) {
6682 CmdArgs.push_back("-arch_multiple");
6683 CmdArgs.push_back("-final_output");
6684 CmdArgs.push_back(LinkingOutput);
6685 }
6686
Daniel Dunbarc1964212009-03-26 16:23:12 +00006687 if (Args.hasArg(options::OPT_fnested_functions))
6688 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006689
Justin Bognerc7701242015-05-12 05:44:36 +00006690 // TODO: It would be nice to use addProfileRT() here, but darwin's compiler-rt
6691 // paths are different enough from other toolchains that this needs a fair
6692 // amount of refactoring done first.
6693 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6694
Daniel Dunbarc1964212009-03-26 16:23:12 +00006695 if (!Args.hasArg(options::OPT_nostdlib) &&
6696 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006697 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006698 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006699
Daniel Dunbarc1964212009-03-26 16:23:12 +00006700 // link_ssp spec is empty.
6701
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006702 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006703 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006704 }
6705
Chad Rosier06fd3c62012-05-16 23:45:12 +00006706 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006707 !Args.hasArg(options::OPT_nostartfiles)) {
6708 // endfile_spec is empty.
6709 }
6710
6711 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6712 Args.AddAllArgs(CmdArgs, options::OPT_F);
6713
Steven Wu3ffb61b2015-02-06 18:08:29 +00006714 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00006715 for (const Arg *A : Args.filtered(options::OPT_iframework))
6716 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00006717
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006718 if (!Args.hasArg(options::OPT_nostdlib) &&
6719 !Args.hasArg(options::OPT_nodefaultlibs)) {
6720 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6721 if (A->getValue() == StringRef("Accelerate")) {
6722 CmdArgs.push_back("-framework");
6723 CmdArgs.push_back("Accelerate");
6724 }
6725 }
6726 }
6727
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006728 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006729 std::unique_ptr<Command> Cmd =
Justin Bognerd3371d82015-07-17 03:35:54 +00006730 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006731 Cmd->setInputFileList(std::move(InputFileList));
6732 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006733}
6734
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006735void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006736 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006737 const InputInfoList &Inputs,
6738 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006739 const char *LinkingOutput) const {
6740 ArgStringList CmdArgs;
6741
6742 CmdArgs.push_back("-create");
6743 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006744
6745 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006746 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006747
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006748 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006749 assert(II.isFilename() && "Unexpected lipo input.");
6750 CmdArgs.push_back(II.getFilename());
6751 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006752
6753 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006754 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006755}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006756
Daniel Dunbar88299622010-06-04 18:28:36 +00006757void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006758 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00006759 const InputInfoList &Inputs,
6760 const ArgList &Args,
6761 const char *LinkingOutput) const {
6762 ArgStringList CmdArgs;
6763
Daniel Dunbareb86b042011-05-09 17:23:16 +00006764 CmdArgs.push_back("-o");
6765 CmdArgs.push_back(Output.getFilename());
6766
Daniel Dunbar88299622010-06-04 18:28:36 +00006767 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6768 const InputInfo &Input = Inputs[0];
6769 assert(Input.isFilename() && "Unexpected dsymutil input.");
6770 CmdArgs.push_back(Input.getFilename());
6771
Daniel Dunbar88299622010-06-04 18:28:36 +00006772 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006773 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006774 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006775}
6776
Eric Christopher551ef452011-08-23 17:56:55 +00006777void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006778 const InputInfo &Output,
6779 const InputInfoList &Inputs,
6780 const ArgList &Args,
6781 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006782 ArgStringList CmdArgs;
6783 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006784 CmdArgs.push_back("--debug-info");
6785 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006786 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006787
6788 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6789 const InputInfo &Input = Inputs[0];
6790 assert(Input.isFilename() && "Unexpected verify input");
6791
6792 // Grabbing the output of the earlier dsymutil run.
6793 CmdArgs.push_back(Input.getFilename());
6794
6795 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006796 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006797 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher551ef452011-08-23 17:56:55 +00006798}
6799
Douglas Katzman95354292015-06-23 20:42:09 +00006800void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
David Chisnallf571cde2012-02-15 13:39:01 +00006801 const InputInfo &Output,
6802 const InputInfoList &Inputs,
6803 const ArgList &Args,
6804 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006805 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006806 ArgStringList CmdArgs;
6807
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006808 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
David Chisnallf571cde2012-02-15 13:39:01 +00006809
6810 CmdArgs.push_back("-o");
6811 CmdArgs.push_back(Output.getFilename());
6812
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006813 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006814 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006815
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006816 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006817 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00006818}
6819
Douglas Katzman95354292015-06-23 20:42:09 +00006820void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6821 const InputInfo &Output,
6822 const InputInfoList &Inputs,
6823 const ArgList &Args,
6824 const char *LinkingOutput) const {
David Chisnallf571cde2012-02-15 13:39:01 +00006825 // FIXME: Find a real GCC, don't hard-code versions here
6826 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6827 const llvm::Triple &T = getToolChain().getTriple();
6828 std::string LibPath = "/usr/lib/";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006829 const llvm::Triple::ArchType Arch = T.getArch();
David Chisnallf571cde2012-02-15 13:39:01 +00006830 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006831 case llvm::Triple::x86:
6832 GCCLibPath +=
6833 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6834 break;
6835 case llvm::Triple::x86_64:
6836 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6837 GCCLibPath += "/4.5.2/amd64/";
6838 LibPath += "amd64/";
6839 break;
6840 default:
6841 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006842 }
6843
6844 ArgStringList CmdArgs;
6845
David Chisnall272a0712012-02-29 15:06:12 +00006846 // Demangle C++ names in errors
6847 CmdArgs.push_back("-C");
6848
David Chisnallf571cde2012-02-15 13:39:01 +00006849 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6850 (!Args.hasArg(options::OPT_shared))) {
6851 CmdArgs.push_back("-e");
6852 CmdArgs.push_back("_start");
6853 }
6854
6855 if (Args.hasArg(options::OPT_static)) {
6856 CmdArgs.push_back("-Bstatic");
6857 CmdArgs.push_back("-dn");
6858 } else {
6859 CmdArgs.push_back("-Bdynamic");
6860 if (Args.hasArg(options::OPT_shared)) {
6861 CmdArgs.push_back("-shared");
6862 } else {
6863 CmdArgs.push_back("--dynamic-linker");
6864 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6865 }
6866 }
6867
6868 if (Output.isFilename()) {
6869 CmdArgs.push_back("-o");
6870 CmdArgs.push_back(Output.getFilename());
6871 } else {
6872 assert(Output.isNothing() && "Invalid output.");
6873 }
6874
6875 if (!Args.hasArg(options::OPT_nostdlib) &&
6876 !Args.hasArg(options::OPT_nostartfiles)) {
6877 if (!Args.hasArg(options::OPT_shared)) {
6878 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6879 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006880 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006881 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6882 } else {
6883 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006884 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6885 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006886 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006887 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006888 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006889 }
6890
6891 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6892
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006893 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
6894 options::OPT_e, options::OPT_r});
David Chisnallf571cde2012-02-15 13:39:01 +00006895
6896 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6897
6898 if (!Args.hasArg(options::OPT_nostdlib) &&
6899 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006900 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006901 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006902 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006903 if (!Args.hasArg(options::OPT_shared)) {
6904 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006905 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006906 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006907 }
David Chisnallf571cde2012-02-15 13:39:01 +00006908 }
6909
6910 if (!Args.hasArg(options::OPT_nostdlib) &&
6911 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006912 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006913 }
David Chisnall96de9932012-02-16 16:00:47 +00006914 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006915
Alexey Samsonov7811d192014-02-20 13:57:37 +00006916 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006917
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006918 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00006919 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00006920}
6921
Douglas Katzman95354292015-06-23 20:42:09 +00006922void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6923 const InputInfo &Output,
6924 const InputInfoList &Inputs,
6925 const ArgList &Args,
6926 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006927 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006928 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006929 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006930
Rafael Espindolacc126272014-02-28 01:55:21 +00006931 switch (getToolChain().getArch()) {
6932 case llvm::Triple::x86:
6933 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6934 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006935 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006936 break;
6937
6938 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006939 CmdArgs.push_back("-mppc");
6940 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006941 break;
6942
6943 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006944 case llvm::Triple::sparcel:
Rafael Espindolacc126272014-02-28 01:55:21 +00006945 CmdArgs.push_back("-32");
6946 NeedsKPIC = true;
6947 break;
6948
6949 case llvm::Triple::sparcv9:
6950 CmdArgs.push_back("-64");
6951 CmdArgs.push_back("-Av9a");
6952 NeedsKPIC = true;
6953 break;
6954
6955 case llvm::Triple::mips64:
6956 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006957 StringRef CPUName;
6958 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006959 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006960
6961 CmdArgs.push_back("-mabi");
6962 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6963
6964 if (getToolChain().getArch() == llvm::Triple::mips64)
6965 CmdArgs.push_back("-EB");
6966 else
6967 CmdArgs.push_back("-EL");
6968
Rafael Espindolacc126272014-02-28 01:55:21 +00006969 NeedsKPIC = true;
6970 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006971 }
6972
Rafael Espindolacc126272014-02-28 01:55:21 +00006973 default:
6974 break;
6975 }
6976
6977 if (NeedsKPIC)
James Y Knight5bdf7ab2015-08-19 15:12:02 +00006978 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00006979
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006980 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006981
6982 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006983 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006984
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006985 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006986 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006987
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006988 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006989 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006990}
6991
Douglas Katzman95354292015-06-23 20:42:09 +00006992void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6993 const InputInfo &Output,
6994 const InputInfoList &Inputs,
6995 const ArgList &Args,
6996 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006997 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006998 ArgStringList CmdArgs;
6999
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00007000 // Silence warning for "clang -g foo.o -o foo"
7001 Args.ClaimAllArgs(options::OPT_g_Group);
7002 // and "clang -emit-llvm foo.o -o foo"
7003 Args.ClaimAllArgs(options::OPT_emit_llvm);
7004 // and for "clang -w foo.o -o foo". Other warning options are already
7005 // handled somewhere else.
7006 Args.ClaimAllArgs(options::OPT_w);
7007
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007008 if (getToolChain().getArch() == llvm::Triple::mips64)
7009 CmdArgs.push_back("-EB");
7010 else if (getToolChain().getArch() == llvm::Triple::mips64el)
7011 CmdArgs.push_back("-EL");
7012
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007013 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007014 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007015 CmdArgs.push_back("-e");
7016 CmdArgs.push_back("__start");
7017 }
7018
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007019 if (Args.hasArg(options::OPT_static)) {
7020 CmdArgs.push_back("-Bstatic");
7021 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007022 if (Args.hasArg(options::OPT_rdynamic))
7023 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007024 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007025 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007026 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007027 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007028 } else {
7029 CmdArgs.push_back("-dynamic-linker");
7030 CmdArgs.push_back("/usr/libexec/ld.so");
7031 }
7032 }
7033
Rafael Espindola044f7832013-06-05 04:28:55 +00007034 if (Args.hasArg(options::OPT_nopie))
7035 CmdArgs.push_back("-nopie");
7036
Daniel Dunbarb440f562010-08-02 02:38:21 +00007037 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007038 CmdArgs.push_back("-o");
7039 CmdArgs.push_back(Output.getFilename());
7040 } else {
7041 assert(Output.isNothing() && "Invalid output.");
7042 }
7043
7044 if (!Args.hasArg(options::OPT_nostdlib) &&
7045 !Args.hasArg(options::OPT_nostartfiles)) {
7046 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007047 if (Args.hasArg(options::OPT_pg))
7048 CmdArgs.push_back(
7049 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman3715d1f2011-12-15 02:15:56 +00007050 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007051 CmdArgs.push_back(
7052 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7053 CmdArgs.push_back(
7054 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007055 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007056 CmdArgs.push_back(
7057 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007058 }
7059 }
7060
Edward O'Callaghan5c521462009-10-28 15:13:08 +00007061 std::string Triple = getToolChain().getTripleString();
7062 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007063 Triple.replace(0, 6, "amd64");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007064 CmdArgs.push_back(
7065 Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007066
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007067 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7068 options::OPT_e, options::OPT_s, options::OPT_t,
7069 options::OPT_Z_Flag, options::OPT_r});
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007070
Daniel Dunbar54423b22010-09-17 00:24:54 +00007071 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007072
7073 if (!Args.hasArg(options::OPT_nostdlib) &&
7074 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007075 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007076 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007077 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00007078 CmdArgs.push_back("-lm_p");
7079 else
7080 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00007081 }
7082
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007083 // FIXME: For some reason GCC passes -lgcc before adding
7084 // the default system libraries. Just mimic this for now.
7085 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007086
Eric Christopher17674ec2012-09-13 06:32:34 +00007087 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007088 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7089 CmdArgs.push_back("-lpthread_p");
Eric Christopher17674ec2012-09-13 06:32:34 +00007090 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007091 CmdArgs.push_back("-lpthread");
Eric Christopher17674ec2012-09-13 06:32:34 +00007092 }
7093
Chandler Carruth45661652011-12-17 22:32:42 +00007094 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00007095 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007096 CmdArgs.push_back("-lc_p");
Eli Friedman3715d1f2011-12-15 02:15:56 +00007097 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007098 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00007099 }
Eric Christopher17674ec2012-09-13 06:32:34 +00007100
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007101 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007102 }
7103
7104 if (!Args.hasArg(options::OPT_nostdlib) &&
7105 !Args.hasArg(options::OPT_nostartfiles)) {
7106 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007107 CmdArgs.push_back(
7108 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007109 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007110 CmdArgs.push_back(
7111 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007112 }
7113
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007114 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007115 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007116}
Ed Schoutene33194b2009-04-02 19:13:12 +00007117
Douglas Katzman95354292015-06-23 20:42:09 +00007118void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7119 const InputInfo &Output,
7120 const InputInfoList &Inputs,
7121 const ArgList &Args,
7122 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007123 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00007124 ArgStringList CmdArgs;
7125
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007126 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Eli Friedman9fa28852012-08-08 23:57:20 +00007127
7128 CmdArgs.push_back("-o");
7129 CmdArgs.push_back(Output.getFilename());
7130
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007131 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00007132 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00007133
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007134 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007135 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007136}
7137
Douglas Katzman95354292015-06-23 20:42:09 +00007138void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7139 const InputInfo &Output,
7140 const InputInfoList &Inputs,
7141 const ArgList &Args,
7142 const char *LinkingOutput) const {
Eli Friedman9fa28852012-08-08 23:57:20 +00007143 const Driver &D = getToolChain().getDriver();
7144 ArgStringList CmdArgs;
7145
7146 if ((!Args.hasArg(options::OPT_nostdlib)) &&
7147 (!Args.hasArg(options::OPT_shared))) {
7148 CmdArgs.push_back("-e");
7149 CmdArgs.push_back("__start");
7150 }
7151
7152 if (Args.hasArg(options::OPT_static)) {
7153 CmdArgs.push_back("-Bstatic");
7154 } else {
7155 if (Args.hasArg(options::OPT_rdynamic))
7156 CmdArgs.push_back("-export-dynamic");
7157 CmdArgs.push_back("--eh-frame-hdr");
7158 CmdArgs.push_back("-Bdynamic");
7159 if (Args.hasArg(options::OPT_shared)) {
7160 CmdArgs.push_back("-shared");
7161 } else {
7162 CmdArgs.push_back("-dynamic-linker");
7163 CmdArgs.push_back("/usr/libexec/ld.so");
7164 }
7165 }
7166
7167 if (Output.isFilename()) {
7168 CmdArgs.push_back("-o");
7169 CmdArgs.push_back(Output.getFilename());
7170 } else {
7171 assert(Output.isNothing() && "Invalid output.");
7172 }
7173
7174 if (!Args.hasArg(options::OPT_nostdlib) &&
7175 !Args.hasArg(options::OPT_nostartfiles)) {
7176 if (!Args.hasArg(options::OPT_shared)) {
7177 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007178 CmdArgs.push_back(
7179 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007180 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007181 CmdArgs.push_back(
7182 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7183 CmdArgs.push_back(
7184 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007185 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007186 CmdArgs.push_back(
7187 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007188 }
7189 }
7190
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007191 Args.AddAllArgs(CmdArgs,
7192 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Eli Friedman9fa28852012-08-08 23:57:20 +00007193
7194 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7195
7196 if (!Args.hasArg(options::OPT_nostdlib) &&
7197 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007198 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00007199 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7200 if (Args.hasArg(options::OPT_pg))
7201 CmdArgs.push_back("-lm_p");
7202 else
7203 CmdArgs.push_back("-lm");
7204 }
7205
Rafael Espindola1ad26f02012-10-23 17:07:31 +00007206 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007207 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
Rafael Espindola1ad26f02012-10-23 17:07:31 +00007208 CmdArgs.push_back("-lpthread_p");
7209 else
7210 CmdArgs.push_back("-lpthread");
7211 }
7212
Eli Friedman9fa28852012-08-08 23:57:20 +00007213 if (!Args.hasArg(options::OPT_shared)) {
7214 if (Args.hasArg(options::OPT_pg))
7215 CmdArgs.push_back("-lc_p");
7216 else
7217 CmdArgs.push_back("-lc");
7218 }
7219
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00007220 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007221 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00007222 case llvm::Triple::arm:
7223 MyArch = "arm";
7224 break;
7225 case llvm::Triple::x86:
7226 MyArch = "i386";
7227 break;
7228 case llvm::Triple::x86_64:
7229 MyArch = "amd64";
7230 break;
7231 default:
7232 llvm_unreachable("Unsupported architecture");
7233 }
7234 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00007235 }
7236
7237 if (!Args.hasArg(options::OPT_nostdlib) &&
7238 !Args.hasArg(options::OPT_nostartfiles)) {
7239 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007240 CmdArgs.push_back(
7241 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007242 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007243 CmdArgs.push_back(
7244 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007245 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00007246
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007247 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007248 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007249}
7250
Douglas Katzman95354292015-06-23 20:42:09 +00007251void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7252 const InputInfo &Output,
7253 const InputInfoList &Inputs,
7254 const ArgList &Args,
7255 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007256 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007257 ArgStringList CmdArgs;
7258
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007259 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7260 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007261 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007262 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007263 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00007264 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007265 else if (getToolChain().getArch() == llvm::Triple::mips ||
7266 getToolChain().getArch() == llvm::Triple::mipsel ||
7267 getToolChain().getArch() == llvm::Triple::mips64 ||
7268 getToolChain().getArch() == llvm::Triple::mips64el) {
7269 StringRef CPUName;
7270 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007271 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007272
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007273 CmdArgs.push_back("-march");
7274 CmdArgs.push_back(CPUName.data());
7275
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007276 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00007277 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007278
7279 if (getToolChain().getArch() == llvm::Triple::mips ||
7280 getToolChain().getArch() == llvm::Triple::mips64)
7281 CmdArgs.push_back("-EB");
7282 else
7283 CmdArgs.push_back("-EL");
7284
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007285 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007286 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007287 getToolChain().getArch() == llvm::Triple::armeb ||
7288 getToolChain().getArch() == llvm::Triple::thumb ||
7289 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00007290 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007291 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00007292 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
7293
7294 if (FloatABI == "hard") {
7295 CmdArgs.push_back("-mfpu=vfp");
7296 } else {
7297 CmdArgs.push_back("-mfpu=softvfp");
7298 }
7299
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007300 switch (getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00007301 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007302 case llvm::Triple::GNUEABI:
7303 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00007304 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007305 break;
7306
7307 default:
7308 CmdArgs.push_back("-matpcs");
7309 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00007310 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007311 getToolChain().getArch() == llvm::Triple::sparcel ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00007312 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00007313 if (getToolChain().getArch() == llvm::Triple::sparc)
7314 CmdArgs.push_back("-Av8plusa");
7315 else
7316 CmdArgs.push_back("-Av9a");
7317
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007318 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007319 }
Eric Christopher0b26a612010-03-02 02:41:08 +00007320
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007321 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007322
7323 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007324 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007325
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007326 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007327 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007328
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007329 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007330 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007331}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007332
Douglas Katzman95354292015-06-23 20:42:09 +00007333void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7334 const InputInfo &Output,
7335 const InputInfoList &Inputs,
7336 const ArgList &Args,
7337 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007338 const toolchains::FreeBSD &ToolChain =
7339 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00007340 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007341 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007342 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007343 !Args.hasArg(options::OPT_shared) &&
7344 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007345 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00007346
7347 // Silence warning for "clang -g foo.o -o foo"
7348 Args.ClaimAllArgs(options::OPT_g_Group);
7349 // and "clang -emit-llvm foo.o -o foo"
7350 Args.ClaimAllArgs(options::OPT_emit_llvm);
7351 // and for "clang -w foo.o -o foo". Other warning options are already
7352 // handled somewhere else.
7353 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007354
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007355 if (!D.SysRoot.empty())
7356 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7357
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007358 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007359 CmdArgs.push_back("-pie");
7360
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007361 if (Args.hasArg(options::OPT_static)) {
7362 CmdArgs.push_back("-Bstatic");
7363 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007364 if (Args.hasArg(options::OPT_rdynamic))
7365 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007366 CmdArgs.push_back("--eh-frame-hdr");
7367 if (Args.hasArg(options::OPT_shared)) {
7368 CmdArgs.push_back("-Bshareable");
7369 } else {
7370 CmdArgs.push_back("-dynamic-linker");
7371 CmdArgs.push_back("/libexec/ld-elf.so.1");
7372 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007373 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00007374 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7375 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7376 CmdArgs.push_back("--hash-style=both");
7377 }
7378 }
7379 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007380 }
7381
7382 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7383 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007384 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007385 CmdArgs.push_back("-m");
7386 CmdArgs.push_back("elf_i386_fbsd");
7387 }
7388
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007389 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00007390 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00007391 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00007392 }
7393
Daniel Dunbarb440f562010-08-02 02:38:21 +00007394 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007395 CmdArgs.push_back("-o");
7396 CmdArgs.push_back(Output.getFilename());
7397 } else {
7398 assert(Output.isNothing() && "Invalid output.");
7399 }
7400
7401 if (!Args.hasArg(options::OPT_nostdlib) &&
7402 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007403 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007404 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007405 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00007406 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007407 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007408 crt1 = "Scrt1.o";
7409 else
7410 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007411 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007412 if (crt1)
7413 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7414
7415 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7416
Craig Topper92fc2df2014-05-17 16:56:41 +00007417 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00007418 if (Args.hasArg(options::OPT_static))
7419 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007420 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007421 crtbegin = "crtbeginS.o";
7422 else
7423 crtbegin = "crtbegin.o";
7424
7425 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007426 }
7427
7428 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007429 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007430 for (const auto &Path : Paths)
7431 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007432 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7433 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00007434 Args.AddAllArgs(CmdArgs, options::OPT_s);
7435 Args.AddAllArgs(CmdArgs, options::OPT_t);
7436 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7437 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007438
Alexey Samsonov907880e2015-06-19 19:57:46 +00007439 if (D.IsUsingLTO(Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007440 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00007441
Alexey Samsonov52550342014-09-15 19:58:40 +00007442 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00007443 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007444
7445 if (!Args.hasArg(options::OPT_nostdlib) &&
7446 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007447 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00007448 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00007449 if (Args.hasArg(options::OPT_pg))
7450 CmdArgs.push_back("-lm_p");
7451 else
7452 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007453 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007454 if (NeedsSanitizerDeps)
7455 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007456 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7457 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007458 if (Args.hasArg(options::OPT_pg))
7459 CmdArgs.push_back("-lgcc_p");
7460 else
7461 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007462 if (Args.hasArg(options::OPT_static)) {
7463 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007464 } else if (Args.hasArg(options::OPT_pg)) {
7465 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007466 } else {
7467 CmdArgs.push_back("--as-needed");
7468 CmdArgs.push_back("-lgcc_s");
7469 CmdArgs.push_back("--no-as-needed");
7470 }
7471
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007472 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007473 if (Args.hasArg(options::OPT_pg))
7474 CmdArgs.push_back("-lpthread_p");
7475 else
7476 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007477 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007478
Roman Divacky66f22762011-02-10 16:59:40 +00007479 if (Args.hasArg(options::OPT_pg)) {
7480 if (Args.hasArg(options::OPT_shared))
7481 CmdArgs.push_back("-lc");
7482 else
7483 CmdArgs.push_back("-lc_p");
7484 CmdArgs.push_back("-lgcc_p");
7485 } else {
7486 CmdArgs.push_back("-lc");
7487 CmdArgs.push_back("-lgcc");
7488 }
7489
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007490 if (Args.hasArg(options::OPT_static)) {
7491 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007492 } else if (Args.hasArg(options::OPT_pg)) {
7493 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007494 } else {
7495 CmdArgs.push_back("--as-needed");
7496 CmdArgs.push_back("-lgcc_s");
7497 CmdArgs.push_back("--no-as-needed");
7498 }
7499 }
7500
7501 if (!Args.hasArg(options::OPT_nostdlib) &&
7502 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007503 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007504 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007505 else
7506 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007507 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007508 }
7509
Alexey Samsonov7811d192014-02-20 13:57:37 +00007510 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007511
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007512 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007513 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007514}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007515
Douglas Katzman95354292015-06-23 20:42:09 +00007516void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007517 const InputInfo &Output,
7518 const InputInfoList &Inputs,
7519 const ArgList &Args,
7520 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007521 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007522 ArgStringList CmdArgs;
7523
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007524 // GNU as needs different flags for creating the correct output format
7525 // on architectures with different ABIs or optional feature sets.
7526 switch (getToolChain().getArch()) {
7527 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007528 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007529 break;
7530 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007531 case llvm::Triple::armeb:
7532 case llvm::Triple::thumb:
7533 case llvm::Triple::thumbeb: {
Renato Goline17c5802015-07-27 23:44:42 +00007534 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00007535 getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true);
7536 std::string Arch =
7537 arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple());
Renato Goline17c5802015-07-27 23:44:42 +00007538 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007539 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007540 }
7541
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007542 case llvm::Triple::mips:
7543 case llvm::Triple::mipsel:
7544 case llvm::Triple::mips64:
7545 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007546 StringRef CPUName;
7547 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007548 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007549
7550 CmdArgs.push_back("-march");
7551 CmdArgs.push_back(CPUName.data());
7552
7553 CmdArgs.push_back("-mabi");
7554 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7555
7556 if (getToolChain().getArch() == llvm::Triple::mips ||
7557 getToolChain().getArch() == llvm::Triple::mips64)
7558 CmdArgs.push_back("-EB");
7559 else
7560 CmdArgs.push_back("-EL");
7561
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007562 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007563 break;
7564 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007565
7566 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007567 case llvm::Triple::sparcel:
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007568 CmdArgs.push_back("-32");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007569 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007570 break;
7571
7572 case llvm::Triple::sparcv9:
7573 CmdArgs.push_back("-64");
7574 CmdArgs.push_back("-Av9");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007575 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007576 break;
7577
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007578 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007579 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007580 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007581
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007582 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007583
7584 CmdArgs.push_back("-o");
7585 CmdArgs.push_back(Output.getFilename());
7586
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007587 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007588 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007589
David Chisnallddbd68f2011-09-27 22:03:18 +00007590 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Justin Bognerd3371d82015-07-17 03:35:54 +00007591 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007592}
7593
Douglas Katzman95354292015-06-23 20:42:09 +00007594void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7595 const InputInfo &Output,
7596 const InputInfoList &Inputs,
7597 const ArgList &Args,
7598 const char *LinkingOutput) const {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007599 const Driver &D = getToolChain().getDriver();
7600 ArgStringList CmdArgs;
7601
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007602 if (!D.SysRoot.empty())
7603 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7604
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007605 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007606 if (Args.hasArg(options::OPT_static)) {
7607 CmdArgs.push_back("-Bstatic");
7608 } else {
7609 if (Args.hasArg(options::OPT_rdynamic))
7610 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007611 if (Args.hasArg(options::OPT_shared)) {
7612 CmdArgs.push_back("-Bshareable");
7613 } else {
7614 CmdArgs.push_back("-dynamic-linker");
7615 CmdArgs.push_back("/libexec/ld.elf_so");
7616 }
7617 }
7618
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007619 // Many NetBSD architectures support more than one ABI.
7620 // Determine the correct emulation for ld.
7621 switch (getToolChain().getArch()) {
7622 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007623 CmdArgs.push_back("-m");
7624 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007625 break;
7626 case llvm::Triple::arm:
7627 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007628 CmdArgs.push_back("-m");
7629 switch (getToolChain().getTriple().getEnvironment()) {
7630 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007631 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007632 CmdArgs.push_back("armelf_nbsd_eabi");
7633 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007634 case llvm::Triple::EABIHF:
7635 case llvm::Triple::GNUEABIHF:
7636 CmdArgs.push_back("armelf_nbsd_eabihf");
7637 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007638 default:
7639 CmdArgs.push_back("armelf_nbsd");
7640 break;
7641 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007642 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007643 case llvm::Triple::armeb:
7644 case llvm::Triple::thumbeb:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007645 arm::appendEBLinkFlags(
7646 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00007647 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007648 CmdArgs.push_back("-m");
7649 switch (getToolChain().getTriple().getEnvironment()) {
7650 case llvm::Triple::EABI:
7651 case llvm::Triple::GNUEABI:
7652 CmdArgs.push_back("armelfb_nbsd_eabi");
7653 break;
7654 case llvm::Triple::EABIHF:
7655 case llvm::Triple::GNUEABIHF:
7656 CmdArgs.push_back("armelfb_nbsd_eabihf");
7657 break;
7658 default:
7659 CmdArgs.push_back("armelfb_nbsd");
7660 break;
7661 }
7662 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007663 case llvm::Triple::mips64:
7664 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007665 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007666 CmdArgs.push_back("-m");
7667 if (getToolChain().getArch() == llvm::Triple::mips64)
7668 CmdArgs.push_back("elf32btsmip");
7669 else
7670 CmdArgs.push_back("elf32ltsmip");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007671 } else if (mips::hasMipsAbiArg(Args, "64")) {
7672 CmdArgs.push_back("-m");
7673 if (getToolChain().getArch() == llvm::Triple::mips64)
7674 CmdArgs.push_back("elf64btsmip");
7675 else
7676 CmdArgs.push_back("elf64ltsmip");
7677 }
7678 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007679 case llvm::Triple::ppc:
7680 CmdArgs.push_back("-m");
7681 CmdArgs.push_back("elf32ppc_nbsd");
7682 break;
7683
7684 case llvm::Triple::ppc64:
7685 case llvm::Triple::ppc64le:
7686 CmdArgs.push_back("-m");
7687 CmdArgs.push_back("elf64ppc");
7688 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007689
7690 case llvm::Triple::sparc:
7691 CmdArgs.push_back("-m");
7692 CmdArgs.push_back("elf32_sparc");
7693 break;
7694
7695 case llvm::Triple::sparcv9:
7696 CmdArgs.push_back("-m");
7697 CmdArgs.push_back("elf64_sparc");
7698 break;
7699
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007700 default:
7701 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007702 }
7703
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007704 if (Output.isFilename()) {
7705 CmdArgs.push_back("-o");
7706 CmdArgs.push_back(Output.getFilename());
7707 } else {
7708 assert(Output.isNothing() && "Invalid output.");
7709 }
7710
7711 if (!Args.hasArg(options::OPT_nostdlib) &&
7712 !Args.hasArg(options::OPT_nostartfiles)) {
7713 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007714 CmdArgs.push_back(
7715 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7716 CmdArgs.push_back(
7717 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7718 CmdArgs.push_back(
7719 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007720 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007721 CmdArgs.push_back(
7722 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7723 CmdArgs.push_back(
7724 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007725 }
7726 }
7727
7728 Args.AddAllArgs(CmdArgs, options::OPT_L);
7729 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7730 Args.AddAllArgs(CmdArgs, options::OPT_e);
7731 Args.AddAllArgs(CmdArgs, options::OPT_s);
7732 Args.AddAllArgs(CmdArgs, options::OPT_t);
7733 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7734 Args.AddAllArgs(CmdArgs, options::OPT_r);
7735
7736 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7737
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007738 unsigned Major, Minor, Micro;
7739 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7740 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007741 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007742 switch (getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007743 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00007744 case llvm::Triple::arm:
7745 case llvm::Triple::armeb:
7746 case llvm::Triple::thumb:
7747 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007748 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007749 case llvm::Triple::ppc64:
7750 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007751 case llvm::Triple::x86:
7752 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007753 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007754 break;
7755 default:
7756 break;
7757 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007758 }
7759
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007760 if (!Args.hasArg(options::OPT_nostdlib) &&
7761 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007762 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007763 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7764 CmdArgs.push_back("-lm");
7765 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007766 if (Args.hasArg(options::OPT_pthread))
7767 CmdArgs.push_back("-lpthread");
7768 CmdArgs.push_back("-lc");
7769
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007770 if (useLibgcc) {
7771 if (Args.hasArg(options::OPT_static)) {
7772 // libgcc_eh depends on libc, so resolve as much as possible,
7773 // pull in any new requirements from libc and then get the rest
7774 // of libgcc.
7775 CmdArgs.push_back("-lgcc_eh");
7776 CmdArgs.push_back("-lc");
7777 CmdArgs.push_back("-lgcc");
7778 } else {
7779 CmdArgs.push_back("-lgcc");
7780 CmdArgs.push_back("--as-needed");
7781 CmdArgs.push_back("-lgcc_s");
7782 CmdArgs.push_back("--no-as-needed");
7783 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007784 }
7785 }
7786
7787 if (!Args.hasArg(options::OPT_nostdlib) &&
7788 !Args.hasArg(options::OPT_nostartfiles)) {
7789 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007790 CmdArgs.push_back(
7791 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007792 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007793 CmdArgs.push_back(
7794 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
7795 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007796 }
7797
Alexey Samsonov7811d192014-02-20 13:57:37 +00007798 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007799
Logan Chieneb9162f2014-06-26 14:23:45 +00007800 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007801 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007802}
7803
Douglas Katzman95354292015-06-23 20:42:09 +00007804void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7805 const InputInfo &Output,
7806 const InputInfoList &Inputs,
7807 const ArgList &Args,
7808 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007809 claimNoWarnArgs(Args);
7810
James Y Knight2db38f32015-08-15 03:45:25 +00007811 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
7812 llvm::Triple Triple = llvm::Triple(TripleStr);
7813
Rafael Espindola92b00932010-08-10 00:25:48 +00007814 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007815 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007816
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007817 llvm::Reloc::Model RelocationModel;
7818 unsigned PICLevel;
7819 bool IsPIE;
7820 std::tie(RelocationModel, PICLevel, IsPIE) =
7821 ParsePICArgs(getToolChain(), Triple, Args);
7822
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007823 switch (getToolChain().getArch()) {
7824 default:
7825 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00007826 // Add --32/--64 to make sure we get the format we want.
7827 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007828 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00007829 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007830 break;
7831 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00007832 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7833 CmdArgs.push_back("--x32");
7834 else
7835 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007836 break;
7837 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007838 CmdArgs.push_back("-a32");
7839 CmdArgs.push_back("-mppc");
7840 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007841 break;
7842 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007843 CmdArgs.push_back("-a64");
7844 CmdArgs.push_back("-mppc64");
7845 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007846 break;
7847 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00007848 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007849 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007850 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007851 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007852 break;
7853 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007854 case llvm::Triple::sparcel:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007855 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007856 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007857 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007858 break;
7859 case llvm::Triple::sparcv9:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007860 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007861 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007862 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007863 break;
7864 case llvm::Triple::arm:
7865 case llvm::Triple::armeb:
7866 case llvm::Triple::thumb:
7867 case llvm::Triple::thumbeb: {
James Y Knight2db38f32015-08-15 03:45:25 +00007868 const llvm::Triple &Triple2 = getToolChain().getTriple();
7869 switch (Triple2.getSubArch()) {
Scott Douglass3205f522015-03-23 10:54:24 +00007870 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00007871 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00007872 break;
7873 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00007874 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00007875 break;
7876 default:
7877 break;
7878 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007879
James Y Knight2db38f32015-08-15 03:45:25 +00007880 StringRef ARMFloatABI =
7881 tools::arm::getARMFloatABI(getToolChain().getDriver(), Args, Triple);
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007882 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007883
7884 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007885
7886 // FIXME: remove krait check when GNU tools support krait cpu
7887 // for now replace it with -march=armv7-a to avoid a lower
7888 // march from being picked in the absence of a cpu flag.
7889 Arg *A;
7890 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007891 StringRef(A->getValue()).lower() == "krait")
7892 CmdArgs.push_back("-march=armv7-a");
Ana Pazosdd6068d2013-12-06 22:43:17 +00007893 else
7894 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007895 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007896 break;
7897 }
7898 case llvm::Triple::mips:
7899 case llvm::Triple::mipsel:
7900 case llvm::Triple::mips64:
7901 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007902 StringRef CPUName;
7903 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007904 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007905 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007906
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007907 CmdArgs.push_back("-march");
7908 CmdArgs.push_back(CPUName.data());
7909
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007910 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007911 CmdArgs.push_back(ABIName.data());
7912
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007913 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7914 // or -mshared (not implemented) is in effect.
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007915 if (RelocationModel == llvm::Reloc::Static)
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007916 CmdArgs.push_back("-mno-shared");
7917
Daniel Sanders379d44b2014-07-16 11:52:23 +00007918 // LLVM doesn't support -mplt yet and acts as if it is always given.
7919 // However, -mplt has no effect with the N64 ABI.
7920 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007921
7922 if (getToolChain().getArch() == llvm::Triple::mips ||
7923 getToolChain().getArch() == llvm::Triple::mips64)
7924 CmdArgs.push_back("-EB");
7925 else
7926 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007927
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007928 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7929 if (StringRef(A->getValue()) == "2008")
7930 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7931 }
7932
Daniel Sanders379d44b2014-07-16 11:52:23 +00007933 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
Toma Tabacu94ea6862015-06-16 13:54:13 +00007934 StringRef MIPSFloatABI = getMipsFloatABI(getToolChain().getDriver(), Args);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007935 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7936 options::OPT_mfp64)) {
7937 A->claim();
7938 A->render(Args, CmdArgs);
Toma Tabacu94ea6862015-06-16 13:54:13 +00007939 } else if (mips::shouldUseFPXX(Args, getToolChain().getTriple(), CPUName,
7940 ABIName, MIPSFloatABI))
Daniel Sanders379d44b2014-07-16 11:52:23 +00007941 CmdArgs.push_back("-mfpxx");
7942
7943 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7944 // -mno-mips16 is actually -no-mips16.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007945 if (Arg *A =
7946 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00007947 if (A->getOption().matches(options::OPT_mips16)) {
7948 A->claim();
7949 A->render(Args, CmdArgs);
7950 } else {
7951 A->claim();
7952 CmdArgs.push_back("-no-mips16");
7953 }
7954 }
7955
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007956 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7957 options::OPT_mno_micromips);
7958 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7959 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7960
Simon Atanasyanbd986632013-11-26 11:58:04 +00007961 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7962 // Do not use AddLastArg because not all versions of MIPS assembler
7963 // support -mmsa / -mno-msa options.
7964 if (A->getOption().matches(options::OPT_mmsa))
7965 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7966 }
7967
Daniel Sanders379d44b2014-07-16 11:52:23 +00007968 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7969 options::OPT_msoft_float);
7970
Toma Tabacub36d6102015-06-11 12:13:18 +00007971 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
7972 options::OPT_msingle_float);
7973
Daniel Sanders379d44b2014-07-16 11:52:23 +00007974 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7975 options::OPT_mno_odd_spreg);
7976
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007977 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007978 break;
7979 }
7980 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007981 // Always pass an -march option, since our default of z10 is later
7982 // than the GNU assembler's default.
7983 StringRef CPUName = getSystemZTargetCPU(Args);
7984 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007985 break;
7986 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007987 }
7988
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007989 if (NeedsKPIC) {
7990 if (RelocationModel != llvm::Reloc::Static)
7991 CmdArgs.push_back("-KPIC");
7992 }
Rafael Espindola92b00932010-08-10 00:25:48 +00007993
Renato Golina74bbc72015-07-22 15:32:36 +00007994 Args.AddAllArgs(CmdArgs, options::OPT_I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007995 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Rafael Espindola92b00932010-08-10 00:25:48 +00007996
7997 CmdArgs.push_back("-o");
7998 CmdArgs.push_back(Output.getFilename());
7999
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008000 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00008001 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00008002
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008003 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008004 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00008005
8006 // Handle the debug info splitting at object creation time if we're
8007 // creating an object.
8008 // TODO: Currently only works on linux with newer objcopy.
8009 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00008010 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00008011 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00008012 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00008013}
8014
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00008015static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008016 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00008017 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Reid Kleckner0213a472015-07-22 16:01:38 +00008018 bool isCygMing = Triple.isOSCygMing();
Chandler Carruth58d6eb62013-03-04 02:07:55 +00008019 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
8020 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00008021 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008022 CmdArgs.push_back("-lgcc");
8023
Logan Chien3d3373c2012-11-19 12:04:11 +00008024 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008025 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008026 CmdArgs.push_back("-lgcc");
8027 } else {
Reid Kleckner0213a472015-07-22 16:01:38 +00008028 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008029 CmdArgs.push_back("--as-needed");
8030 CmdArgs.push_back("-lgcc_s");
Reid Kleckner0213a472015-07-22 16:01:38 +00008031 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008032 CmdArgs.push_back("--no-as-needed");
8033 }
8034
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008035 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00008036 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00008037 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008038 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00008039
8040 // According to Android ABI, we have to link with libdl if we are
8041 // linking with non-static libgcc.
8042 //
8043 // NOTE: This fixes a link error on Android MIPS as well. The non-static
8044 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
8045 if (isAndroid && !StaticLibgcc)
8046 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00008047}
8048
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008049static std::string getLinuxDynamicLinker(const ArgList &Args,
8050 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008051 const llvm::Triple::ArchType Arch = ToolChain.getArch();
8052
Alexey Bataevcf7ae302014-01-23 09:08:32 +00008053 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
8054 if (ToolChain.getTriple().isArch64Bit())
8055 return "/system/bin/linker64";
8056 else
8057 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008058 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
8059 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008060 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008061 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008062 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008063 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00008064 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008065 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Renato Golin24ba3e92015-07-27 09:56:37 +00008066 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
8067 tools::arm::getARMFloatABI(ToolChain.getDriver(), Args, ToolChain.getTriple()) == "hard")
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008068 return "/lib/ld-linux-armhf.so.3";
8069 else
8070 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008071 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
8072 // TODO: check which dynamic linker name.
Renato Golin24ba3e92015-07-27 09:56:37 +00008073 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
8074 tools::arm::getARMFloatABI(ToolChain.getDriver(), Args, ToolChain.getTriple()) == "hard")
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008075 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00008076 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008077 return "/lib/ld-linux.so.3";
8078 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
8079 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008080 StringRef CPUName;
8081 StringRef ABIName;
8082 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
8083 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
8084
8085 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
8086 .Case("o32", "/lib")
8087 .Case("n32", "/lib32")
8088 .Case("n64", "/lib64")
8089 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00008090 StringRef LibName;
8091 if (mips::isUCLibc(Args))
8092 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
8093 else
8094 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008095
8096 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008097 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008098 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008099 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00008100 if (ppc::hasPPCAbiArg(Args, "elfv2"))
8101 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008102 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008103 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00008104 if (ppc::hasPPCAbiArg(Args, "elfv1"))
8105 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00008106 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008107 } else if (Arch == llvm::Triple::systemz)
Ulrich Weigand8afad612014-07-28 13:17:52 +00008108 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008109 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00008110 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008111 else if (Arch == llvm::Triple::x86_64 &&
Zinovy Nis1db95732014-07-10 15:27:19 +00008112 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
8113 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008114 else
8115 return "/lib64/ld-linux-x86-64.so.2";
8116}
8117
Renato Golinc4b49242014-02-13 10:01:16 +00008118static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00008119 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00008120 // Make use of compiler-rt if --rtlib option is used
8121 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
8122
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00008123 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00008124 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008125 switch (TC.getTriple().getOS()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008126 default:
8127 llvm_unreachable("unsupported OS");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008128 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008129 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00008130 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008131 break;
8132 }
Renato Golinc4b49242014-02-13 10:01:16 +00008133 break;
8134 case ToolChain::RLT_Libgcc:
8135 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
8136 break;
Renato Golinc4b49242014-02-13 10:01:16 +00008137 }
8138}
8139
Rafael Espindola1e085772014-08-15 17:14:35 +00008140static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
8141 switch (T.getArch()) {
8142 case llvm::Triple::x86:
8143 return "elf_i386";
8144 case llvm::Triple::aarch64:
8145 return "aarch64linux";
8146 case llvm::Triple::aarch64_be:
8147 return "aarch64_be_linux";
8148 case llvm::Triple::arm:
8149 case llvm::Triple::thumb:
8150 return "armelf_linux_eabi";
8151 case llvm::Triple::armeb:
8152 case llvm::Triple::thumbeb:
8153 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
8154 case llvm::Triple::ppc:
8155 return "elf32ppclinux";
8156 case llvm::Triple::ppc64:
8157 return "elf64ppc";
8158 case llvm::Triple::ppc64le:
8159 return "elf64lppc";
8160 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00008161 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00008162 return "elf32_sparc";
8163 case llvm::Triple::sparcv9:
8164 return "elf64_sparc";
8165 case llvm::Triple::mips:
8166 return "elf32btsmip";
8167 case llvm::Triple::mipsel:
8168 return "elf32ltsmip";
8169 case llvm::Triple::mips64:
8170 if (mips::hasMipsAbiArg(Args, "n32"))
8171 return "elf32btsmipn32";
8172 return "elf64btsmip";
8173 case llvm::Triple::mips64el:
8174 if (mips::hasMipsAbiArg(Args, "n32"))
8175 return "elf32ltsmipn32";
8176 return "elf64ltsmip";
8177 case llvm::Triple::systemz:
8178 return "elf64_s390";
8179 case llvm::Triple::x86_64:
8180 if (T.getEnvironment() == llvm::Triple::GNUX32)
8181 return "elf32_x86_64";
8182 return "elf_x86_64";
8183 default:
8184 llvm_unreachable("Unexpected arch");
8185 }
8186}
8187
Douglas Katzman95354292015-06-23 20:42:09 +00008188void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8189 const InputInfo &Output,
8190 const InputInfoList &Inputs,
8191 const ArgList &Args,
8192 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008193 const toolchains::Linux &ToolChain =
8194 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008195 const Driver &D = ToolChain.getDriver();
James Y Knight2db38f32015-08-15 03:45:25 +00008196
8197 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8198 llvm::Triple Triple = llvm::Triple(TripleStr);
8199
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008200 const llvm::Triple::ArchType Arch = ToolChain.getArch();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008201 const bool isAndroid =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008202 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008203 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008204 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
8205 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008206
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008207 ArgStringList CmdArgs;
8208
Rafael Espindolad1002f62010-11-15 18:28:16 +00008209 // Silence warning for "clang -g foo.o -o foo"
8210 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00008211 // and "clang -emit-llvm foo.o -o foo"
8212 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00008213 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00008214 // handled somewhere else.
8215 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00008216
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008217 if (!D.SysRoot.empty())
8218 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008219
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008220 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00008221 CmdArgs.push_back("-pie");
8222
Rafael Espindola1c76c592010-11-07 22:57:16 +00008223 if (Args.hasArg(options::OPT_rdynamic))
8224 CmdArgs.push_back("-export-dynamic");
8225
Rafael Espindola34d77dc2010-11-11 19:34:42 +00008226 if (Args.hasArg(options::OPT_s))
8227 CmdArgs.push_back("-s");
8228
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008229 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
James Y Knight2db38f32015-08-15 03:45:25 +00008230 arm::appendEBLinkFlags(Args, CmdArgs, Triple);
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00008231
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008232 for (const auto &Opt : ToolChain.ExtraOpts)
8233 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008234
8235 if (!Args.hasArg(options::OPT_static)) {
8236 CmdArgs.push_back("--eh-frame-hdr");
8237 }
8238
8239 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00008240 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008241
8242 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008243 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8244 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008245 CmdArgs.push_back("-Bstatic");
8246 else
8247 CmdArgs.push_back("-static");
8248 } else if (Args.hasArg(options::OPT_shared)) {
8249 CmdArgs.push_back("-shared");
8250 }
8251
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008252 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8253 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008254 (!Args.hasArg(options::OPT_static) &&
8255 !Args.hasArg(options::OPT_shared))) {
8256 CmdArgs.push_back("-dynamic-linker");
8257 CmdArgs.push_back(Args.MakeArgString(
8258 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
8259 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008260
8261 CmdArgs.push_back("-o");
8262 CmdArgs.push_back(Output.getFilename());
8263
Rafael Espindola81937ec2010-12-01 01:52:43 +00008264 if (!Args.hasArg(options::OPT_nostdlib) &&
8265 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008266 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008267 const char *crt1 = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008268 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopherac021742013-06-07 23:25:01 +00008269 if (Args.hasArg(options::OPT_pg))
8270 crt1 = "gcrt1.o";
8271 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008272 crt1 = "Scrt1.o";
8273 else
8274 crt1 = "crt1.o";
8275 }
8276 if (crt1)
8277 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008278
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008279 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8280 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008281
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008282 const char *crtbegin;
8283 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008284 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008285 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008286 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008287 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008288 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008289 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008290 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008291 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00008292
8293 // Add crtfastmath.o if available and fast math is enabled.
8294 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008295 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008296
8297 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00008298 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008299
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00008300 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008301
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008302 for (const auto &Path : Paths)
8303 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008304
Alexey Samsonov907880e2015-06-19 19:57:46 +00008305 if (D.IsUsingLTO(Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00008306 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00008307
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00008308 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8309 CmdArgs.push_back("--no-demangle");
8310
Alexey Samsonov52550342014-09-15 19:58:40 +00008311 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008312 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008313 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00008314 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008315
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008316 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
Chandler Carruth94a32012012-05-14 18:31:18 +00008317 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00008318 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008319 !Args.hasArg(options::OPT_static);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008320 if (OnlyLibstdcxxStatic)
8321 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008322 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008323 if (OnlyLibstdcxxStatic)
8324 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008325 CmdArgs.push_back("-lm");
8326 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00008327 // Silence warnings when linking C code with a C++ '-stdlib' argument.
8328 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008329
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008330 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00008331 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8332 if (Args.hasArg(options::OPT_static))
8333 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00008334
Alexey Samsonov52550342014-09-15 19:58:40 +00008335 if (NeedsSanitizerDeps)
8336 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
8337
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008338 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8339 Args.hasArg(options::OPT_pthreads);
8340
8341 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8342 options::OPT_fno_openmp, false)) {
8343 // OpenMP runtimes implies pthreads when using the GNU toolchain.
8344 // FIXME: Does this really make sense for all GNU toolchains?
8345 WantPthread = true;
8346
8347 // Also link the particular OpenMP runtimes.
8348 switch (getOpenMPRuntime(ToolChain, Args)) {
8349 case OMPRT_OMP:
8350 CmdArgs.push_back("-lomp");
8351 break;
8352 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00008353 CmdArgs.push_back("-lgomp");
8354
8355 // FIXME: Exclude this for platforms with libgomp that don't require
8356 // librt. Most modern Linux platforms require it, but some may not.
8357 CmdArgs.push_back("-lrt");
8358 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008359 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00008360 CmdArgs.push_back("-liomp5");
8361 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008362 case OMPRT_Unknown:
8363 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00008364 break;
8365 }
Chandler Carruth01538002013-01-17 13:19:29 +00008366 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008367
Renato Golinc4b49242014-02-13 10:01:16 +00008368 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008369
Richard Smith31d1de22015-05-20 22:48:44 +00008370 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00008371 CmdArgs.push_back("-lpthread");
8372
8373 CmdArgs.push_back("-lc");
8374
8375 if (Args.hasArg(options::OPT_static))
8376 CmdArgs.push_back("--end-group");
8377 else
Renato Golinc4b49242014-02-13 10:01:16 +00008378 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00008379 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00008380
Rafael Espindola81937ec2010-12-01 01:52:43 +00008381 if (!Args.hasArg(options::OPT_nostartfiles)) {
8382 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008383 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008384 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008385 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008386 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00008387 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008388 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008389
Rafael Espindola81937ec2010-12-01 01:52:43 +00008390 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008391 if (!isAndroid)
8392 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00008393 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008394 }
8395
Justin Bognerd3371d82015-07-17 03:35:54 +00008396 C.addCommand(llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(),
8397 CmdArgs, Inputs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00008398}
8399
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008400// NaCl ARM assembly (inline or standalone) can be written with a set of macros
8401// for the various SFI requirements like register masking. The assembly tool
8402// inserts the file containing the macros as an input into all the assembly
8403// jobs.
Douglas Katzman95354292015-06-23 20:42:09 +00008404void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
8405 const InputInfo &Output,
8406 const InputInfoList &Inputs,
8407 const ArgList &Args,
8408 const char *LinkingOutput) const {
Douglas Katzman54366072015-07-27 16:53:08 +00008409 const toolchains::NaClToolChain &ToolChain =
8410 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008411 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8412 "nacl-arm-macros.s");
8413 InputInfoList NewInputs;
8414 NewInputs.push_back(NaClMacros);
8415 NewInputs.append(Inputs.begin(), Inputs.end());
Douglas Katzman95354292015-06-23 20:42:09 +00008416 gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
8417 LinkingOutput);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008418}
8419
Douglas Katzman750cfc52015-06-29 18:42:16 +00008420// This is quite similar to gnutools::Linker::ConstructJob with changes that
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008421// we use static by default, do not yet support sanitizers or LTO, and a few
8422// others. Eventually we can support more of that and hopefully migrate back
Douglas Katzman750cfc52015-06-29 18:42:16 +00008423// to gnutools::Linker.
Douglas Katzman95354292015-06-23 20:42:09 +00008424void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8425 const InputInfo &Output,
8426 const InputInfoList &Inputs,
8427 const ArgList &Args,
8428 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008429
Douglas Katzman54366072015-07-27 16:53:08 +00008430 const toolchains::NaClToolChain &ToolChain =
8431 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008432 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008433 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008434 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008435 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008436
8437 ArgStringList CmdArgs;
8438
8439 // Silence warning for "clang -g foo.o -o foo"
8440 Args.ClaimAllArgs(options::OPT_g_Group);
8441 // and "clang -emit-llvm foo.o -o foo"
8442 Args.ClaimAllArgs(options::OPT_emit_llvm);
8443 // and for "clang -w foo.o -o foo". Other warning options are already
8444 // handled somewhere else.
8445 Args.ClaimAllArgs(options::OPT_w);
8446
8447 if (!D.SysRoot.empty())
8448 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8449
8450 if (Args.hasArg(options::OPT_rdynamic))
8451 CmdArgs.push_back("-export-dynamic");
8452
8453 if (Args.hasArg(options::OPT_s))
8454 CmdArgs.push_back("-s");
8455
Douglas Katzman54366072015-07-27 16:53:08 +00008456 // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
8457 // from there is --build-id, which we do want.
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008458 CmdArgs.push_back("--build-id");
8459
8460 if (!IsStatic)
8461 CmdArgs.push_back("--eh-frame-hdr");
8462
8463 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008464 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008465 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008466 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008467 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008468 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008469 CmdArgs.push_back("elf_x86_64_nacl");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008470 else if (Arch == llvm::Triple::mipsel)
8471 CmdArgs.push_back("mipselelf_nacl");
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008472 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008473 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8474 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008475
8476 if (IsStatic)
8477 CmdArgs.push_back("-static");
8478 else if (Args.hasArg(options::OPT_shared))
8479 CmdArgs.push_back("-shared");
8480
8481 CmdArgs.push_back("-o");
8482 CmdArgs.push_back(Output.getFilename());
8483 if (!Args.hasArg(options::OPT_nostdlib) &&
8484 !Args.hasArg(options::OPT_nostartfiles)) {
8485 if (!Args.hasArg(options::OPT_shared))
8486 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8487 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8488
8489 const char *crtbegin;
8490 if (IsStatic)
8491 crtbegin = "crtbeginT.o";
8492 else if (Args.hasArg(options::OPT_shared))
8493 crtbegin = "crtbeginS.o";
8494 else
8495 crtbegin = "crtbegin.o";
8496 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8497 }
8498
8499 Args.AddAllArgs(CmdArgs, options::OPT_L);
8500 Args.AddAllArgs(CmdArgs, options::OPT_u);
8501
8502 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8503
8504 for (const auto &Path : Paths)
8505 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8506
8507 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8508 CmdArgs.push_back("--no-demangle");
8509
8510 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8511
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008512 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008513 !Args.hasArg(options::OPT_nodefaultlibs)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008514 bool OnlyLibstdcxxStatic =
8515 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008516 if (OnlyLibstdcxxStatic)
8517 CmdArgs.push_back("-Bstatic");
8518 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8519 if (OnlyLibstdcxxStatic)
8520 CmdArgs.push_back("-Bdynamic");
8521 CmdArgs.push_back("-lm");
8522 }
8523
8524 if (!Args.hasArg(options::OPT_nostdlib)) {
8525 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8526 // Always use groups, since it has no effect on dynamic libraries.
8527 CmdArgs.push_back("--start-group");
8528 CmdArgs.push_back("-lc");
8529 // NaCl's libc++ currently requires libpthread, so just always include it
8530 // in the group for C++.
8531 if (Args.hasArg(options::OPT_pthread) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008532 Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008533 // Gold, used by Mips, handles nested groups differently than ld, and
8534 // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
8535 // which is not a desired behaviour here.
8536 // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
8537 if (getToolChain().getArch() == llvm::Triple::mipsel)
8538 CmdArgs.push_back("-lnacl");
8539
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008540 CmdArgs.push_back("-lpthread");
8541 }
8542
8543 CmdArgs.push_back("-lgcc");
8544 CmdArgs.push_back("--as-needed");
8545 if (IsStatic)
8546 CmdArgs.push_back("-lgcc_eh");
8547 else
8548 CmdArgs.push_back("-lgcc_s");
8549 CmdArgs.push_back("--no-as-needed");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008550
8551 // Mips needs to create and use pnacl_legacy library that contains
8552 // definitions from bitcode/pnaclmm.c and definitions for
8553 // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
8554 if (getToolChain().getArch() == llvm::Triple::mipsel)
8555 CmdArgs.push_back("-lpnacl_legacy");
8556
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008557 CmdArgs.push_back("--end-group");
8558 }
8559
8560 if (!Args.hasArg(options::OPT_nostartfiles)) {
8561 const char *crtend;
8562 if (Args.hasArg(options::OPT_shared))
8563 crtend = "crtendS.o";
8564 else
8565 crtend = "crtend.o";
8566
8567 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8568 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8569 }
8570 }
8571
Justin Bognerd3371d82015-07-17 03:35:54 +00008572 C.addCommand(llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(),
8573 CmdArgs, Inputs));
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008574}
8575
Douglas Katzman95354292015-06-23 20:42:09 +00008576void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8577 const InputInfo &Output,
8578 const InputInfoList &Inputs,
8579 const ArgList &Args,
8580 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008581 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008582 ArgStringList CmdArgs;
8583
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008584 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008585
8586 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008587 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008588
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008589 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008590 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008591
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008592 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008593 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008594}
8595
Douglas Katzman95354292015-06-23 20:42:09 +00008596void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8597 const InputInfo &Output,
8598 const InputInfoList &Inputs,
8599 const ArgList &Args,
8600 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008601 const Driver &D = getToolChain().getDriver();
8602 ArgStringList CmdArgs;
8603
Daniel Dunbarb440f562010-08-02 02:38:21 +00008604 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008605 CmdArgs.push_back("-o");
8606 CmdArgs.push_back(Output.getFilename());
8607 } else {
8608 assert(Output.isNothing() && "Invalid output.");
8609 }
8610
8611 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008612 !Args.hasArg(options::OPT_nostartfiles)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008613 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8614 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8615 CmdArgs.push_back(
8616 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8617 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Eli Friedman83de5132011-12-08 23:54:21 +00008618 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008619
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008620 Args.AddAllArgs(CmdArgs,
8621 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Chris Lattner3e2ee142010-07-07 16:01:42 +00008622
Daniel Dunbar54423b22010-09-17 00:24:54 +00008623 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008624
Alexey Samsonov7811d192014-02-20 13:57:37 +00008625 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008626
Chris Lattner3e2ee142010-07-07 16:01:42 +00008627 if (!Args.hasArg(options::OPT_nostdlib) &&
8628 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008629 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008630 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008631 CmdArgs.push_back("-lm");
8632 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008633 }
8634
8635 if (!Args.hasArg(options::OPT_nostdlib) &&
8636 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008637 if (Args.hasArg(options::OPT_pthread))
8638 CmdArgs.push_back("-lpthread");
8639 CmdArgs.push_back("-lc");
8640 CmdArgs.push_back("-lCompilerRT-Generic");
8641 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8642 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008643 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008644 }
8645
Logan Chieneb9162f2014-06-26 14:23:45 +00008646 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008647 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008648}
8649
Daniel Dunbarcc912342009-05-02 18:28:39 +00008650/// DragonFly Tools
8651
8652// For now, DragonFly Assemble does just about the same as for
8653// FreeBSD, but this may change soon.
Douglas Katzman95354292015-06-23 20:42:09 +00008654void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8655 const InputInfo &Output,
8656 const InputInfoList &Inputs,
8657 const ArgList &Args,
8658 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008659 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008660 ArgStringList CmdArgs;
8661
8662 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8663 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008664 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008665 CmdArgs.push_back("--32");
8666
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008667 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008668
8669 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008670 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008671
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008672 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008673 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008674
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008675 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008676 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008677}
8678
Douglas Katzman95354292015-06-23 20:42:09 +00008679void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8680 const InputInfo &Output,
8681 const InputInfoList &Inputs,
8682 const ArgList &Args,
8683 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008684 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008685 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008686 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008687
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008688 if (!D.SysRoot.empty())
8689 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8690
John McCall65b8da02013-04-11 22:55:55 +00008691 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008692 if (Args.hasArg(options::OPT_static)) {
8693 CmdArgs.push_back("-Bstatic");
8694 } else {
John McCall65b8da02013-04-11 22:55:55 +00008695 if (Args.hasArg(options::OPT_rdynamic))
8696 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008697 if (Args.hasArg(options::OPT_shared))
8698 CmdArgs.push_back("-Bshareable");
8699 else {
8700 CmdArgs.push_back("-dynamic-linker");
8701 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8702 }
John McCall65b8da02013-04-11 22:55:55 +00008703 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008704 }
8705
8706 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8707 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008708 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008709 CmdArgs.push_back("-m");
8710 CmdArgs.push_back("elf_i386");
8711 }
8712
Daniel Dunbarb440f562010-08-02 02:38:21 +00008713 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008714 CmdArgs.push_back("-o");
8715 CmdArgs.push_back(Output.getFilename());
8716 } else {
8717 assert(Output.isNothing() && "Invalid output.");
8718 }
8719
8720 if (!Args.hasArg(options::OPT_nostdlib) &&
8721 !Args.hasArg(options::OPT_nostartfiles)) {
8722 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008723 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008724 CmdArgs.push_back(
8725 Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00008726 else {
8727 if (Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008728 CmdArgs.push_back(
8729 Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00008730 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008731 CmdArgs.push_back(
8732 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00008733 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008734 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008735 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
John McCall65b8da02013-04-11 22:55:55 +00008736 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008737 CmdArgs.push_back(
8738 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008739 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008740 CmdArgs.push_back(
8741 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008742 }
8743
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008744 Args.AddAllArgs(CmdArgs,
8745 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Daniel Dunbarcc912342009-05-02 18:28:39 +00008746
Daniel Dunbar54423b22010-09-17 00:24:54 +00008747 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008748
8749 if (!Args.hasArg(options::OPT_nostdlib) &&
8750 !Args.hasArg(options::OPT_nodefaultlibs)) {
8751 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8752 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00008753 if (UseGCC47)
8754 CmdArgs.push_back("-L/usr/lib/gcc47");
8755 else
8756 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008757
8758 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00008759 if (UseGCC47) {
8760 CmdArgs.push_back("-rpath");
8761 CmdArgs.push_back("/usr/lib/gcc47");
8762 } else {
8763 CmdArgs.push_back("-rpath");
8764 CmdArgs.push_back("/usr/lib/gcc44");
8765 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008766 }
8767
Hans Wennborg70850d82013-07-18 20:29:38 +00008768 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008769 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00008770 CmdArgs.push_back("-lm");
8771 }
8772
Daniel Dunbarcc912342009-05-02 18:28:39 +00008773 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00008774 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008775
8776 if (!Args.hasArg(options::OPT_nolibc)) {
8777 CmdArgs.push_back("-lc");
8778 }
8779
John McCall65b8da02013-04-11 22:55:55 +00008780 if (UseGCC47) {
8781 if (Args.hasArg(options::OPT_static) ||
8782 Args.hasArg(options::OPT_static_libgcc)) {
8783 CmdArgs.push_back("-lgcc");
8784 CmdArgs.push_back("-lgcc_eh");
8785 } else {
8786 if (Args.hasArg(options::OPT_shared_libgcc)) {
8787 CmdArgs.push_back("-lgcc_pic");
8788 if (!Args.hasArg(options::OPT_shared))
8789 CmdArgs.push_back("-lgcc");
8790 } else {
8791 CmdArgs.push_back("-lgcc");
8792 CmdArgs.push_back("--as-needed");
8793 CmdArgs.push_back("-lgcc_pic");
8794 CmdArgs.push_back("--no-as-needed");
8795 }
8796 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008797 } else {
John McCall65b8da02013-04-11 22:55:55 +00008798 if (Args.hasArg(options::OPT_shared)) {
8799 CmdArgs.push_back("-lgcc_pic");
8800 } else {
8801 CmdArgs.push_back("-lgcc");
8802 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008803 }
8804 }
8805
8806 if (!Args.hasArg(options::OPT_nostdlib) &&
8807 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00008808 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008809 CmdArgs.push_back(
8810 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008811 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008812 CmdArgs.push_back(
8813 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
8814 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008815 }
8816
Alexey Samsonov7811d192014-02-20 13:57:37 +00008817 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008818
Logan Chieneb9162f2014-06-26 14:23:45 +00008819 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008820 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008821}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008822
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008823// Try to find Exe from a Visual Studio distribution. This first tries to find
8824// an installed copy of Visual Studio and, failing that, looks in the PATH,
8825// making sure that whatever executable that's found is not a same-named exe
8826// from clang itself to prevent clang from falling back to itself.
8827static std::string FindVisualStudioExecutable(const ToolChain &TC,
8828 const char *Exe,
8829 const char *ClangProgramPath) {
8830 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8831 std::string visualStudioBinDir;
8832 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8833 visualStudioBinDir)) {
8834 SmallString<128> FilePath(visualStudioBinDir);
8835 llvm::sys::path::append(FilePath, Exe);
8836 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8837 return FilePath.str();
8838 }
8839
8840 return Exe;
8841}
8842
Douglas Katzman95354292015-06-23 20:42:09 +00008843void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8844 const InputInfo &Output,
8845 const InputInfoList &Inputs,
8846 const ArgList &Args,
8847 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008848 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008849 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008850
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008851 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8852 if (Output.isFilename())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008853 CmdArgs.push_back(
8854 Args.MakeArgString(std::string("-out:") + Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008855
8856 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008857 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008858 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008859
Zachary Turner10d75b22014-10-22 20:40:43 +00008860 if (!llvm::sys::Process::GetEnv("LIB")) {
8861 // If the VC environment hasn't been configured (perhaps because the user
8862 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00008863 // the environment variable is set however, assume the user knows what
8864 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00008865 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008866 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00008867 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8868 SmallString<128> LibDir(VisualStudioDir);
8869 llvm::sys::path::append(LibDir, "VC", "lib");
8870 switch (MSVC.getArch()) {
8871 case llvm::Triple::x86:
8872 // x86 just puts the libraries directly in lib
8873 break;
8874 case llvm::Triple::x86_64:
8875 llvm::sys::path::append(LibDir, "amd64");
8876 break;
8877 case llvm::Triple::arm:
8878 llvm::sys::path::append(LibDir, "arm");
8879 break;
8880 default:
8881 break;
8882 }
8883 CmdArgs.push_back(
8884 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8885 }
8886
8887 std::string WindowsSdkLibPath;
8888 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8889 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8890 WindowsSdkLibPath.c_str()));
8891 }
8892
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008893 CmdArgs.push_back("-nologo");
8894
Reid Kleckner124955a2015-08-05 18:51:13 +00008895 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008896 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008897
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008898 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
Hans Wennborge4c47f22015-03-04 23:16:21 +00008899 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00008900 if (DLL) {
8901 CmdArgs.push_back(Args.MakeArgString("-dll"));
8902
8903 SmallString<128> ImplibName(Output.getFilename());
8904 llvm::sys::path::replace_extension(ImplibName, "lib");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008905 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00008906 }
8907
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008908 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00008909 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00008910 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008911 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008912 static const char *CompilerRTComponents[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008913 "asan_dynamic", "asan_dynamic_runtime_thunk",
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008914 };
8915 for (const auto &Component : CompilerRTComponents)
8916 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00008917 // Make sure the dynamic runtime thunk is not optimized out at link time
8918 // to ensure proper SEH handling.
8919 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008920 } else if (DLL) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008921 CmdArgs.push_back(
8922 Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008923 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008924 static const char *CompilerRTComponents[] = {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008925 "asan", "asan_cxx",
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008926 };
8927 for (const auto &Component : CompilerRTComponents)
8928 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008929 }
Hans Wennborg65f17522013-08-27 18:10:21 +00008930 }
8931
Hans Wennborg2e274592013-08-13 23:38:57 +00008932 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00008933
Alexey Bataevc7e84352015-08-19 04:49:01 +00008934 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8935 options::OPT_fno_openmp, false)) {
8936 CmdArgs.push_back("-nodefaultlib:vcomp.lib");
8937 CmdArgs.push_back("-nodefaultlib:vcompd.lib");
8938 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8939 TC.getDriver().Dir + "/../lib"));
8940 switch (getOpenMPRuntime(getToolChain(), Args)) {
8941 case OMPRT_OMP:
8942 CmdArgs.push_back("-defaultlib:libomp.lib");
8943 break;
8944 case OMPRT_IOMP5:
8945 CmdArgs.push_back("-defaultlib:libiomp5md.lib");
8946 break;
8947 case OMPRT_GOMP:
8948 break;
8949 case OMPRT_Unknown:
8950 // Already diagnosed.
8951 break;
8952 }
8953 }
8954
Reid Kleckner337188f2014-09-16 19:22:00 +00008955 // Add filenames, libraries, and other linker inputs.
8956 for (const auto &Input : Inputs) {
8957 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008958 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00008959 continue;
8960 }
8961
8962 const Arg &A = Input.getInputArg();
8963
8964 // Render -l options differently for the MSVC linker.
8965 if (A.getOption().matches(options::OPT_l)) {
8966 StringRef Lib = A.getValue();
8967 const char *LinkLibArg;
8968 if (Lib.endswith(".lib"))
8969 LinkLibArg = Args.MakeArgString(Lib);
8970 else
8971 LinkLibArg = Args.MakeArgString(Lib + ".lib");
8972 CmdArgs.push_back(LinkLibArg);
8973 continue;
8974 }
8975
8976 // Otherwise, this is some other kind of linker input option like -Wl, -z,
8977 // or -L. Render it, even if MSVC doesn't understand it.
8978 A.renderAsInput(Args, CmdArgs);
8979 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008980
Zachary Turner719f58c2014-12-01 23:06:47 +00008981 // We need to special case some linker paths. In the case of lld, we need to
8982 // translate 'lld' into 'lld-link', and in the case of the regular msvc
8983 // linker, we need to use a special search algorithm.
8984 llvm::SmallString<128> linkPath;
8985 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8986 if (Linker.equals_lower("lld"))
8987 Linker = "lld-link";
8988
8989 if (Linker.equals_lower("link")) {
8990 // If we're using the MSVC linker, it's not sufficient to just use link
8991 // from the program PATH, because other environments like GnuWin32 install
8992 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008993 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008994 C.getDriver().getClangProgramPath());
8995 } else {
8996 linkPath = Linker;
8997 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008998 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008999 }
9000
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009001 const char *Exec = Args.MakeArgString(linkPath);
Justin Bognerd3371d82015-07-17 03:35:54 +00009002 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009003}
Hans Wennborg87cfa712013-09-19 20:32:16 +00009004
Douglas Katzman95354292015-06-23 20:42:09 +00009005void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9006 const InputInfo &Output,
9007 const InputInfoList &Inputs,
9008 const ArgList &Args,
9009 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009010 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
9011}
9012
Douglas Katzman95354292015-06-23 20:42:09 +00009013std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
David Blaikiec11bf802014-09-04 16:04:28 +00009014 Compilation &C, const JobAction &JA, const InputInfo &Output,
9015 const InputInfoList &Inputs, const ArgList &Args,
9016 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009017 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00009018 CmdArgs.push_back("/nologo");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009019 CmdArgs.push_back("/c"); // Compile only.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009020 CmdArgs.push_back("/W0"); // No warnings.
9021
9022 // The goal is to be able to invoke this tool correctly based on
9023 // any flag accepted by clang-cl.
9024
9025 // These are spelled the same way in clang and cl.exe,.
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009026 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009027
9028 // Optimization level.
David Majnemer015ce0f2015-07-27 07:32:11 +00009029 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
9030 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"
9031 : "/Oi-");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009032 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
9033 if (A->getOption().getID() == options::OPT_O0) {
9034 CmdArgs.push_back("/Od");
9035 } else {
David Majnemer015ce0f2015-07-27 07:32:11 +00009036 CmdArgs.push_back("/Og");
9037
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009038 StringRef OptLevel = A->getValue();
David Majnemer015ce0f2015-07-27 07:32:11 +00009039 if (OptLevel == "s" || OptLevel == "z")
9040 CmdArgs.push_back("/Os");
9041 else
9042 CmdArgs.push_back("/Ot");
9043
9044 CmdArgs.push_back("/Ob2");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009045 }
9046 }
David Majnemer015ce0f2015-07-27 07:32:11 +00009047 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
9048 options::OPT_fno_omit_frame_pointer))
9049 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
9050 ? "/Oy"
9051 : "/Oy-");
9052 if (!Args.hasArg(options::OPT_fwritable_strings))
9053 CmdArgs.push_back("/GF");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009054
Nico Weber3f8dafb2015-03-12 19:37:10 +00009055 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009056 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
9057
David Majnemerf6072342014-07-01 22:24:56 +00009058 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
9059 /*default=*/false))
9060 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00009061 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
9062 options::OPT_fno_function_sections))
9063 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
9064 ? "/Gy"
9065 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00009066 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
9067 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00009068 CmdArgs.push_back(
9069 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009070 if (Args.hasArg(options::OPT_fsyntax_only))
9071 CmdArgs.push_back("/Zs");
Reid Kleckner124955a2015-08-05 18:51:13 +00009072 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
9073 options::OPT__SLASH_Z7))
Reid Klecknerc688daf2014-02-19 22:05:59 +00009074 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009075
Nico Weber3f8dafb2015-03-12 19:37:10 +00009076 std::vector<std::string> Includes =
9077 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009078 for (const auto &Include : Includes)
9079 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00009080
Hans Wennborg87cfa712013-09-19 20:32:16 +00009081 // Flags that can simply be passed through.
9082 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
9083 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00009084 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
David Majnemerbac941c2015-07-25 06:07:59 +00009085 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
Hans Wennborg87cfa712013-09-19 20:32:16 +00009086
9087 // The order of these flags is relevant, so pick the last one.
9088 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
9089 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
9090 A->render(Args, CmdArgs);
9091
Hans Wennborg87cfa712013-09-19 20:32:16 +00009092 // Input filename.
9093 assert(Inputs.size() == 1);
9094 const InputInfo &II = Inputs[0];
9095 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9096 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
9097 if (II.isFilename())
9098 CmdArgs.push_back(II.getFilename());
9099 else
9100 II.getInputArg().renderAsInput(Args, CmdArgs);
9101
9102 // Output filename.
9103 assert(Output.getType() == types::TY_Object);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009104 const char *Fo =
9105 Args.MakeArgString(std::string("/Fo") + Output.getFilename());
Hans Wennborg87cfa712013-09-19 20:32:16 +00009106 CmdArgs.push_back(Fo);
9107
Hans Wennborg188382e2013-09-20 18:16:35 +00009108 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009109 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
9110 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00009111 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
Justin Bognerd3371d82015-07-17 03:35:54 +00009112 CmdArgs, Inputs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00009113}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009114
Yaron Keren1c0070c2015-07-02 04:45:27 +00009115/// MinGW Tools
9116void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9117 const InputInfo &Output,
9118 const InputInfoList &Inputs,
9119 const ArgList &Args,
9120 const char *LinkingOutput) const {
9121 claimNoWarnArgs(Args);
9122 ArgStringList CmdArgs;
9123
9124 if (getToolChain().getArch() == llvm::Triple::x86) {
9125 CmdArgs.push_back("--32");
9126 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
9127 CmdArgs.push_back("--64");
9128 }
9129
9130 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9131
9132 CmdArgs.push_back("-o");
9133 CmdArgs.push_back(Output.getFilename());
9134
9135 for (const auto &II : Inputs)
9136 CmdArgs.push_back(II.getFilename());
9137
9138 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009139 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +00009140
9141 if (Args.hasArg(options::OPT_gsplit_dwarf))
9142 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
9143 SplitDebugName(Args, Inputs[0]));
9144}
9145
9146void MinGW::Linker::AddLibGCC(const ArgList &Args,
9147 ArgStringList &CmdArgs) const {
9148 if (Args.hasArg(options::OPT_mthreads))
9149 CmdArgs.push_back("-lmingwthrd");
9150 CmdArgs.push_back("-lmingw32");
Reid Kleckner0213a472015-07-22 16:01:38 +00009151
Yaron Kerenaa281332015-08-09 00:24:07 +00009152 // Make use of compiler-rt if --rtlib option is used
9153 ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
9154 if (RLT == ToolChain::RLT_Libgcc) {
9155 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
9156 Args.hasArg(options::OPT_static);
9157 bool Shared = Args.hasArg(options::OPT_shared);
9158 bool CXX = getToolChain().getDriver().CCCIsCXX();
9159
9160 if (Static || (!CXX && !Shared)) {
9161 CmdArgs.push_back("-lgcc");
9162 CmdArgs.push_back("-lgcc_eh");
9163 } else {
9164 CmdArgs.push_back("-lgcc_s");
9165 CmdArgs.push_back("-lgcc");
9166 }
9167 } else {
9168 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
9169 }
Reid Kleckner0213a472015-07-22 16:01:38 +00009170
Yaron Keren1c0070c2015-07-02 04:45:27 +00009171 CmdArgs.push_back("-lmoldname");
9172 CmdArgs.push_back("-lmingwex");
9173 CmdArgs.push_back("-lmsvcrt");
9174}
9175
9176void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9177 const InputInfo &Output,
9178 const InputInfoList &Inputs,
9179 const ArgList &Args,
9180 const char *LinkingOutput) const {
9181 const ToolChain &TC = getToolChain();
9182 const Driver &D = TC.getDriver();
9183 // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
9184
9185 ArgStringList CmdArgs;
9186
9187 // Silence warning for "clang -g foo.o -o foo"
9188 Args.ClaimAllArgs(options::OPT_g_Group);
9189 // and "clang -emit-llvm foo.o -o foo"
9190 Args.ClaimAllArgs(options::OPT_emit_llvm);
9191 // and for "clang -w foo.o -o foo". Other warning options are already
9192 // handled somewhere else.
9193 Args.ClaimAllArgs(options::OPT_w);
9194
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009195 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
9196 if (LinkerName.equals_lower("lld")) {
9197 CmdArgs.push_back("-flavor");
9198 CmdArgs.push_back("gnu");
9199 }
9200
Yaron Keren1c0070c2015-07-02 04:45:27 +00009201 if (!D.SysRoot.empty())
9202 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9203
9204 if (Args.hasArg(options::OPT_s))
9205 CmdArgs.push_back("-s");
9206
9207 CmdArgs.push_back("-m");
9208 if (TC.getArch() == llvm::Triple::x86)
9209 CmdArgs.push_back("i386pe");
9210 if (TC.getArch() == llvm::Triple::x86_64)
9211 CmdArgs.push_back("i386pep");
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009212 if (TC.getArch() == llvm::Triple::arm)
9213 CmdArgs.push_back("thumb2pe");
Yaron Keren1c0070c2015-07-02 04:45:27 +00009214
9215 if (Args.hasArg(options::OPT_mwindows)) {
9216 CmdArgs.push_back("--subsystem");
9217 CmdArgs.push_back("windows");
9218 } else if (Args.hasArg(options::OPT_mconsole)) {
9219 CmdArgs.push_back("--subsystem");
9220 CmdArgs.push_back("console");
9221 }
9222
9223 if (Args.hasArg(options::OPT_static))
9224 CmdArgs.push_back("-Bstatic");
9225 else {
9226 if (Args.hasArg(options::OPT_mdll))
9227 CmdArgs.push_back("--dll");
9228 else if (Args.hasArg(options::OPT_shared))
9229 CmdArgs.push_back("--shared");
9230 CmdArgs.push_back("-Bdynamic");
9231 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
9232 CmdArgs.push_back("-e");
9233 if (TC.getArch() == llvm::Triple::x86)
9234 CmdArgs.push_back("_DllMainCRTStartup@12");
9235 else
9236 CmdArgs.push_back("DllMainCRTStartup");
9237 CmdArgs.push_back("--enable-auto-image-base");
9238 }
9239 }
9240
9241 CmdArgs.push_back("-o");
9242 CmdArgs.push_back(Output.getFilename());
9243
9244 Args.AddAllArgs(CmdArgs, options::OPT_e);
9245 // FIXME: add -N, -n flags
9246 Args.AddLastArg(CmdArgs, options::OPT_r);
9247 Args.AddLastArg(CmdArgs, options::OPT_s);
9248 Args.AddLastArg(CmdArgs, options::OPT_t);
9249 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
9250 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
9251
9252 if (!Args.hasArg(options::OPT_nostdlib) &&
9253 !Args.hasArg(options::OPT_nostartfiles)) {
9254 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
9255 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
9256 } else {
9257 if (Args.hasArg(options::OPT_municode))
9258 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
9259 else
9260 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
9261 }
9262 if (Args.hasArg(options::OPT_pg))
9263 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
9264 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
9265 }
9266
9267 Args.AddAllArgs(CmdArgs, options::OPT_L);
9268 const ToolChain::path_list Paths = TC.getFilePaths();
9269 for (const auto &Path : Paths)
9270 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9271
9272 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9273
9274 // TODO: Add ASan stuff here
9275
9276 // TODO: Add profile stuff here
9277
9278 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9279 !Args.hasArg(options::OPT_nodefaultlibs)) {
9280 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
9281 !Args.hasArg(options::OPT_static);
9282 if (OnlyLibstdcxxStatic)
9283 CmdArgs.push_back("-Bstatic");
9284 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9285 if (OnlyLibstdcxxStatic)
9286 CmdArgs.push_back("-Bdynamic");
9287 }
9288
9289 if (!Args.hasArg(options::OPT_nostdlib)) {
9290 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9291 if (Args.hasArg(options::OPT_static))
9292 CmdArgs.push_back("--start-group");
9293
9294 if (Args.hasArg(options::OPT_fstack_protector) ||
9295 Args.hasArg(options::OPT_fstack_protector_strong) ||
9296 Args.hasArg(options::OPT_fstack_protector_all)) {
9297 CmdArgs.push_back("-lssp_nonshared");
9298 CmdArgs.push_back("-lssp");
9299 }
9300 if (Args.hasArg(options::OPT_fopenmp))
9301 CmdArgs.push_back("-lgomp");
9302
9303 AddLibGCC(Args, CmdArgs);
9304
9305 if (Args.hasArg(options::OPT_pg))
9306 CmdArgs.push_back("-lgmon");
9307
Yaron Kerenadce68e2015-07-06 18:52:19 +00009308 if (Args.hasArg(options::OPT_pthread))
9309 CmdArgs.push_back("-lpthread");
Yaron Keren1c0070c2015-07-02 04:45:27 +00009310
9311 // add system libraries
9312 if (Args.hasArg(options::OPT_mwindows)) {
9313 CmdArgs.push_back("-lgdi32");
9314 CmdArgs.push_back("-lcomdlg32");
9315 }
9316 CmdArgs.push_back("-ladvapi32");
9317 CmdArgs.push_back("-lshell32");
9318 CmdArgs.push_back("-luser32");
9319 CmdArgs.push_back("-lkernel32");
9320
9321 if (Args.hasArg(options::OPT_static))
9322 CmdArgs.push_back("--end-group");
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009323 else if (!LinkerName.equals_lower("lld"))
Yaron Keren1c0070c2015-07-02 04:45:27 +00009324 AddLibGCC(Args, CmdArgs);
9325 }
9326
9327 if (!Args.hasArg(options::OPT_nostartfiles)) {
9328 // Add crtfastmath.o if available and fast math is enabled.
9329 TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
9330
9331 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
9332 }
9333 }
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009334 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
Justin Bognerd3371d82015-07-17 03:35:54 +00009335 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +00009336}
9337
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009338/// XCore Tools
9339// We pass assemble and link construction to the xcc tool.
9340
Douglas Katzman95354292015-06-23 20:42:09 +00009341void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9342 const InputInfo &Output,
9343 const InputInfoList &Inputs,
9344 const ArgList &Args,
9345 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009346 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009347 ArgStringList CmdArgs;
9348
9349 CmdArgs.push_back("-o");
9350 CmdArgs.push_back(Output.getFilename());
9351
9352 CmdArgs.push_back("-c");
9353
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009354 if (Args.hasArg(options::OPT_v))
9355 CmdArgs.push_back("-v");
9356
Robert Lytton894d25c2014-05-02 09:33:25 +00009357 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
9358 if (!A->getOption().matches(options::OPT_g0))
9359 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009360
Robert Lytton8e95d4e2014-02-11 10:34:45 +00009361 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
9362 false))
9363 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009364
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009365 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009366
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009367 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009368 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009369
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009370 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009371 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009372}
9373
Douglas Katzman95354292015-06-23 20:42:09 +00009374void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9375 const InputInfo &Output,
9376 const InputInfoList &Inputs,
9377 const ArgList &Args,
9378 const char *LinkingOutput) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009379 ArgStringList CmdArgs;
9380
9381 if (Output.isFilename()) {
9382 CmdArgs.push_back("-o");
9383 CmdArgs.push_back(Output.getFilename());
9384 } else {
9385 assert(Output.isNothing() && "Invalid output.");
9386 }
9387
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009388 if (Args.hasArg(options::OPT_v))
9389 CmdArgs.push_back("-v");
9390
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00009391 // Pass -fexceptions through to the linker if it was present.
9392 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
9393 false))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00009394 CmdArgs.push_back("-fexceptions");
9395
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009396 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
9397
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009398 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009399 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009400}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009401
Douglas Katzman95354292015-06-23 20:42:09 +00009402void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9403 const InputInfo &Output,
9404 const InputInfoList &Inputs,
9405 const ArgList &Args,
9406 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009407 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009408 const auto &TC =
9409 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9410 ArgStringList CmdArgs;
9411 const char *Exec;
9412
9413 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009414 default:
9415 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009416 case llvm::Triple::arm:
9417 case llvm::Triple::thumb:
9418 break;
9419 case llvm::Triple::x86:
9420 CmdArgs.push_back("--32");
9421 break;
9422 case llvm::Triple::x86_64:
9423 CmdArgs.push_back("--64");
9424 break;
9425 }
9426
9427 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9428
9429 CmdArgs.push_back("-o");
9430 CmdArgs.push_back(Output.getFilename());
9431
9432 for (const auto &Input : Inputs)
9433 CmdArgs.push_back(Input.getFilename());
9434
9435 const std::string Assembler = TC.GetProgramPath("as");
9436 Exec = Args.MakeArgString(Assembler);
9437
Justin Bognerd3371d82015-07-17 03:35:54 +00009438 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009439}
9440
Douglas Katzman95354292015-06-23 20:42:09 +00009441void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9442 const InputInfo &Output,
9443 const InputInfoList &Inputs,
9444 const ArgList &Args,
9445 const char *LinkingOutput) const {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009446 const auto &TC =
9447 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9448 const llvm::Triple &T = TC.getTriple();
9449 const Driver &D = TC.getDriver();
9450 SmallString<128> EntryPoint;
9451 ArgStringList CmdArgs;
9452 const char *Exec;
9453
9454 // Silence warning for "clang -g foo.o -o foo"
9455 Args.ClaimAllArgs(options::OPT_g_Group);
9456 // and "clang -emit-llvm foo.o -o foo"
9457 Args.ClaimAllArgs(options::OPT_emit_llvm);
9458 // and for "clang -w foo.o -o foo"
9459 Args.ClaimAllArgs(options::OPT_w);
9460 // Other warning options are already handled somewhere else.
9461
9462 if (!D.SysRoot.empty())
9463 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9464
9465 if (Args.hasArg(options::OPT_pie))
9466 CmdArgs.push_back("-pie");
9467 if (Args.hasArg(options::OPT_rdynamic))
9468 CmdArgs.push_back("-export-dynamic");
9469 if (Args.hasArg(options::OPT_s))
9470 CmdArgs.push_back("--strip-all");
9471
9472 CmdArgs.push_back("-m");
9473 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009474 default:
9475 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009476 case llvm::Triple::arm:
9477 case llvm::Triple::thumb:
9478 // FIXME: this is incorrect for WinCE
9479 CmdArgs.push_back("thumb2pe");
9480 break;
9481 case llvm::Triple::x86:
9482 CmdArgs.push_back("i386pe");
9483 EntryPoint.append("_");
9484 break;
9485 case llvm::Triple::x86_64:
9486 CmdArgs.push_back("i386pep");
9487 break;
9488 }
9489
9490 if (Args.hasArg(options::OPT_shared)) {
9491 switch (T.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009492 default:
9493 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009494 case llvm::Triple::arm:
9495 case llvm::Triple::thumb:
9496 case llvm::Triple::x86_64:
9497 EntryPoint.append("_DllMainCRTStartup");
9498 break;
9499 case llvm::Triple::x86:
9500 EntryPoint.append("_DllMainCRTStartup@12");
9501 break;
9502 }
9503
9504 CmdArgs.push_back("-shared");
9505 CmdArgs.push_back("-Bdynamic");
9506
9507 CmdArgs.push_back("--enable-auto-image-base");
9508
9509 CmdArgs.push_back("--entry");
9510 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9511 } else {
9512 EntryPoint.append("mainCRTStartup");
9513
9514 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
9515 : "-Bdynamic");
9516
9517 if (!Args.hasArg(options::OPT_nostdlib) &&
9518 !Args.hasArg(options::OPT_nostartfiles)) {
9519 CmdArgs.push_back("--entry");
9520 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9521 }
9522
9523 // FIXME: handle subsystem
9524 }
9525
9526 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00009527 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009528
9529 CmdArgs.push_back("-o");
9530 CmdArgs.push_back(Output.getFilename());
9531
9532 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9533 SmallString<261> ImpLib(Output.getFilename());
9534 llvm::sys::path::replace_extension(ImpLib, ".lib");
9535
9536 CmdArgs.push_back("--out-implib");
9537 CmdArgs.push_back(Args.MakeArgString(ImpLib));
9538 }
9539
9540 if (!Args.hasArg(options::OPT_nostdlib) &&
9541 !Args.hasArg(options::OPT_nostartfiles)) {
9542 const std::string CRTPath(D.SysRoot + "/usr/lib/");
9543 const char *CRTBegin;
9544
9545 CRTBegin =
9546 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
9547 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9548 }
9549
9550 Args.AddAllArgs(CmdArgs, options::OPT_L);
9551
9552 const auto &Paths = TC.getFilePaths();
9553 for (const auto &Path : Paths)
9554 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9555
9556 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9557
9558 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9559 !Args.hasArg(options::OPT_nodefaultlibs)) {
9560 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9561 !Args.hasArg(options::OPT_static);
9562 if (StaticCXX)
9563 CmdArgs.push_back("-Bstatic");
9564 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9565 if (StaticCXX)
9566 CmdArgs.push_back("-Bdynamic");
9567 }
9568
9569 if (!Args.hasArg(options::OPT_nostdlib)) {
9570 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9571 // TODO handle /MT[d] /MD[d]
9572 CmdArgs.push_back("-lmsvcrt");
9573 AddRunTimeLibs(TC, D, CmdArgs, Args);
9574 }
9575 }
9576
9577 const std::string Linker = TC.GetProgramPath("ld");
9578 Exec = Args.MakeArgString(Linker);
9579
Justin Bognerd3371d82015-07-17 03:35:54 +00009580 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009581}
Douglas Katzman84a75642015-06-19 14:55:19 +00009582
Douglas Katzman95354292015-06-23 20:42:09 +00009583void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9584 const InputInfo &Output,
9585 const InputInfoList &Inputs,
9586 const ArgList &Args,
9587 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +00009588
9589 ArgStringList CmdArgs;
9590
9591 assert(Inputs.size() == 1);
9592 const InputInfo &II = Inputs[0];
9593 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9594 assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm.
9595
Douglas Katzman84a75642015-06-19 14:55:19 +00009596 CmdArgs.push_back("-DMYRIAD2");
9597 CmdArgs.push_back("-mcpu=myriad2");
9598 CmdArgs.push_back("-S");
9599
Douglas Katzmanf6071112015-08-03 14:34:22 +00009600 // Append all -I, -iquote, -isystem paths, defines/undefines,
9601 // 'f' flags, optimize flags, and warning options.
9602 // These are spelled the same way in clang and moviCompile.
9603 Args.AddAllArgs(CmdArgs,
9604 {options::OPT_I_Group, options::OPT_clang_i_Group,
9605 options::OPT_D, options::OPT_U,
9606 options::OPT_f_Group,
9607 options::OPT_f_clang_Group,
9608 options::OPT_g_Group,
9609 options::OPT_O_Group,
9610 options::OPT_W_Group});
Douglas Katzman84a75642015-06-19 14:55:19 +00009611 CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified.
9612
9613 CmdArgs.push_back(II.getFilename());
9614 CmdArgs.push_back("-o");
9615 CmdArgs.push_back(Output.getFilename());
9616
9617 std::string Exec =
9618 Args.MakeArgString(getToolChain().GetProgramPath("moviCompile"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009619 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
9620 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +00009621}
9622
Douglas Katzman95354292015-06-23 20:42:09 +00009623void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9624 const InputInfo &Output,
9625 const InputInfoList &Inputs,
9626 const ArgList &Args,
9627 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +00009628 ArgStringList CmdArgs;
9629
9630 assert(Inputs.size() == 1);
9631 const InputInfo &II = Inputs[0];
9632 assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input.
9633 assert(Output.getType() == types::TY_Object);
9634
9635 CmdArgs.push_back("-no6thSlotCompression");
9636 CmdArgs.push_back("-cv:myriad2"); // Chip Version ?
9637 CmdArgs.push_back("-noSPrefixing");
9638 CmdArgs.push_back("-a"); // Mystery option.
9639 for (auto Arg : Args.filtered(options::OPT_I)) {
9640 Arg->claim();
9641 CmdArgs.push_back(
9642 Args.MakeArgString(std::string("-i:") + Arg->getValue(0)));
9643 }
9644 CmdArgs.push_back("-elf"); // Output format.
9645 CmdArgs.push_back(II.getFilename());
9646 CmdArgs.push_back(
9647 Args.MakeArgString(std::string("-o:") + Output.getFilename()));
9648
9649 std::string Exec =
9650 Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009651 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
9652 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +00009653}