blob: 9ebf681aabde39324c80bfb15808928b0a722d49 [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"
David Blaikie24bbfed22014-03-31 23:29:38 +000035#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000036#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000037#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000038#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000039#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000040#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000041#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000042#include "llvm/Support/raw_ostream.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000043
Ben Langmuir3b7b5402015-02-03 19:28:37 +000044#ifdef LLVM_ON_UNIX
45#include <unistd.h> // For getuid().
46#endif
47
Daniel Dunbar1a093d22009-03-18 06:00:36 +000048using namespace clang::driver;
49using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000050using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000051using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000052
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000053static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
54 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
55 options::OPT_fpic, options::OPT_fno_pic,
56 options::OPT_fPIE, options::OPT_fno_PIE,
57 options::OPT_fpie, options::OPT_fno_pie);
58 if (!LastPICArg)
59 return;
60 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
61 LastPICArg->getOption().matches(options::OPT_fpic) ||
62 LastPICArg->getOption().matches(options::OPT_fPIE) ||
63 LastPICArg->getOption().matches(options::OPT_fpie)) {
64 CmdArgs.push_back("-KPIC");
65 }
66}
67
Daniel Dunbar64198ef2009-09-10 01:21:05 +000068/// CheckPreprocessingOptions - Perform some validation of preprocessing
69/// arguments that is shared with gcc.
70static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000071 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
72 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
73 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000074 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000075 << A->getBaseArg().getAsString(Args)
76 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
77 }
78 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000079}
80
Daniel Dunbar4eadb602009-09-10 01:21:12 +000081/// CheckCodeGenerationOptions - Perform some validation of code generation
82/// arguments that is shared with gcc.
83static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
84 // In gcc, only ARM checks this, but it seems reasonable to check universally.
85 if (Args.hasArg(options::OPT_static))
86 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
87 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000088 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000089 << A->getAsString(Args) << "-static";
90}
91
Bob Wilsond5aad2a2014-11-04 22:28:48 +000092// Add backslashes to escape spaces and other backslashes.
93// This is used for the space-separated argument list specified with
94// the -dwarf-debug-flags option.
95static void EscapeSpacesAndBackslashes(const char *Arg,
96 SmallVectorImpl<char> &Res) {
97 for ( ; *Arg; ++Arg) {
98 switch (*Arg) {
99 default: break;
100 case ' ':
101 case '\\':
102 Res.push_back('\\');
103 break;
104 }
105 Res.push_back(*Arg);
106 }
107}
108
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000109// Quote target names for inclusion in GNU Make dependency files.
110// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000111static void QuoteTarget(StringRef Target,
112 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000113 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
114 switch (Target[i]) {
115 case ' ':
116 case '\t':
117 // Escape the preceding backslashes
118 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
119 Res.push_back('\\');
120
121 // Escape the space/tab
122 Res.push_back('\\');
123 break;
124 case '$':
125 Res.push_back('$');
126 break;
127 case '#':
128 Res.push_back('\\');
129 break;
130 default:
131 break;
132 }
133
134 Res.push_back(Target[i]);
135 }
136}
137
Bill Wendlingc0938f32012-03-12 22:10:06 +0000138static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000139 ArgStringList &CmdArgs,
140 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000141 const char *EnvVar) {
142 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000143 bool CombinedArg = false;
144
Bill Wendling281ca292012-03-12 21:22:35 +0000145 if (!DirList)
146 return; // Nothing to do.
147
Chad Rosier616e8a52012-10-30 21:42:09 +0000148 StringRef Name(ArgName);
149 if (Name.equals("-I") || Name.equals("-L"))
150 CombinedArg = true;
151
Bill Wendling281ca292012-03-12 21:22:35 +0000152 StringRef Dirs(DirList);
153 if (Dirs.empty()) // Empty string should not add '.'.
154 return;
155
156 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000157 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000158 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000159 if (CombinedArg) {
160 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
161 } else {
162 CmdArgs.push_back(ArgName);
163 CmdArgs.push_back(".");
164 }
Bill Wendling281ca292012-03-12 21:22:35 +0000165 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000166 if (CombinedArg) {
167 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
168 } else {
169 CmdArgs.push_back(ArgName);
170 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
171 }
Bill Wendling281ca292012-03-12 21:22:35 +0000172 }
Nico Weber89355782012-03-19 15:00:03 +0000173 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000174 }
175
176 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000177 if (CombinedArg) {
178 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
179 } else {
180 CmdArgs.push_back(ArgName);
181 CmdArgs.push_back(".");
182 }
Bill Wendling281ca292012-03-12 21:22:35 +0000183 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000184 if (CombinedArg) {
185 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
186 } else {
187 CmdArgs.push_back(ArgName);
188 CmdArgs.push_back(Args.MakeArgString(Dirs));
189 }
Bill Wendling281ca292012-03-12 21:22:35 +0000190 }
191}
192
Daniel Dunbar54423b22010-09-17 00:24:54 +0000193static void AddLinkerInputs(const ToolChain &TC,
194 const InputInfoList &Inputs, const ArgList &Args,
195 ArgStringList &CmdArgs) {
196 const Driver &D = TC.getDriver();
197
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000198 // Add extra linker input arguments which are not treated as inputs
199 // (constructed via -Xarch_).
200 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
201
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000202 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000203 if (!TC.HasNativeLLVMSupport()) {
204 // Don't try to pass LLVM inputs unless we have native support.
205 if (II.getType() == types::TY_LLVM_IR ||
206 II.getType() == types::TY_LTO_IR ||
207 II.getType() == types::TY_LLVM_BC ||
208 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000209 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000210 << TC.getTripleString();
211 }
212
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000213 // Add filenames immediately.
214 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000215 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000216 continue;
217 }
218
219 // Otherwise, this is a linker input argument.
220 const Arg &A = II.getInputArg();
221
222 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000223 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000224 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000225 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000226 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000227 else if (A.getOption().matches(options::OPT_z)) {
228 // Pass -z prefix for gcc linker compatibility.
229 A.claim();
230 A.render(Args, CmdArgs);
231 } else {
232 A.renderAsInput(Args, CmdArgs);
233 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000234 }
Bill Wendling281ca292012-03-12 21:22:35 +0000235
236 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000237 // and only supported on native toolchains.
238 if (!TC.isCrossCompiling())
239 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000240}
241
John McCall31168b02011-06-15 23:02:42 +0000242/// \brief Determine whether Objective-C automated reference counting is
243/// enabled.
244static bool isObjCAutoRefCount(const ArgList &Args) {
245 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
246}
247
Ted Kremeneke65b0862012-03-06 20:05:56 +0000248/// \brief Determine whether we are linking the ObjC runtime.
249static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000250 if (isObjCAutoRefCount(Args)) {
251 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000252 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000253 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000254 return Args.hasArg(options::OPT_fobjc_link_runtime);
255}
256
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000257static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000258 // Don't forward inputs from the original command line. They are added from
259 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000260 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000261 !O.hasFlag(options::DriverOption) &&
262 !O.hasFlag(options::LinkerInput);
263}
264
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000265void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000266 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000267 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000268 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000269 ArgStringList &CmdArgs,
270 const InputInfo &Output,
271 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000272 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000273
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000274 CheckPreprocessingOptions(D, Args);
275
276 Args.AddLastArg(CmdArgs, options::OPT_C);
277 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000278
279 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000280 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000281 (A = Args.getLastArg(options::OPT_MD)) ||
282 (A = Args.getLastArg(options::OPT_MMD))) {
283 // Determine the output location.
284 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000285 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000286 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000287 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000288 } else if (Output.getType() == types::TY_Dependencies) {
289 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000290 } else if (A->getOption().matches(options::OPT_M) ||
291 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000292 DepFile = "-";
293 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000294 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000295 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000296 }
297 CmdArgs.push_back("-dependency-file");
298 CmdArgs.push_back(DepFile);
299
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000300 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000301 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
302 const char *DepTarget;
303
304 // If user provided -o, that is the dependency target, except
305 // when we are only generating a dependency file.
306 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
307 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000308 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000309 } else {
310 // Otherwise derive from the base input.
311 //
312 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000313 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000314 llvm::sys::path::replace_extension(P, "o");
315 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000316 }
317
318 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000319 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000320 QuoteTarget(DepTarget, Quoted);
321 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000322 }
323
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000324 if (A->getOption().matches(options::OPT_M) ||
325 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000326 CmdArgs.push_back("-sys-header-deps");
Manuel Klimekc68aa162015-03-19 12:00:22 +0000327 if ((isa<PrecompileJobAction>(JA) &&
328 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
329 Args.hasArg(options::OPT_fmodule_file_deps))
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000330 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000331 }
332
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000333 if (Args.hasArg(options::OPT_MG)) {
334 if (!A || A->getOption().matches(options::OPT_MD) ||
335 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000336 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000337 CmdArgs.push_back("-MG");
338 }
339
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000340 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000341
342 // Convert all -MQ <target> args to -MT <quoted target>
343 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
344 options::OPT_MQ),
345 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000346 const Arg *A = *it;
347 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000348
Daniel Dunbara442fd52010-06-11 22:00:13 +0000349 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000350 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000351 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000352 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000353 CmdArgs.push_back(Args.MakeArgString(Quoted));
354
355 // -MT flag - no change
356 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000357 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000358 }
359 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000360
Douglas Gregor111af7d2009-04-18 00:34:01 +0000361 // Add -i* options, and automatically translate to
362 // -include-pch/-include-pth for transparent PCH support. It's
363 // wonky, but we include looking for .gch so we can support seamless
364 // replacement into a build system already set up to be generating
365 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000366 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000367 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
368 ie = Args.filtered_end(); it != ie; ++it) {
369 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000370
371 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000372 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
373 RenderedImplicitInclude = true;
374
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000375 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000376 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000377
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000378 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000379 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000380 SmallString<128> P(A->getValue());
381 // We want the files to have a name like foo.h.pch. Add a dummy extension
382 // so that replace_extension does the right thing.
383 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000384 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000385 llvm::sys::path::replace_extension(P, "pch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000386 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000387 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000388 }
389
Douglas Gregor111af7d2009-04-18 00:34:01 +0000390 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000391 llvm::sys::path::replace_extension(P, "pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000392 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000393 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000394 }
395
Douglas Gregor111af7d2009-04-18 00:34:01 +0000396 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000397 llvm::sys::path::replace_extension(P, "gch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000398 if (llvm::sys::fs::exists(P)) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000399 FoundPCH = UsePCH;
400 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000401 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000402 }
403
404 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000405 if (IsFirstImplicitInclude) {
406 A->claim();
407 if (UsePCH)
408 CmdArgs.push_back("-include-pch");
409 else
410 CmdArgs.push_back("-include-pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000411 CmdArgs.push_back(Args.MakeArgString(P));
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000412 continue;
413 } else {
414 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000415 D.Diag(diag::warn_drv_pch_not_first_include)
Yaron Keren92e1b622015-03-18 10:17:07 +0000416 << P << A->getAsString(Args);
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000417 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000418 }
419 }
420
421 // Not translated, render as usual.
422 A->claim();
423 A->render(Args, CmdArgs);
424 }
425
426 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000427 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
428 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000429
430 // Add -Wp, and -Xassembler if using the preprocessor.
431
432 // FIXME: There is a very unfortunate problem here, some troubled
433 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
434 // really support that we would have to parse and then translate
435 // those options. :(
436 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
437 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000438
439 // -I- is a deprecated GCC feature, reject it.
440 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000441 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000442
443 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
444 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000445 StringRef sysroot = C.getSysRoot();
446 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000447 if (!Args.hasArg(options::OPT_isysroot)) {
448 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000449 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000450 }
451 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000452
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000453 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000454 // FIXME: We should probably sink the logic for handling these from the
455 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000456 // CPATH - included following the user specified includes (but prior to
457 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000458 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000459 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000460 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000461 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000462 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000463 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000464 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000465 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000466 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000467
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000468 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000469 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000470 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000471
472 // Add system include arguments.
473 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000474}
475
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000476// FIXME: Move to target hook.
477static bool isSignedCharDefault(const llvm::Triple &Triple) {
478 switch (Triple.getArch()) {
479 default:
480 return true;
481
Tim Northover9bb857a2013-01-31 12:13:10 +0000482 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000483 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000484 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000485 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000486 case llvm::Triple::thumb:
487 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000488 if (Triple.isOSDarwin() || Triple.isOSWindows())
489 return true;
490 return false;
491
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000492 case llvm::Triple::ppc:
493 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000494 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000495 return true;
496 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000497
Bill Schmidt778d3872013-07-26 01:36:11 +0000498 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000499 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000500 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000501 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000502 }
503}
504
Robert Lytton0e076492013-08-13 09:43:10 +0000505static bool isNoCommonDefault(const llvm::Triple &Triple) {
506 switch (Triple.getArch()) {
507 default:
508 return false;
509
510 case llvm::Triple::xcore:
511 return true;
512 }
513}
514
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000515// Handle -mhwdiv=.
516static void getARMHWDivFeatures(const Driver &D, const Arg *A,
517 const ArgList &Args,
518 std::vector<const char *> &Features) {
519 StringRef HWDiv = A->getValue();
520 if (HWDiv == "arm") {
521 Features.push_back("+hwdiv-arm");
522 Features.push_back("-hwdiv");
523 } else if (HWDiv == "thumb") {
524 Features.push_back("-hwdiv-arm");
525 Features.push_back("+hwdiv");
526 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
527 Features.push_back("+hwdiv-arm");
528 Features.push_back("+hwdiv");
529 } else if (HWDiv == "none") {
530 Features.push_back("-hwdiv-arm");
531 Features.push_back("-hwdiv");
532 } else
533 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=.
537//
538// FIXME: Centralize feature selection, defaulting shouldn't be also in the
539// frontend target.
540static void getARMFPUFeatures(const Driver &D, const Arg *A,
541 const ArgList &Args,
542 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000543 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000544
545 // Set the target features based on the FPU.
546 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
547 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000548 Features.push_back("-vfp2");
549 Features.push_back("-vfp3");
550 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000551 } else if (FPU == "vfp") {
552 Features.push_back("+vfp2");
553 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000554 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000555 Features.push_back("+vfp3");
556 Features.push_back("+d16");
557 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000558 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000559 Features.push_back("+vfp3");
560 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000561 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
562 Features.push_back("+vfp4");
563 Features.push_back("+d16");
564 Features.push_back("-neon");
565 } else if (FPU == "vfp4" || FPU == "vfpv4") {
566 Features.push_back("+vfp4");
567 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000568 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
569 Features.push_back("+vfp4");
570 Features.push_back("+d16");
571 Features.push_back("+fp-only-sp");
572 Features.push_back("-neon");
Oliver Stannardbfd3ea32014-10-01 09:03:02 +0000573 } else if (FPU == "fp5-sp-d16" || FPU == "fpv5-sp-d16") {
574 Features.push_back("+fp-armv8");
575 Features.push_back("+fp-only-sp");
576 Features.push_back("+d16");
577 Features.push_back("-neon");
578 Features.push_back("-crypto");
579 } else if (FPU == "fp5-dp-d16" || FPU == "fpv5-dp-d16" ||
580 FPU == "fp5-d16" || FPU == "fpv5-d16") {
581 Features.push_back("+fp-armv8");
582 Features.push_back("+d16");
583 Features.push_back("-neon");
584 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000585 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000586 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000587 Features.push_back("-neon");
588 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000589 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000590 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000591 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000592 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000593 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000594 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000595 Features.push_back("+neon");
596 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000597 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000598 Features.push_back("+neon");
Richard Barton3b0dcc12014-11-28 20:39:59 +0000599 } else if (FPU == "neon-vfpv3") {
Richard Barton2c5a8972014-12-18 16:31:18 +0000600 Features.push_back("+vfp3");
Richard Barton3b0dcc12014-11-28 20:39:59 +0000601 Features.push_back("+neon");
Richard Barton09b60b22014-11-28 20:39:54 +0000602 } else if (FPU == "neon-vfpv4") {
603 Features.push_back("+neon");
Richard Barton2c5a8972014-12-18 16:31:18 +0000604 Features.push_back("+vfp4");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000605 } else if (FPU == "none") {
606 Features.push_back("-vfp2");
607 Features.push_back("-vfp3");
608 Features.push_back("-vfp4");
609 Features.push_back("-fp-armv8");
610 Features.push_back("-crypto");
611 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000612 } else
613 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
614}
615
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000616// Select the float ABI as determined by -msoft-float, -mhard-float, and
617// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000618StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000619 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000620 StringRef FloatABI;
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000621 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
622 options::OPT_mhard_float,
623 options::OPT_mfloat_abi_EQ)) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000624 if (A->getOption().matches(options::OPT_msoft_float))
625 FloatABI = "soft";
626 else if (A->getOption().matches(options::OPT_mhard_float))
627 FloatABI = "hard";
628 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000629 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000630 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000631 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000632 << A->getAsString(Args);
633 FloatABI = "soft";
634 }
635 }
636 }
637
638 // If unspecified, choose the default based on the platform.
639 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000640 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000641 case llvm::Triple::Darwin:
642 case llvm::Triple::MacOSX:
643 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000644 // Darwin defaults to "softfp" for v6 and v7.
645 //
646 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000647 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000648 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000649 if (StringRef(ArchName).startswith("v6") ||
650 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000651 FloatABI = "softfp";
652 else
653 FloatABI = "soft";
654 break;
655 }
656
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000657 // FIXME: this is invalid for WindowsCE
658 case llvm::Triple::Win32:
659 FloatABI = "hard";
660 break;
661
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000662 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000663 switch(Triple.getEnvironment()) {
664 case llvm::Triple::GNUEABIHF:
665 FloatABI = "hard";
666 break;
667 default:
668 // FreeBSD defaults to soft float
669 FloatABI = "soft";
670 break;
671 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000672 break;
673
Daniel Dunbar78485922009-09-10 23:00:09 +0000674 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000675 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000676 case llvm::Triple::GNUEABIHF:
677 FloatABI = "hard";
678 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000679 case llvm::Triple::GNUEABI:
680 FloatABI = "softfp";
681 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000682 case llvm::Triple::EABIHF:
683 FloatABI = "hard";
684 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000685 case llvm::Triple::EABI:
686 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
687 FloatABI = "softfp";
688 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000689 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000690 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000691 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000692 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000693 FloatABI = "softfp";
694 else
695 FloatABI = "soft";
696 break;
697 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000698 default:
699 // Assume "soft", but warn the user we are guessing.
700 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000701 if (Triple.getOS() != llvm::Triple::UnknownOS ||
702 !Triple.isOSBinFormatMachO())
703 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000704 break;
705 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000706 }
707 }
708
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000709 return FloatABI;
710}
711
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000712static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
713 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000714 std::vector<const char *> &Features,
715 bool ForAS) {
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000716 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000717 if (!ForAS) {
718 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
719 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
720 // stripped out by the ARM target. We should probably pass this a new
721 // -target-option, which is handled by the -cc1/-cc1as invocation.
722 //
723 // FIXME2: For consistency, it would be ideal if we set up the target
724 // machine state the same when using the frontend or the assembler. We don't
725 // currently do that for the assembler, we pass the options directly to the
726 // backend and never even instantiate the frontend TargetInfo. If we did,
727 // and used its handleTargetFeatures hook, then we could ensure the
728 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000729
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000730 // Use software floating point operations?
731 if (FloatABI == "soft")
732 Features.push_back("+soft-float");
733
734 // Use software floating point argument passing?
735 if (FloatABI != "hard")
736 Features.push_back("+soft-float-abi");
737 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000738
739 // Honor -mfpu=.
740 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000741 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000742 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
743 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000744
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000745 // Setting -msoft-float effectively disables NEON because of the GCC
746 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000747 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000748 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000749 // Also need to explicitly disable features which imply NEON.
750 Features.push_back("-crypto");
751 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000752
Eric Christopher269c2a22015-04-04 03:34:43 +0000753 // En/disable crc code generation.
754 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bernard Ogden18b57012013-10-29 09:47:51 +0000755 if (A->getOption().matches(options::OPT_mcrc))
756 Features.push_back("+crc");
757 else
758 Features.push_back("-crc");
759 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000760}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000761
762void Clang::AddARMTargetArgs(const ArgList &Args,
763 ArgStringList &CmdArgs,
764 bool KernelOrKext) const {
765 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000766 // Get the effective triple, which takes into account the deployment target.
767 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
768 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000769 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000770
771 // Select the ABI to use.
772 //
773 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +0000774 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +0000775 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000776 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000777 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000778 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000779 // The backend is hardwired to assume AAPCS for M-class processors, ensure
780 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000781 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Eric Christopher610952e2014-12-05 00:22:48 +0000782 Triple.getOS() == llvm::Triple::UnknownOS ||
Tim Northovere66c9462013-10-03 14:23:28 +0000783 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000784 ABIName = "aapcs";
785 } else {
786 ABIName = "apcs-gnu";
787 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000788 } else if (Triple.isOSWindows()) {
789 // FIXME: this is invalid for WindowsCE
790 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000791 } else {
792 // Select the default based on the platform.
793 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000794 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000795 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000796 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000797 ABIName = "aapcs-linux";
798 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000799 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000800 case llvm::Triple::EABI:
801 ABIName = "aapcs";
802 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000803 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +0000804 if (Triple.getOS() == llvm::Triple::NetBSD)
805 ABIName = "apcs-gnu";
806 else
807 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000808 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000809 }
810 }
811 CmdArgs.push_back("-target-abi");
812 CmdArgs.push_back(ABIName);
813
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000814 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000815 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000816 if (FloatABI == "soft") {
817 // Floating point operations and argument passing are soft.
818 //
819 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000820 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000821 CmdArgs.push_back("-mfloat-abi");
822 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000823 } else if (FloatABI == "softfp") {
824 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000825 CmdArgs.push_back("-mfloat-abi");
826 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000827 } else {
828 // Floating point operations and argument passing are hard.
829 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000830 CmdArgs.push_back("-mfloat-abi");
831 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000832 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000833
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000834 // Kernel code has more strict alignment requirements.
835 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000836 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000837 CmdArgs.push_back("-backend-option");
838 CmdArgs.push_back("-arm-long-calls");
839 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000840
Daniel Dunbar12100e22011-03-22 16:48:17 +0000841 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000842 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000843
844 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000845 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000846 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000847 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000848
Bob Wilson0874e532014-07-29 00:23:18 +0000849 // -mkernel implies -mstrict-align; don't add the redundant option.
850 if (!KernelOrKext) {
851 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
852 options::OPT_munaligned_access)) {
853 CmdArgs.push_back("-backend-option");
854 if (A->getOption().matches(options::OPT_mno_unaligned_access))
855 CmdArgs.push_back("-arm-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000856 else {
Jonathan Roelofs2b00d542014-10-07 15:11:32 +0000857 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
Oliver Stannard76244be2014-08-13 09:18:12 +0000858 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
Bob Wilson0874e532014-07-29 00:23:18 +0000859 CmdArgs.push_back("-arm-no-strict-align");
Oliver Stannard76244be2014-08-13 09:18:12 +0000860 }
Bob Wilson0874e532014-07-29 00:23:18 +0000861 }
862 }
863
Chad Rosierba3df1d2011-08-26 00:26:29 +0000864 // Setting -mno-global-merge disables the codegen global merge pass. Setting
865 // -mglobal-merge has no effect as the pass is enabled by default.
866 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
867 options::OPT_mno_global_merge)) {
868 if (A->getOption().matches(options::OPT_mno_global_merge))
869 CmdArgs.push_back("-mno-global-merge");
870 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000871
Bob Wilson9c8af452013-04-11 18:53:25 +0000872 if (!Args.hasFlag(options::OPT_mimplicit_float,
873 options::OPT_mno_implicit_float,
874 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000875 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000876
Logan Chien749763e2014-04-03 13:12:44 +0000877 // llvm does not support reserving registers in general. There is support
878 // for reserving r9 on ARM though (defined as a platform-specific register
879 // in ARM EABI).
880 if (Args.hasArg(options::OPT_ffixed_r9)) {
881 CmdArgs.push_back("-backend-option");
882 CmdArgs.push_back("-arm-reserve-r9");
883 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000884}
885
Tim Northover573cbee2014-05-24 12:52:07 +0000886/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
887/// targeting.
888static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000889 Arg *A;
890 std::string CPU;
891 // If we have -mtune or -mcpu, use that.
892 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
893 CPU = A->getValue();
894 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
895 StringRef Mcpu = A->getValue();
896 CPU = Mcpu.split("+").first;
Tim Northovera2ee4332014-03-29 15:09:45 +0000897 }
898
Kevin Qin110db6f2014-07-18 07:03:22 +0000899 // Handle CPU name is 'native'.
900 if (CPU == "native")
901 return llvm::sys::getHostCPUName();
902 else if (CPU.size())
903 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000904
James Molloy9b1586b2014-04-17 12:51:17 +0000905 // Make sure we pick "cyclone" if -arch is used.
906 // FIXME: Should this be picked by checking the target triple instead?
907 if (Args.getLastArg(options::OPT_arch))
908 return "cyclone";
909
910 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000911}
912
Tim Northover573cbee2014-05-24 12:52:07 +0000913void Clang::AddAArch64TargetArgs(const ArgList &Args,
914 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000915 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
916 llvm::Triple Triple(TripleStr);
917
918 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
919 Args.hasArg(options::OPT_mkernel) ||
920 Args.hasArg(options::OPT_fapple_kext))
921 CmdArgs.push_back("-disable-red-zone");
922
923 if (!Args.hasFlag(options::OPT_mimplicit_float,
924 options::OPT_mno_implicit_float, true))
925 CmdArgs.push_back("-no-implicit-float");
926
Craig Topper92fc2df2014-05-17 16:56:41 +0000927 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000928 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
929 ABIName = A->getValue();
930 else if (Triple.isOSDarwin())
931 ABIName = "darwinpcs";
932 else
933 ABIName = "aapcs";
934
935 CmdArgs.push_back("-target-abi");
936 CmdArgs.push_back(ABIName);
937
Bob Wilson0874e532014-07-29 00:23:18 +0000938 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
939 options::OPT_munaligned_access)) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000940 CmdArgs.push_back("-backend-option");
Bob Wilson0874e532014-07-29 00:23:18 +0000941 if (A->getOption().matches(options::OPT_mno_unaligned_access))
942 CmdArgs.push_back("-aarch64-strict-align");
943 else
944 CmdArgs.push_back("-aarch64-no-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000945 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000946
Bradley Smith9ff64332014-10-13 10:16:06 +0000947 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
948 options::OPT_mno_fix_cortex_a53_835769)) {
949 CmdArgs.push_back("-backend-option");
950 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
951 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
952 else
953 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Bradley Smith04ee8aa2014-10-16 16:35:14 +0000954 } else if (Triple.getEnvironment() == llvm::Triple::Android) {
955 // Enabled A53 errata (835769) workaround by default on android
956 CmdArgs.push_back("-backend-option");
957 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +0000958 }
959
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000960 // Setting -mno-global-merge disables the codegen global merge pass. Setting
961 // -mglobal-merge has no effect as the pass is enabled by default.
962 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
963 options::OPT_mno_global_merge)) {
964 if (A->getOption().matches(options::OPT_mno_global_merge))
965 CmdArgs.push_back("-mno-global-merge");
966 }
Renato Golinb625f482015-01-25 23:17:48 +0000967
968 if (Args.hasArg(options::OPT_ffixed_x18)) {
969 CmdArgs.push_back("-backend-option");
970 CmdArgs.push_back("-aarch64-reserve-x18");
971 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000972}
973
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000974// Get CPU and ABI names. They are not independent
975// so we have to calculate them together.
Simon Atanasyan7018e1d2014-07-16 12:29:22 +0000976void mips::getMipsCPUAndABI(const ArgList &Args,
977 const llvm::Triple &Triple,
978 StringRef &CPUName,
979 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000980 const char *DefMips32CPU = "mips32r2";
981 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000982
Daniel Sanders2bf13662014-07-10 14:40:57 +0000983 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
984 // default for mips64(el)?-img-linux-gnu.
985 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
986 Triple.getEnvironment() == llvm::Triple::GNU) {
987 DefMips32CPU = "mips32r6";
988 DefMips64CPU = "mips64r6";
989 }
990
Brad Smithba26f582015-01-06 02:53:17 +0000991 // MIPS3 is the default for mips64*-unknown-openbsd.
992 if (Triple.getOS() == llvm::Triple::OpenBSD)
993 DefMips64CPU = "mips3";
994
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000995 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000996 options::OPT_mcpu_EQ))
997 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000998
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000999 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001000 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001001 // Convert a GNU style Mips ABI name to the name
1002 // accepted by LLVM Mips backend.
1003 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
1004 .Case("32", "o32")
1005 .Case("64", "n64")
1006 .Default(ABIName);
1007 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001008
1009 // Setup default CPU and ABI names.
1010 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001011 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001012 default:
1013 llvm_unreachable("Unexpected triple arch name");
1014 case llvm::Triple::mips:
1015 case llvm::Triple::mipsel:
1016 CPUName = DefMips32CPU;
1017 break;
1018 case llvm::Triple::mips64:
1019 case llvm::Triple::mips64el:
1020 CPUName = DefMips64CPU;
1021 break;
1022 }
1023 }
1024
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001025 if (ABIName.empty()) {
1026 // Deduce ABI name from the target triple.
1027 if (Triple.getArch() == llvm::Triple::mips ||
1028 Triple.getArch() == llvm::Triple::mipsel)
1029 ABIName = "o32";
1030 else
1031 ABIName = "n64";
1032 }
1033
1034 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001035 // Deduce CPU name from ABI name.
1036 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyanad805952014-07-01 10:59:09 +00001037 .Cases("o32", "eabi", DefMips32CPU)
1038 .Cases("n32", "n64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001039 .Default("");
1040 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001041
1042 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001043}
1044
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001045// Convert ABI name to the GNU tools acceptable variant.
1046static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1047 return llvm::StringSwitch<llvm::StringRef>(ABI)
1048 .Case("o32", "32")
1049 .Case("n64", "64")
1050 .Default(ABI);
1051}
1052
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001053// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1054// and -mfloat-abi=.
1055static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001056 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +00001057 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001058 options::OPT_mhard_float,
1059 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001060 if (A->getOption().matches(options::OPT_msoft_float))
1061 FloatABI = "soft";
1062 else if (A->getOption().matches(options::OPT_mhard_float))
1063 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001064 else {
Richard Smithbd55daf2012-11-01 04:30:05 +00001065 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +00001066 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001067 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001068 FloatABI = "hard";
1069 }
1070 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001071 }
1072
1073 // If unspecified, choose the default based on the platform.
1074 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001075 // Assume "hard", because it's a default value used by gcc.
1076 // When we start to recognize specific target MIPS processors,
1077 // we will be able to select the default more correctly.
1078 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001079 }
1080
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001081 return FloatABI;
1082}
1083
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001084static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001085 std::vector<const char *> &Features,
1086 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001087 StringRef FeatureName) {
1088 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001089 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001090 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001091 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001092 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001093 }
1094}
1095
Daniel Sanders379d44b2014-07-16 11:52:23 +00001096static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1097 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001098 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001099 StringRef CPUName;
1100 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001101 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001102 ABIName = getGnuCompatibleMipsABIName(ABIName);
1103
Daniel Sandersfeb61302014-08-08 15:47:17 +00001104 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1105 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001106
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001107 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001108 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001109 // FIXME: Note, this is a hack. We need to pass the selected float
1110 // mode to the MipsTargetInfoBase to define appropriate macros there.
1111 // Now it is the only method.
1112 Features.push_back("+soft-float");
1113 }
1114
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001115 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001116 StringRef Val = StringRef(A->getValue());
1117 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001118 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001119 else if (Val == "legacy")
1120 Features.push_back("-nan2008");
1121 else
1122 D.Diag(diag::err_drv_unsupported_option_argument)
1123 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001124 }
1125
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001126 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1127 options::OPT_mdouble_float, "single-float");
1128 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1129 "mips16");
1130 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1131 options::OPT_mno_micromips, "micromips");
1132 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1133 "dsp");
1134 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1135 "dspr2");
1136 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1137 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001138
1139 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1140 // pass -mfpxx
1141 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1142 options::OPT_mfp64)) {
1143 if (A->getOption().matches(options::OPT_mfp32))
1144 Features.push_back(Args.MakeArgString("-fp64"));
1145 else if (A->getOption().matches(options::OPT_mfpxx)) {
1146 Features.push_back(Args.MakeArgString("+fpxx"));
1147 Features.push_back(Args.MakeArgString("+nooddspreg"));
1148 } else
1149 Features.push_back(Args.MakeArgString("+fp64"));
1150 } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001151 Features.push_back(Args.MakeArgString("+fpxx"));
1152 Features.push_back(Args.MakeArgString("+nooddspreg"));
1153 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001154
Daniel Sanders28e5d392014-07-10 10:39:51 +00001155 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1156 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001157}
1158
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001159void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001160 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001161 const Driver &D = getToolChain().getDriver();
1162 StringRef CPUName;
1163 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001164 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001165 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001166
1167 CmdArgs.push_back("-target-abi");
1168 CmdArgs.push_back(ABIName.data());
1169
1170 StringRef FloatABI = getMipsFloatABI(D, Args);
1171
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001172 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001173 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001174 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001175 CmdArgs.push_back("-mfloat-abi");
1176 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001177 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001178 else {
1179 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001180 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001181 CmdArgs.push_back("-mfloat-abi");
1182 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001183 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001184
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001185 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1186 if (A->getOption().matches(options::OPT_mxgot)) {
1187 CmdArgs.push_back("-mllvm");
1188 CmdArgs.push_back("-mxgot");
1189 }
1190 }
1191
Simon Atanasyanc580b322013-05-11 06:33:44 +00001192 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1193 options::OPT_mno_ldc1_sdc1)) {
1194 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1195 CmdArgs.push_back("-mllvm");
1196 CmdArgs.push_back("-mno-ldc1-sdc1");
1197 }
1198 }
1199
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001200 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1201 options::OPT_mno_check_zero_division)) {
1202 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1203 CmdArgs.push_back("-mllvm");
1204 CmdArgs.push_back("-mno-check-zero-division");
1205 }
1206 }
1207
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001208 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001209 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001210 CmdArgs.push_back("-mllvm");
1211 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1212 A->claim();
1213 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001214}
1215
Hal Finkel8eb59282012-06-11 22:35:19 +00001216/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1217static std::string getPPCTargetCPU(const ArgList &Args) {
1218 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001219 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001220
1221 if (CPUName == "native") {
1222 std::string CPU = llvm::sys::getHostCPUName();
1223 if (!CPU.empty() && CPU != "generic")
1224 return CPU;
1225 else
1226 return "";
1227 }
1228
1229 return llvm::StringSwitch<const char *>(CPUName)
1230 .Case("common", "generic")
1231 .Case("440", "440")
1232 .Case("440fp", "440")
1233 .Case("450", "450")
1234 .Case("601", "601")
1235 .Case("602", "602")
1236 .Case("603", "603")
1237 .Case("603e", "603e")
1238 .Case("603ev", "603ev")
1239 .Case("604", "604")
1240 .Case("604e", "604e")
1241 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001242 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001243 .Case("G3", "g3")
1244 .Case("7400", "7400")
1245 .Case("G4", "g4")
1246 .Case("7450", "7450")
1247 .Case("G4+", "g4+")
1248 .Case("750", "750")
1249 .Case("970", "970")
1250 .Case("G5", "g5")
1251 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001252 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001253 .Case("e500mc", "e500mc")
1254 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001255 .Case("power3", "pwr3")
1256 .Case("power4", "pwr4")
1257 .Case("power5", "pwr5")
1258 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001259 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001260 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001261 .Case("power7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001262 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001263 .Case("pwr3", "pwr3")
1264 .Case("pwr4", "pwr4")
1265 .Case("pwr5", "pwr5")
1266 .Case("pwr5x", "pwr5x")
1267 .Case("pwr6", "pwr6")
1268 .Case("pwr6x", "pwr6x")
1269 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001270 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001271 .Case("powerpc", "ppc")
1272 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001273 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001274 .Default("");
1275 }
1276
1277 return "";
1278}
1279
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001280static void getPPCTargetFeatures(const ArgList &Args,
1281 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001282 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1283 ie = Args.filtered_end();
1284 it != ie; ++it) {
1285 StringRef Name = (*it)->getOption().getName();
1286 (*it)->claim();
1287
1288 // Skip over "-m".
1289 assert(Name.startswith("m") && "Invalid feature name.");
1290 Name = Name.substr(1);
1291
1292 bool IsNegative = Name.startswith("no-");
1293 if (IsNegative)
1294 Name = Name.substr(3);
1295
1296 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1297 // pass the correct option to the backend while calling the frontend
1298 // option the same.
1299 // TODO: Change the LLVM backend option maybe?
1300 if (Name == "mfcrf")
1301 Name = "mfocrf";
1302
1303 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1304 }
1305
1306 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001307 AddTargetFeature(Args, Features, options::OPT_faltivec,
1308 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001309}
1310
Ulrich Weigand8afad612014-07-28 13:17:52 +00001311void Clang::AddPPCTargetArgs(const ArgList &Args,
1312 ArgStringList &CmdArgs) const {
1313 // Select the ABI to use.
1314 const char *ABIName = nullptr;
1315 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1316 ABIName = A->getValue();
1317 } else if (getToolChain().getTriple().isOSLinux())
1318 switch(getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001319 case llvm::Triple::ppc64: {
1320 // When targeting a processor that supports QPX, or if QPX is
1321 // specifically enabled, default to using the ABI that supports QPX (so
1322 // long as it is not specifically disabled).
1323 bool HasQPX = false;
1324 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1325 HasQPX = A->getValue() == StringRef("a2q");
1326 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1327 if (HasQPX) {
1328 ABIName = "elfv1-qpx";
1329 break;
1330 }
1331
Ulrich Weigand8afad612014-07-28 13:17:52 +00001332 ABIName = "elfv1";
1333 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001334 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001335 case llvm::Triple::ppc64le:
1336 ABIName = "elfv2";
1337 break;
1338 default:
1339 break;
1340 }
1341
1342 if (ABIName) {
1343 CmdArgs.push_back("-target-abi");
1344 CmdArgs.push_back(ABIName);
1345 }
1346}
1347
1348bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1349 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1350 return A && (A->getValue() == StringRef(Value));
1351}
1352
Tom Stellard6674c702013-04-01 20:56:53 +00001353/// Get the (LLVM) name of the R600 gpu we are targeting.
1354static std::string getR600TargetGPU(const ArgList &Args) {
1355 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001356 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001357 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001358 .Cases("rv630", "rv635", "r600")
1359 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001360 .Case("rv740", "rv770")
1361 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001362 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001363 .Case("hemlock", "cypress")
1364 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001365 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001366 }
1367 return "";
1368}
1369
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001370static void getSparcTargetFeatures(const ArgList &Args,
Brad Smithf436e9e2014-08-19 21:50:15 +00001371 std::vector<const char *> &Features) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001372 bool SoftFloatABI = true;
1373 if (Arg *A =
1374 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1375 if (A->getOption().matches(options::OPT_mhard_float))
1376 SoftFloatABI = false;
1377 }
1378 if (SoftFloatABI)
1379 Features.push_back("+soft-float");
1380}
1381
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001382void Clang::AddSparcTargetArgs(const ArgList &Args,
1383 ArgStringList &CmdArgs) const {
1384 const Driver &D = getToolChain().getDriver();
1385
Brad Smith10cd0f42014-07-11 20:12:08 +00001386 // Select the float ABI as determined by -msoft-float and -mhard-float.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001387 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001388 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1389 options::OPT_mhard_float)) {
1390 if (A->getOption().matches(options::OPT_msoft_float))
1391 FloatABI = "soft";
1392 else if (A->getOption().matches(options::OPT_mhard_float))
1393 FloatABI = "hard";
1394 }
1395
1396 // If unspecified, choose the default based on the platform.
1397 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001398 // Assume "soft", but warn the user we are guessing.
1399 FloatABI = "soft";
1400 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001401 }
1402
1403 if (FloatABI == "soft") {
1404 // Floating point operations and argument passing are soft.
1405 //
1406 // FIXME: This changes CPP defines, we need -target-soft-float.
1407 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001408 } else {
1409 assert(FloatABI == "hard" && "Invalid float abi!");
1410 CmdArgs.push_back("-mhard-float");
1411 }
1412}
1413
Richard Sandiford4652d892013-07-19 16:51:51 +00001414static const char *getSystemZTargetCPU(const ArgList &Args) {
1415 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1416 return A->getValue();
1417 return "z10";
1418}
1419
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001420static void getSystemZTargetFeatures(const ArgList &Args,
1421 std::vector<const char *> &Features) {
1422 // -m(no-)htm overrides use of the transactional-execution facility.
1423 if (Arg *A = Args.getLastArg(options::OPT_mhtm,
1424 options::OPT_mno_htm)) {
1425 if (A->getOption().matches(options::OPT_mhtm))
1426 Features.push_back("+transactional-execution");
1427 else
1428 Features.push_back("-transactional-execution");
1429 }
1430}
1431
Chandler Carruth953fb082013-01-13 11:46:33 +00001432static const char *getX86TargetCPU(const ArgList &Args,
1433 const llvm::Triple &Triple) {
1434 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001435 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001436 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001437 return "core-avx2";
1438
Chandler Carruth953fb082013-01-13 11:46:33 +00001439 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001440 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001441
1442 // FIXME: Reject attempts to use -march=native unless the target matches
1443 // the host.
1444 //
1445 // FIXME: We should also incorporate the detected target features for use
1446 // with -native.
1447 std::string CPU = llvm::sys::getHostCPUName();
1448 if (!CPU.empty() && CPU != "generic")
1449 return Args.MakeArgString(CPU);
1450 }
1451
1452 // Select the default CPU if none was given (or detection failed).
1453
1454 if (Triple.getArch() != llvm::Triple::x86_64 &&
1455 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001456 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001457
1458 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1459
1460 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001461 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001462 if (Triple.getArchName() == "x86_64h")
1463 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001464 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001465 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001466
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001467 // Set up default CPU name for PS4 compilers.
1468 if (Triple.isPS4CPU())
1469 return "btver2";
1470
Alexey Bataev286d1b92014-01-31 04:07:13 +00001471 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001472 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001473 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001474
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001475 // Everything else goes to x86-64 in 64-bit mode.
1476 if (Is64Bit)
1477 return "x86-64";
1478
1479 switch (Triple.getOS()) {
1480 case llvm::Triple::FreeBSD:
1481 case llvm::Triple::NetBSD:
1482 case llvm::Triple::OpenBSD:
1483 return "i486";
1484 case llvm::Triple::Haiku:
1485 return "i586";
1486 case llvm::Triple::Bitrig:
1487 return "i686";
1488 default:
1489 // Fallback to p4.
1490 return "pentium4";
1491 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001492}
1493
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001494static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1495 switch(T.getArch()) {
1496 default:
1497 return "";
1498
Amara Emerson703da2e2013-10-31 09:32:33 +00001499 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001500 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001501 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001502
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001503 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001504 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001505 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001506 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001507 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001508
1509 case llvm::Triple::mips:
1510 case llvm::Triple::mipsel:
1511 case llvm::Triple::mips64:
1512 case llvm::Triple::mips64el: {
1513 StringRef CPUName;
1514 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001515 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001516 return CPUName;
1517 }
1518
1519 case llvm::Triple::ppc:
1520 case llvm::Triple::ppc64:
1521 case llvm::Triple::ppc64le: {
1522 std::string TargetCPUName = getPPCTargetCPU(Args);
1523 // LLVM may default to generating code for the native CPU,
1524 // but, like gcc, we default to a more generic option for
1525 // each architecture. (except on Darwin)
1526 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1527 if (T.getArch() == llvm::Triple::ppc64)
1528 TargetCPUName = "ppc64";
1529 else if (T.getArch() == llvm::Triple::ppc64le)
1530 TargetCPUName = "ppc64le";
1531 else
1532 TargetCPUName = "ppc";
1533 }
1534 return TargetCPUName;
1535 }
1536
1537 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001538 case llvm::Triple::sparcv9:
1539 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001540 return A->getValue();
1541 return "";
1542
1543 case llvm::Triple::x86:
1544 case llvm::Triple::x86_64:
1545 return getX86TargetCPU(Args, T);
1546
1547 case llvm::Triple::hexagon:
1548 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1549
1550 case llvm::Triple::systemz:
1551 return getSystemZTargetCPU(Args);
1552
1553 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001554 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001555 return getR600TargetGPU(Args);
1556 }
1557}
1558
Alp Tokerce365ca2013-12-02 12:43:03 +00001559static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1560 ArgStringList &CmdArgs) {
1561 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1562 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1563 // forward.
1564 CmdArgs.push_back("-plugin");
Rafael Espindola3e34e652015-02-03 16:33:53 +00001565 std::string Plugin = ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001566 CmdArgs.push_back(Args.MakeArgString(Plugin));
1567
1568 // Try to pass driver level flags relevant to LTO code generation down to
1569 // the plugin.
1570
1571 // Handle flags for selecting CPU variants.
1572 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1573 if (!CPU.empty())
1574 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1575}
1576
Eric Christopherc54920a2015-03-23 19:26:05 +00001577static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001578 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001579 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001580 // If -march=native, autodetect the feature list.
1581 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1582 if (StringRef(A->getValue()) == "native") {
1583 llvm::StringMap<bool> HostFeatures;
1584 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1585 for (auto &F : HostFeatures)
1586 Features.push_back(Args.MakeArgString((F.second ? "+" : "-") +
1587 F.first()));
1588 }
1589 }
1590
Jim Grosbach82eee262013-11-16 00:53:35 +00001591 if (Triple.getArchName() == "x86_64h") {
1592 // x86_64h implies quite a few of the more modern subtarget features
1593 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1594 Features.push_back("-rdrnd");
1595 Features.push_back("-aes");
1596 Features.push_back("-pclmul");
1597 Features.push_back("-rtm");
1598 Features.push_back("-hle");
1599 Features.push_back("-fsgsbase");
1600 }
1601
Eric Christopherc54920a2015-03-23 19:26:05 +00001602 // Add features to be compatible with gcc for Android.
Alexey Bataev286d1b92014-01-31 04:07:13 +00001603 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001604 if (Triple.getArch() == llvm::Triple::x86_64) {
1605 Features.push_back("+sse4.2");
1606 Features.push_back("+popcnt");
1607 } else
1608 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001609 }
1610
Eric Christopherc54920a2015-03-23 19:26:05 +00001611 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001612 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1613 StringRef Arch = A->getValue();
1614 bool ArchUsed = false;
1615 // First, look for flags that are shared in x86 and x86-64.
1616 if (Triple.getArch() == llvm::Triple::x86_64 ||
1617 Triple.getArch() == llvm::Triple::x86) {
1618 if (Arch == "AVX" || Arch == "AVX2") {
1619 ArchUsed = true;
1620 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1621 }
1622 }
1623 // Then, look for x86-specific flags.
1624 if (Triple.getArch() == llvm::Triple::x86) {
1625 if (Arch == "IA32") {
1626 ArchUsed = true;
1627 } else if (Arch == "SSE" || Arch == "SSE2") {
1628 ArchUsed = true;
1629 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1630 }
1631 }
1632 if (!ArchUsed)
1633 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1634 }
1635
Jim Grosbach82eee262013-11-16 00:53:35 +00001636 // Now add any that the user explicitly requested on the command line,
1637 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001638 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1639 ie = Args.filtered_end();
1640 it != ie; ++it) {
1641 StringRef Name = (*it)->getOption().getName();
1642 (*it)->claim();
1643
1644 // Skip over "-m".
1645 assert(Name.startswith("m") && "Invalid feature name.");
1646 Name = Name.substr(1);
1647
1648 bool IsNegative = Name.startswith("no-");
1649 if (IsNegative)
1650 Name = Name.substr(3);
1651
1652 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1653 }
1654}
1655
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001656void Clang::AddX86TargetArgs(const ArgList &Args,
1657 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001658 if (!Args.hasFlag(options::OPT_mred_zone,
1659 options::OPT_mno_red_zone,
1660 true) ||
1661 Args.hasArg(options::OPT_mkernel) ||
1662 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001663 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001664
Bob Wilson2616e2e2013-02-10 16:01:41 +00001665 // Default to avoid implicit floating-point for kernel/kext code, but allow
1666 // that to be overridden with -mno-soft-float.
1667 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1668 Args.hasArg(options::OPT_fapple_kext));
1669 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1670 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001671 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001672 options::OPT_mno_implicit_float)) {
1673 const Option &O = A->getOption();
1674 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1675 O.matches(options::OPT_msoft_float));
1676 }
1677 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001678 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001679
1680 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1681 StringRef Value = A->getValue();
1682 if (Value == "intel" || Value == "att") {
1683 CmdArgs.push_back("-mllvm");
1684 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1685 } else {
1686 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1687 << A->getOption().getName() << Value;
1688 }
1689 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001690}
1691
Matthew Curtise8f80a12012-12-06 17:49:03 +00001692static inline bool HasPICArg(const ArgList &Args) {
1693 return Args.hasArg(options::OPT_fPIC)
1694 || Args.hasArg(options::OPT_fpic);
1695}
1696
1697static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1698 return Args.getLastArg(options::OPT_G,
1699 options::OPT_G_EQ,
1700 options::OPT_msmall_data_threshold_EQ);
1701}
1702
1703static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1704 std::string value;
1705 if (HasPICArg(Args))
1706 value = "0";
1707 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1708 value = A->getValue();
1709 A->claim();
1710 }
1711 return value;
1712}
1713
Tony Linthicum76329bf2011-12-12 21:14:55 +00001714void Clang::AddHexagonTargetArgs(const ArgList &Args,
1715 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001716 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001717 CmdArgs.push_back("-mqdsp6-compat");
1718 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001719
Matthew Curtise8f80a12012-12-06 17:49:03 +00001720 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1721 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001722 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001723 CmdArgs.push_back(Args.MakeArgString(
1724 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001725 }
1726
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001727 if (!Args.hasArg(options::OPT_fno_short_enums))
1728 CmdArgs.push_back("-fshort-enums");
1729 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1730 CmdArgs.push_back ("-mllvm");
1731 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1732 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001733 CmdArgs.push_back ("-mllvm");
1734 CmdArgs.push_back ("-machine-sink-split=0");
1735}
1736
Kevin Qin110db6f2014-07-18 07:03:22 +00001737// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001738static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001739 std::vector<const char *> &Features) {
1740 SmallVector<StringRef, 8> Split;
1741 text.split(Split, StringRef("+"), -1, false);
1742
1743 for (unsigned I = 0, E = Split.size(); I != E; ++I) {
1744 const char *result = llvm::StringSwitch<const char *>(Split[I])
1745 .Case("fp", "+fp-armv8")
1746 .Case("simd", "+neon")
1747 .Case("crc", "+crc")
1748 .Case("crypto", "+crypto")
1749 .Case("nofp", "-fp-armv8")
1750 .Case("nosimd", "-neon")
1751 .Case("nocrc", "-crc")
1752 .Case("nocrypto", "-crypto")
1753 .Default(nullptr);
1754 if (result)
1755 Features.push_back(result);
1756 else if (Split[I] == "neon" || Split[I] == "noneon")
1757 D.Diag(diag::err_drv_no_neon_modifier);
1758 else
1759 return false;
1760 }
1761 return true;
1762}
1763
1764// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1765// decode CPU and feature.
1766static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1767 std::vector<const char *> &Features) {
1768 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1769 CPU = Split.first;
Renato Golin84545d72015-02-04 13:31:56 +00001770 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00001771 Features.push_back("+neon");
1772 Features.push_back("+crc");
1773 Features.push_back("+crypto");
1774 } else if (CPU == "generic") {
1775 Features.push_back("+neon");
1776 } else {
1777 return false;
1778 }
1779
1780 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1781 return false;
1782
1783 return true;
1784}
1785
1786static bool
1787getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1788 const ArgList &Args,
1789 std::vector<const char *> &Features) {
1790 std::pair<StringRef, StringRef> Split = March.split("+");
1791 if (Split.first != "armv8-a")
1792 return false;
1793
1794 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1795 return false;
1796
1797 return true;
1798}
1799
1800static bool
1801getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1802 const ArgList &Args,
1803 std::vector<const char *> &Features) {
1804 StringRef CPU;
1805 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
1806 return false;
1807
1808 return true;
1809}
1810
1811static bool
1812getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1813 const ArgList &Args,
1814 std::vector<const char *> &Features) {
1815 // Handle CPU name is 'native'.
1816 if (Mtune == "native")
1817 Mtune = llvm::sys::getHostCPUName();
1818 if (Mtune == "cyclone") {
1819 Features.push_back("+zcm");
1820 Features.push_back("+zcz");
1821 }
1822 return true;
1823}
1824
1825static bool
1826getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1827 const ArgList &Args,
1828 std::vector<const char *> &Features) {
1829 StringRef CPU;
1830 std::vector<const char *> DecodedFeature;
1831 if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
1832 return false;
1833
1834 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1835}
1836
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001837static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1838 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001839 Arg *A;
1840 bool success = true;
1841 // Enable NEON by default.
1842 Features.push_back("+neon");
1843 if ((A = Args.getLastArg(options::OPT_march_EQ)))
1844 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1845 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1846 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001847 else if (Args.hasArg(options::OPT_arch))
1848 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1849 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001850
1851 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1852 success =
1853 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1854 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1855 success =
1856 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00001857 else if (Args.hasArg(options::OPT_arch))
1858 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1859 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00001860
1861 if (!success)
1862 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001863
1864 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1865 Features.push_back("-fp-armv8");
1866 Features.push_back("-crypto");
1867 Features.push_back("-neon");
1868 }
Bradley Smith418c5932014-05-02 15:17:51 +00001869
1870 // En/disable crc
1871 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1872 options::OPT_mnocrc)) {
1873 if (A->getOption().matches(options::OPT_mcrc))
1874 Features.push_back("+crc");
1875 else
1876 Features.push_back("-crc");
1877 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001878}
1879
1880static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001881 const ArgList &Args, ArgStringList &CmdArgs,
1882 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001883 std::vector<const char *> Features;
1884 switch (Triple.getArch()) {
1885 default:
1886 break;
1887 case llvm::Triple::mips:
1888 case llvm::Triple::mipsel:
1889 case llvm::Triple::mips64:
1890 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00001891 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001892 break;
1893
1894 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001895 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001896 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001897 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001898 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001899 break;
1900
1901 case llvm::Triple::ppc:
1902 case llvm::Triple::ppc64:
1903 case llvm::Triple::ppc64le:
1904 getPPCTargetFeatures(Args, Features);
1905 break;
1906 case llvm::Triple::sparc:
Brad Smithf436e9e2014-08-19 21:50:15 +00001907 case llvm::Triple::sparcv9:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001908 getSparcTargetFeatures(Args, Features);
1909 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001910 case llvm::Triple::systemz:
1911 getSystemZTargetFeatures(Args, Features);
1912 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001913 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001914 case llvm::Triple::aarch64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001915 getAArch64TargetFeatures(D, Args, Features);
1916 break;
1917 case llvm::Triple::x86:
1918 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001919 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001920 break;
1921 }
Rafael Espindola43964802013-08-21 17:34:32 +00001922
1923 // Find the last of each feature.
1924 llvm::StringMap<unsigned> LastOpt;
1925 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1926 const char *Name = Features[I];
1927 assert(Name[0] == '-' || Name[0] == '+');
1928 LastOpt[Name + 1] = I;
1929 }
1930
1931 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1932 // If this feature was overridden, ignore it.
1933 const char *Name = Features[I];
1934 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1935 assert(LastI != LastOpt.end());
1936 unsigned Last = LastI->second;
1937 if (Last != I)
1938 continue;
1939
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001940 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001941 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001942 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001943}
1944
David Majnemerae394812014-12-09 00:12:30 +00001945static bool
1946shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1947 const llvm::Triple &Triple) {
1948 // We use the zero-cost exception tables for Objective-C if the non-fragile
1949 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1950 // later.
1951 if (runtime.isNonFragile())
1952 return true;
1953
1954 if (!Triple.isMacOSX())
1955 return false;
1956
1957 return (!Triple.isMacOSXVersionLT(10,5) &&
1958 (Triple.getArch() == llvm::Triple::x86_64 ||
1959 Triple.getArch() == llvm::Triple::arm));
1960}
1961
Nico Webere8e53112014-05-11 01:04:02 +00001962// exceptionSettings() exists to share the logic between -cc1 and linker
1963// invocations.
David Majnemer8de68642014-12-05 08:11:58 +00001964static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001965 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
David Majnemer8de68642014-12-05 08:11:58 +00001966 options::OPT_fno_exceptions))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001967 if (A->getOption().matches(options::OPT_fexceptions))
David Majnemer8de68642014-12-05 08:11:58 +00001968 return true;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001969
David Majnemer8de68642014-12-05 08:11:58 +00001970 return false;
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001971}
1972
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001973/// Adds exception related arguments to the driver command arguments. There's a
1974/// master flag, -fexceptions and also language specific flags to enable/disable
1975/// C++ and Objective-C exceptions. This makes it possible to for example
1976/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00001977static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001978 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001979 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001980 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00001981 const Driver &D = TC.getDriver();
1982 const llvm::Triple &Triple = TC.getTriple();
1983
Chad Rosier4fab82c2012-03-26 22:04:46 +00001984 if (KernelOrKext) {
1985 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1986 // arguments now to avoid warnings about unused arguments.
1987 Args.ClaimAllArgs(options::OPT_fexceptions);
1988 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1989 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1990 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1991 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1992 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001993 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001994 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001995
David Majnemer8de68642014-12-05 08:11:58 +00001996 // Gather the exception settings from the command line arguments.
1997 bool EH = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001998
David Majnemerae394812014-12-09 00:12:30 +00001999 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2000 // is not necessarily sensible, but follows GCC.
2001 if (types::isObjC(InputType) &&
2002 Args.hasFlag(options::OPT_fobjc_exceptions,
2003 options::OPT_fno_objc_exceptions,
2004 true)) {
2005 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002006
David Majnemerae394812014-12-09 00:12:30 +00002007 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002008 }
2009
2010 if (types::isCXX(InputType)) {
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00002011 bool CXXExceptionsEnabled =
2012 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002013 Arg *ExceptionArg = Args.getLastArg(
2014 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2015 options::OPT_fexceptions, options::OPT_fno_exceptions);
2016 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002017 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002018 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2019 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002020
2021 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002022 if (Triple.isPS4CPU()) {
2023 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2024 assert(ExceptionArg &&
2025 "On the PS4 exceptions should only be enabled if passing "
2026 "an argument");
2027 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2028 const Arg *RTTIArg = TC.getRTTIArg();
2029 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2030 D.Diag(diag::err_drv_argument_not_allowed_with)
2031 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2032 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2033 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2034 } else
2035 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2036
Anders Carlssone96ab552011-02-28 02:27:16 +00002037 CmdArgs.push_back("-fcxx-exceptions");
2038
David Majnemer8de68642014-12-05 08:11:58 +00002039 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002040 }
2041 }
2042
David Majnemer8de68642014-12-05 08:11:58 +00002043 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002044 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002045}
2046
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002047static bool ShouldDisableAutolink(const ArgList &Args,
2048 const ToolChain &TC) {
2049 bool Default = true;
2050 if (TC.getTriple().isOSDarwin()) {
2051 // The native darwin assembler doesn't support the linker_option directives,
2052 // so we disable them if we think the .s file will be passed to it.
2053 Default = TC.useIntegratedAs();
2054 }
2055 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2056 Default);
2057}
2058
Ted Kremenek62093662013-03-12 17:02:12 +00002059static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2060 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002061 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
2062 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00002063 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002064 return !UseDwarfDirectory;
2065}
2066
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002067/// \brief Check whether the given input tree contains any compilation actions.
2068static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002069 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002070 return true;
2071
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002072 for (const auto &Act : *A)
2073 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002074 return true;
2075
2076 return false;
2077}
2078
2079/// \brief Check if -relax-all should be passed to the internal assembler.
2080/// This is done by default when compiling non-assembler source with -O0.
2081static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2082 bool RelaxDefault = true;
2083
2084 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2085 RelaxDefault = A->getOption().matches(options::OPT_O0);
2086
2087 if (RelaxDefault) {
2088 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002089 for (const auto &Act : C.getActions()) {
2090 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002091 RelaxDefault = true;
2092 break;
2093 }
2094 }
2095 }
2096
2097 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2098 RelaxDefault);
2099}
2100
David Blaikie9260ed62013-07-25 21:19:01 +00002101static void CollectArgsForIntegratedAssembler(Compilation &C,
2102 const ArgList &Args,
2103 ArgStringList &CmdArgs,
2104 const Driver &D) {
2105 if (UseRelaxAll(C, Args))
2106 CmdArgs.push_back("-mrelax-all");
2107
David Peixottodfb66142013-11-14 22:52:58 +00002108 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00002109 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00002110 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2111 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2112 // arg after parsing the '-I' arg.
2113 bool TakeNextArg = false;
2114
David Blaikie9260ed62013-07-25 21:19:01 +00002115 // When using an integrated assembler, translate -Wa, and -Xassembler
2116 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00002117 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00002118 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
2119 options::OPT_Xassembler),
2120 ie = Args.filtered_end(); it != ie; ++it) {
2121 const Arg *A = *it;
2122 A->claim();
2123
2124 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
2125 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00002126 if (TakeNextArg) {
2127 CmdArgs.push_back(Value.data());
2128 TakeNextArg = false;
2129 continue;
2130 }
David Blaikie9260ed62013-07-25 21:19:01 +00002131
2132 if (Value == "-force_cpusubtype_ALL") {
2133 // Do nothing, this is the default and we don't support anything else.
2134 } else if (Value == "-L") {
2135 CmdArgs.push_back("-msave-temp-labels");
2136 } else if (Value == "--fatal-warnings") {
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +00002137 CmdArgs.push_back("-massembler-fatal-warnings");
David Blaikie9260ed62013-07-25 21:19:01 +00002138 } else if (Value == "--noexecstack") {
2139 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00002140 } else if (Value == "-compress-debug-sections" ||
2141 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00002142 CompressDebugSections = true;
2143 } else if (Value == "-nocompress-debug-sections" ||
2144 Value == "--nocompress-debug-sections") {
2145 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00002146 } else if (Value.startswith("-I")) {
2147 CmdArgs.push_back(Value.data());
2148 // We need to consume the next argument if the current arg is a plain
2149 // -I. The next arg will be the include directory.
2150 if (Value == "-I")
2151 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00002152 } else if (Value.startswith("-gdwarf-")) {
2153 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00002154 } else {
2155 D.Diag(diag::err_drv_unsupported_option_argument)
2156 << A->getOption().getName() << Value;
2157 }
2158 }
2159 }
David Blaikie24bbfed22014-03-31 23:29:38 +00002160 if (CompressDebugSections) {
2161 if (llvm::zlib::isAvailable())
2162 CmdArgs.push_back("-compress-debug-sections");
2163 else
2164 D.Diag(diag::warn_debug_compression_unavailable);
2165 }
David Blaikie9260ed62013-07-25 21:19:01 +00002166}
2167
Renato Goline807c122014-01-31 11:47:28 +00002168// Until ARM libraries are build separately, we have them all in one library
2169static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Saleem Abdulrasool61770ab2015-01-02 21:47:33 +00002170 // FIXME: handle 64-bit
2171 if (TC.getTriple().isOSWindows() &&
2172 !TC.getTriple().isWindowsItaniumEnvironment())
2173 return "i386";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002174 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00002175 return "arm";
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002176 return TC.getArchName();
Renato Goline807c122014-01-31 11:47:28 +00002177}
2178
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002179static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2180 // The runtimes are located in the OS-specific resource directory.
2181 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002182 const llvm::Triple &Triple = TC.getTriple();
2183 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002184 StringRef OSLibName =
2185 (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00002186 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002187 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00002188}
2189
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002190static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
Dan Albert6f2875d2015-01-28 23:23:36 +00002191 bool Shared = false) {
2192 const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2193 ? "-android"
2194 : "";
2195
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002196 bool IsOSWindows = TC.getTriple().isOSWindows();
2197 StringRef Arch = getArchNameForCompilerRTLib(TC);
2198 const char *Prefix = IsOSWindows ? "" : "lib";
2199 const char *Suffix =
2200 Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2201
2202 SmallString<128> Path = getCompilerRTLibDir(TC);
2203 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2204 Arch + Env + Suffix);
2205
2206 return Path;
2207}
2208
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002209// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002210// FIXME: Make sure we can also emit shared objects if they're requested
2211// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002212static void addClangRT(const ToolChain &TC, const ArgList &Args,
2213 ArgStringList &CmdArgs) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002214 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002215
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002216 if (!TC.getTriple().isOSWindows()) {
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002217 // FIXME: why do we link against gcc when we are using compiler-rt?
2218 CmdArgs.push_back("-lgcc_s");
2219 if (TC.getDriver().CCCIsCXX())
2220 CmdArgs.push_back("-lgcc_eh");
2221 }
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002222}
2223
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00002224static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2225 ArgStringList &CmdArgs) {
Justin Bogner31a4aca2014-08-07 03:14:34 +00002226 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2227 false) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002228 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002229 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00002230 Args.hasArg(options::OPT_fcreate_profile) ||
2231 Args.hasArg(options::OPT_coverage)))
2232 return;
2233
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002234 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002235}
2236
Alexey Samsonov52550342014-09-15 19:58:40 +00002237static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2238 ArgStringList &CmdArgs, StringRef Sanitizer,
2239 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002240 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002241 // whole-archive.
Alexey Samsonov52550342014-09-15 19:58:40 +00002242 if (!IsShared)
2243 CmdArgs.push_back("-whole-archive");
Dan Albert6f2875d2015-01-28 23:23:36 +00002244 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
Alexey Samsonov52550342014-09-15 19:58:40 +00002245 if (!IsShared)
2246 CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002247}
2248
Alexey Samsonov52550342014-09-15 19:58:40 +00002249// Tries to use a file with the list of dynamic symbols that need to be exported
2250// from the runtime library. Returns true if the file was found.
2251static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2252 ArgStringList &CmdArgs,
2253 StringRef Sanitizer) {
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002254 SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2255 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2256 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002257 return true;
2258 }
2259 return false;
2260}
2261
2262static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2263 ArgStringList &CmdArgs) {
2264 // Force linking against the system libraries sanitizers depends on
2265 // (see PR15823 why this is necessary).
2266 CmdArgs.push_back("--no-as-needed");
2267 CmdArgs.push_back("-lpthread");
2268 CmdArgs.push_back("-lrt");
2269 CmdArgs.push_back("-lm");
2270 // There's no libdl on FreeBSD.
2271 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2272 CmdArgs.push_back("-ldl");
2273}
2274
2275static void
2276collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2277 SmallVectorImpl<StringRef> &SharedRuntimes,
2278 SmallVectorImpl<StringRef> &StaticRuntimes,
2279 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2280 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2281 // Collect shared runtimes.
2282 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2283 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002284 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002285
Alexey Samsonov52550342014-09-15 19:58:40 +00002286 // Collect static runtimes.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002287 if (Args.hasArg(options::OPT_shared) ||
Alexey Samsonov52550342014-09-15 19:58:40 +00002288 (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2289 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002290 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002291 }
2292 if (SanArgs.needsAsanRt()) {
2293 if (SanArgs.needsSharedAsanRt()) {
2294 HelperStaticRuntimes.push_back("asan-preinit");
2295 } else {
2296 StaticRuntimes.push_back("asan");
2297 if (SanArgs.linkCXXRuntimes())
2298 StaticRuntimes.push_back("asan_cxx");
2299 }
2300 }
2301 if (SanArgs.needsDfsanRt())
2302 StaticRuntimes.push_back("dfsan");
2303 if (SanArgs.needsLsanRt())
2304 StaticRuntimes.push_back("lsan");
2305 if (SanArgs.needsMsanRt())
2306 StaticRuntimes.push_back("msan");
2307 if (SanArgs.needsTsanRt())
2308 StaticRuntimes.push_back("tsan");
Alexey Samsonov52550342014-09-15 19:58:40 +00002309 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002310 StaticRuntimes.push_back("ubsan_standalone");
2311 if (SanArgs.linkCXXRuntimes())
2312 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002313 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002314}
2315
Alexey Samsonov52550342014-09-15 19:58:40 +00002316// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2317// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2318static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002319 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002320 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2321 HelperStaticRuntimes;
2322 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2323 HelperStaticRuntimes);
2324 for (auto RT : SharedRuntimes)
2325 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2326 for (auto RT : HelperStaticRuntimes)
2327 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2328 bool AddExportDynamic = false;
2329 for (auto RT : StaticRuntimes) {
2330 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2331 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2332 }
2333 // If there is a static runtime with no dynamic list, force all the symbols
2334 // to be dynamic to be sure we export sanitizer interface functions.
2335 if (AddExportDynamic)
2336 CmdArgs.push_back("-export-dynamic");
2337 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002338}
2339
Reid Kleckner86ea7702015-02-04 23:45:07 +00002340static bool areOptimizationsEnabled(const ArgList &Args) {
2341 // Find the last -O arg and see if it is non-zero.
2342 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2343 return !A->getOption().matches(options::OPT_O0);
2344 // Defaults to -O0.
2345 return false;
2346}
2347
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002348static bool shouldUseFramePointerForTarget(const ArgList &Args,
2349 const llvm::Triple &Triple) {
Reid Kleckner86ea7702015-02-04 23:45:07 +00002350 // XCore never wants frame pointers, regardless of OS.
2351 if (Triple.getArch() == llvm::Triple::xcore) {
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002352 return false;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002353 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002354
2355 if (Triple.isOSLinux()) {
2356 switch (Triple.getArch()) {
2357 // Don't use a frame pointer on linux if optimizing for certain targets.
2358 case llvm::Triple::mips64:
2359 case llvm::Triple::mips64el:
2360 case llvm::Triple::mips:
2361 case llvm::Triple::mipsel:
2362 case llvm::Triple::systemz:
2363 case llvm::Triple::x86:
2364 case llvm::Triple::x86_64:
2365 return !areOptimizationsEnabled(Args);
2366 default:
2367 return true;
2368 }
2369 }
2370
2371 if (Triple.isOSWindows()) {
2372 switch (Triple.getArch()) {
2373 case llvm::Triple::x86:
2374 return !areOptimizationsEnabled(Args);
2375 default:
2376 // All other supported Windows ISAs use xdata unwind information, so frame
2377 // pointers are not generally useful.
2378 return false;
2379 }
2380 }
2381
2382 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002383}
2384
Rafael Espindola224dd632011-12-14 21:02:23 +00002385static bool shouldUseFramePointer(const ArgList &Args,
2386 const llvm::Triple &Triple) {
2387 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2388 options::OPT_fomit_frame_pointer))
2389 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2390
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002391 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002392}
2393
Eric Christopherb7d97e92013-04-03 01:58:53 +00002394static bool shouldUseLeafFramePointer(const ArgList &Args,
2395 const llvm::Triple &Triple) {
2396 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2397 options::OPT_momit_leaf_frame_pointer))
2398 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2399
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002400 if (Triple.isPS4CPU())
2401 return false;
2402
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002403 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002404}
2405
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002406/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002407static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002408 SmallString<128> cwd;
2409 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002410 CmdArgs.push_back("-fdebug-compilation-dir");
2411 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002412 }
2413}
2414
Eric Christopherd3804002013-02-22 20:12:52 +00002415static const char *SplitDebugName(const ArgList &Args,
2416 const InputInfoList &Inputs) {
2417 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2418 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2419 SmallString<128> T(FinalOutput->getValue());
2420 llvm::sys::path::replace_extension(T, "dwo");
2421 return Args.MakeArgString(T);
2422 } else {
2423 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002424 SmallString<128> T(
2425 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002426 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2427 llvm::sys::path::replace_extension(F, "dwo");
2428 T += F;
2429 return Args.MakeArgString(F);
2430 }
2431}
2432
2433static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2434 const Tool &T, const JobAction &JA,
2435 const ArgList &Args, const InputInfo &Output,
2436 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002437 ArgStringList ExtractArgs;
2438 ExtractArgs.push_back("--extract-dwo");
2439
2440 ArgStringList StripArgs;
2441 StripArgs.push_back("--strip-dwo");
2442
2443 // Grabbing the output of the earlier compile step.
2444 StripArgs.push_back(Output.getFilename());
2445 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002446 ExtractArgs.push_back(OutFile);
2447
2448 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002449 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002450
2451 // First extract the dwo sections.
David Blaikiec11bf802014-09-04 16:04:28 +00002452 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002453
2454 // Then remove them from the original .o file.
David Blaikiec11bf802014-09-04 16:04:28 +00002455 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002456}
2457
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002458/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002459/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2460static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002461 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002462 if (A->getOption().matches(options::OPT_O4) ||
2463 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002464 return true;
2465
2466 if (A->getOption().matches(options::OPT_O0))
2467 return false;
2468
2469 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2470
Rafael Espindola91780de2013-08-26 14:05:41 +00002471 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002472 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002473 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002474 return true;
2475
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002476 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002477 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002478 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002479
2480 unsigned OptLevel = 0;
2481 if (S.getAsInteger(10, OptLevel))
2482 return false;
2483
2484 return OptLevel > 1;
2485 }
2486
2487 return false;
2488}
2489
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002490/// Add -x lang to \p CmdArgs for \p Input.
2491static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2492 ArgStringList &CmdArgs) {
2493 // When using -verify-pch, we don't want to provide the type
2494 // 'precompiled-header' if it was inferred from the file extension
2495 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2496 return;
2497
2498 CmdArgs.push_back("-x");
2499 if (Args.hasArg(options::OPT_rewrite_objc))
2500 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2501 else
2502 CmdArgs.push_back(types::getTypeName(Input.getType()));
2503}
2504
David Majnemerc371ff02015-03-22 08:39:22 +00002505static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002506 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002507 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002508
2509 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002510 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002511
2512 unsigned Build = 0, Factor = 1;
2513 for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2514 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002515 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002516}
2517
Rafael Espindola577637a2015-01-03 00:06:04 +00002518// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002519// options that build systems might add but are unused when assembling or only
2520// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002521static void claimNoWarnArgs(const ArgList &Args) {
2522 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002523 // preprocessing, precompiling or assembling.
Rafael Espindola577637a2015-01-03 00:06:04 +00002524 Args.ClaimAllArgs(options::OPT_flto);
2525 Args.ClaimAllArgs(options::OPT_fno_lto);
2526}
2527
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002528static void appendUserToPath(SmallVectorImpl<char> &Result) {
2529#ifdef LLVM_ON_UNIX
2530 const char *Username = getenv("LOGNAME");
2531#else
2532 const char *Username = getenv("USERNAME");
2533#endif
2534 if (Username) {
2535 // Validate that LoginName can be used in a path, and get its length.
2536 size_t Len = 0;
2537 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002538 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002539 Username = nullptr;
2540 break;
2541 }
2542 }
2543
2544 if (Username && Len > 0) {
2545 Result.append(Username, Username + Len);
2546 return;
2547 }
2548 }
2549
2550 // Fallback to user id.
2551#ifdef LLVM_ON_UNIX
2552 std::string UID = llvm::utostr(getuid());
2553#else
2554 // FIXME: Windows seems to have an 'SID' that might work.
2555 std::string UID = "9999";
2556#endif
2557 Result.append(UID.begin(), UID.end());
2558}
2559
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002560void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002561 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002562 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002563 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002564 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002565 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2566 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002567 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002568 ArgStringList CmdArgs;
2569
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002570 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002571 bool IsWindowsCygnus =
2572 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002573 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2574
Daniel Dunbare521a892009-03-31 20:53:55 +00002575 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2576
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002577 // Invoke ourselves in -cc1 mode.
2578 //
2579 // FIXME: Implement custom jobs for internal actions.
2580 CmdArgs.push_back("-cc1");
2581
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002582 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002583 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002584 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002585 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002586
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002587 const llvm::Triple TT(TripleStr);
2588 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2589 TT.getArch() == llvm::Triple::thumb)) {
2590 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2591 unsigned Version;
2592 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2593 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002594 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2595 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002596 }
2597
Tim Northover336f1892014-03-29 13:16:12 +00002598 // Push all default warning arguments that are specific to
2599 // the given target. These come before user provided warning options
2600 // are provided.
2601 getToolChain().addClangWarningOptions(CmdArgs);
2602
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002603 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002604 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002605
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002606 if (isa<AnalyzeJobAction>(JA)) {
2607 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2608 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002609 } else if (isa<MigrateJobAction>(JA)) {
2610 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002611 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002612 if (Output.getType() == types::TY_Dependencies)
2613 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002614 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002615 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002616 if (Args.hasArg(options::OPT_rewrite_objc) &&
2617 !Args.hasArg(options::OPT_g_Group))
2618 CmdArgs.push_back("-P");
2619 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002620 } else if (isa<AssembleJobAction>(JA)) {
2621 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002622
David Blaikie9260ed62013-07-25 21:19:01 +00002623 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002624
2625 // Also ignore explicit -force_cpusubtype_ALL option.
2626 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002627 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002628 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002629 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002630
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002631 if (JA.getType() == types::TY_Nothing)
2632 CmdArgs.push_back("-fsyntax-only");
2633 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002634 CmdArgs.push_back("-emit-pch");
2635 else
2636 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002637 } else if (isa<VerifyPCHJobAction>(JA)) {
2638 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002639 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00002640 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2641 "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002642
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002643 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002644 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002645 } else if (JA.getType() == types::TY_LLVM_IR ||
2646 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002647 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002648 } else if (JA.getType() == types::TY_LLVM_BC ||
2649 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002650 CmdArgs.push_back("-emit-llvm-bc");
2651 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002652 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002653 } else if (JA.getType() == types::TY_AST) {
2654 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002655 } else if (JA.getType() == types::TY_ModuleFile) {
2656 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002657 } else if (JA.getType() == types::TY_RewrittenObjC) {
2658 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002659 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002660 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2661 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002662 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002663 } else {
2664 assert(JA.getType() == types::TY_PP_Asm &&
2665 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002666 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002667 }
2668
Justin Bognera88f0122014-06-20 22:59:50 +00002669 // We normally speed up the clang process a bit by skipping destructors at
2670 // exit, but when we're generating diagnostics we can rely on some of the
2671 // cleanup.
2672 if (!C.isForDiagnostics())
2673 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002674
John McCallbb79b5f2010-02-13 03:50:24 +00002675 // Disable the verification pass in -asserts builds.
2676#ifdef NDEBUG
2677 CmdArgs.push_back("-disable-llvm-verifier");
2678#endif
2679
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002680 // Set the main file name, so that debug info works even with
2681 // -save-temps.
2682 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002683 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002684
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002685 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002686 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002687 if (Args.hasArg(options::OPT_static))
2688 CmdArgs.push_back("-static-define");
2689
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002690 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002691 // Enable region store model by default.
2692 CmdArgs.push_back("-analyzer-store=region");
2693
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002694 // Treat blocks as analysis entry points.
2695 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2696
Ted Kremenek49c79792011-03-24 00:28:47 +00002697 CmdArgs.push_back("-analyzer-eagerly-assume");
2698
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002699 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002700 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002701 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002702
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002703 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002704 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002705
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002706 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002707 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002708
2709 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002710
Jordan Rose10ad0812013-04-05 17:55:07 +00002711 if (types::isCXX(Inputs[0].getType()))
2712 CmdArgs.push_back("-analyzer-checker=cplusplus");
2713
Nico Webere8e53112014-05-11 01:04:02 +00002714 // Enable the following experimental checkers for testing.
2715 CmdArgs.push_back(
2716 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002717 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2718 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2719 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2720 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2721 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002722 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002723
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002724 // Set the output format. The default is plist, for (lame) historical
2725 // reasons.
2726 CmdArgs.push_back("-analyzer-output");
2727 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002728 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002729 else
2730 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002731
Ted Kremenekfe449a22010-03-22 22:32:05 +00002732 // Disable the presentation of standard compiler warnings when
2733 // using --analyze. We only want to show static analyzer diagnostics
2734 // or frontend errors.
2735 CmdArgs.push_back("-w");
2736
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002737 // Add -Xanalyzer arguments when running as analyzer.
2738 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002739 }
2740
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002741 CheckCodeGenerationOptions(D, Args);
2742
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002743 bool PIE = getToolChain().isPIEDefault();
2744 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002745 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002746
Alexey Bataev40e75222014-01-28 06:30:35 +00002747 // Android-specific defaults for PIC/PIE
2748 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2749 switch (getToolChain().getTriple().getArch()) {
2750 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002751 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002752 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002753 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002754 case llvm::Triple::aarch64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002755 case llvm::Triple::mips:
2756 case llvm::Triple::mipsel:
2757 case llvm::Triple::mips64:
2758 case llvm::Triple::mips64el:
2759 PIC = true; // "-fpic"
2760 break;
2761
2762 case llvm::Triple::x86:
2763 case llvm::Triple::x86_64:
2764 PIC = true; // "-fPIC"
2765 IsPICLevelTwo = true;
2766 break;
2767
2768 default:
2769 break;
2770 }
2771 }
2772
Brad Smith5b05db82014-06-24 19:51:29 +00002773 // OpenBSD-specific defaults for PIE
2774 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2775 switch (getToolChain().getTriple().getArch()) {
2776 case llvm::Triple::mips64:
2777 case llvm::Triple::mips64el:
2778 case llvm::Triple::sparc:
2779 case llvm::Triple::x86:
2780 case llvm::Triple::x86_64:
2781 IsPICLevelTwo = false; // "-fpie"
2782 break;
2783
2784 case llvm::Triple::ppc:
2785 case llvm::Triple::sparcv9:
2786 IsPICLevelTwo = true; // "-fPIE"
2787 break;
2788
2789 default:
2790 break;
2791 }
2792 }
2793
Alexey Samsonov090301e2013-04-09 12:28:19 +00002794 // For the PIC and PIE flag options, this logic is different from the
2795 // legacy logic in very old versions of GCC, as that logic was just
2796 // a bug no one had ever fixed. This logic is both more rational and
2797 // consistent with GCC's new logic now that the bugs are fixed. The last
2798 // argument relating to either PIC or PIE wins, and no other argument is
2799 // used. If the last argument is any flavor of the '-fno-...' arguments,
2800 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2801 // at the same level.
2802 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2803 options::OPT_fpic, options::OPT_fno_pic,
2804 options::OPT_fPIE, options::OPT_fno_PIE,
2805 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002806 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2807 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002808 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002809 if (LastPICArg) {
2810 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002811 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2812 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2813 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2814 PIC = PIE || O.matches(options::OPT_fPIC) ||
2815 O.matches(options::OPT_fpic);
2816 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2817 O.matches(options::OPT_fPIC);
2818 } else {
2819 PIE = PIC = false;
2820 }
2821 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002822 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002823
Nick Lewycky609dd662013-10-11 03:33:53 +00002824 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002825 // specified while enabling PIC enabled level 1 PIC, just force it back to
2826 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2827 // informal testing).
2828 if (PIC && getToolChain().getTriple().isOSDarwin())
2829 IsPICLevelTwo |= getToolChain().isPICDefault();
2830
Chandler Carruthc0c04552012-04-08 16:40:35 +00002831 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2832 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002833 llvm::Triple Triple(TripleStr);
Bob Wilson5f4346d2014-12-02 00:27:35 +00002834 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002835 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002836 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002837 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002838
Chandler Carruth76a943b2012-11-19 03:52:03 +00002839 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2840 // This is a very special mode. It trumps the other modes, almost no one
2841 // uses it, and it isn't even valid on any OS but Darwin.
2842 if (!getToolChain().getTriple().isOSDarwin())
2843 D.Diag(diag::err_drv_unsupported_opt_for_target)
2844 << A->getSpelling() << getToolChain().getTriple().str();
2845
2846 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2847
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002848 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002849 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002850
Chandler Carruth76a943b2012-11-19 03:52:03 +00002851 // Only a forced PIC mode can cause the actual compile to have PIC defines
2852 // etc., no flags are sufficient. This behavior was selected to closely
2853 // match that of llvm-gcc and Apple GCC before that.
2854 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2855 CmdArgs.push_back("-pic-level");
2856 CmdArgs.push_back("2");
2857 }
2858 } else {
2859 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2860 // handled in Clang's IRGen by the -pie-level flag.
2861 CmdArgs.push_back("-mrelocation-model");
2862 CmdArgs.push_back(PIC ? "pic" : "static");
2863
2864 if (PIC) {
2865 CmdArgs.push_back("-pic-level");
2866 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2867 if (PIE) {
2868 CmdArgs.push_back("-pie-level");
2869 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2870 }
2871 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002872 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002873
Jonathan Roelofsb140a102014-10-03 21:57:44 +00002874 CmdArgs.push_back("-mthread-model");
2875 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
2876 CmdArgs.push_back(A->getValue());
2877 else
2878 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
2879
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00002880 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
2881
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002882 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2883 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002884 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002885
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002886 // LLVM Code Generator Options.
2887
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00002888 if (Args.hasArg(options::OPT_frewrite_map_file) ||
2889 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
2890 for (arg_iterator
2891 MFI = Args.filtered_begin(options::OPT_frewrite_map_file,
2892 options::OPT_frewrite_map_file_EQ),
2893 MFE = Args.filtered_end();
2894 MFI != MFE; ++MFI) {
2895 CmdArgs.push_back("-frewrite-map-file");
2896 CmdArgs.push_back((*MFI)->getValue());
2897 (*MFI)->claim();
2898 }
2899 }
2900
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002901 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2902 StringRef v = A->getValue();
2903 CmdArgs.push_back("-mllvm");
2904 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2905 A->claim();
2906 }
2907
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002908 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2909 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002910 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002911 }
2912
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002913 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2914 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002915 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002916 D.Diag(diag::err_drv_unsupported_opt_for_target)
2917 << A->getSpelling() << getToolChain().getTriple().str();
2918 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2919 CmdArgs.push_back("-fpcc-struct-return");
2920 } else {
2921 assert(A->getOption().matches(options::OPT_freg_struct_return));
2922 CmdArgs.push_back("-freg-struct-return");
2923 }
2924 }
2925
Roman Divacky65b88cd2011-03-01 17:40:53 +00002926 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2927 CmdArgs.push_back("-mrtd");
2928
Rafael Espindola224dd632011-12-14 21:02:23 +00002929 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002930 CmdArgs.push_back("-mdisable-fp-elim");
2931 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2932 options::OPT_fno_zero_initialized_in_bss))
2933 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002934
2935 bool OFastEnabled = isOptimizationLevelFast(Args);
2936 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2937 // enabled. This alias option is being used to simplify the hasFlag logic.
2938 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2939 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002940 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2941 // doesn't do any TBAA.
2942 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002943 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002944 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002945 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002946 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2947 options::OPT_fno_struct_path_tbaa))
2948 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002949 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2950 false))
2951 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002952 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2953 options::OPT_fno_optimize_sibling_calls))
2954 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002955
Eric Christopher006208c2013-04-04 06:29:47 +00002956 // Handle segmented stacks.
2957 if (Args.hasArg(options::OPT_fsplit_stack))
2958 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002959
2960 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2961 // This alias option is being used to simplify the getLastArg logic.
2962 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2963 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002964
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002965 // Handle various floating point optimization flags, mapping them to the
2966 // appropriate LLVM code generation flags. The pattern for all of these is to
2967 // default off the codegen optimizations, and if any flag enables them and no
2968 // flag disables them after the flag enabling them, enable the codegen
2969 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002970 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002971 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002972 options::OPT_ffinite_math_only,
2973 options::OPT_fno_finite_math_only,
2974 options::OPT_fhonor_infinities,
2975 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002976 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2977 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002978 A->getOption().getID() != options::OPT_fhonor_infinities)
2979 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002980 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002981 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002982 options::OPT_ffinite_math_only,
2983 options::OPT_fno_finite_math_only,
2984 options::OPT_fhonor_nans,
2985 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002986 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2987 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002988 A->getOption().getID() != options::OPT_fhonor_nans)
2989 CmdArgs.push_back("-menable-no-nans");
2990
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002991 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2992 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002993 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002994 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002995 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002996 options::OPT_fno_math_errno)) {
2997 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2998 // However, turning *off* -ffast_math merely restores the toolchain default
2999 // (which may be false).
3000 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3001 A->getOption().getID() == options::OPT_ffast_math ||
3002 A->getOption().getID() == options::OPT_Ofast)
3003 MathErrno = false;
3004 else if (A->getOption().getID() == options::OPT_fmath_errno)
3005 MathErrno = true;
3006 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003007 if (MathErrno)
3008 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003009
3010 // There are several flags which require disabling very specific
3011 // optimizations. Any of these being disabled forces us to turn off the
3012 // entire set of LLVM optimizations, so collect them through all the flag
3013 // madness.
3014 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003015 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003016 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003017 options::OPT_funsafe_math_optimizations,
3018 options::OPT_fno_unsafe_math_optimizations,
3019 options::OPT_fassociative_math,
3020 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003021 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3022 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003023 A->getOption().getID() != options::OPT_fno_associative_math)
3024 AssociativeMath = true;
3025 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003026 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003027 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003028 options::OPT_funsafe_math_optimizations,
3029 options::OPT_fno_unsafe_math_optimizations,
3030 options::OPT_freciprocal_math,
3031 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003032 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3033 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003034 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3035 ReciprocalMath = true;
3036 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003037 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003038 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003039 options::OPT_funsafe_math_optimizations,
3040 options::OPT_fno_unsafe_math_optimizations,
3041 options::OPT_fsigned_zeros,
3042 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003043 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3044 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003045 A->getOption().getID() != options::OPT_fsigned_zeros)
3046 SignedZeros = false;
3047 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003048 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003049 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003050 options::OPT_funsafe_math_optimizations,
3051 options::OPT_fno_unsafe_math_optimizations,
3052 options::OPT_ftrapping_math,
3053 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003054 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3055 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003056 A->getOption().getID() != options::OPT_ftrapping_math)
3057 TrappingMath = false;
3058 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3059 !TrappingMath)
3060 CmdArgs.push_back("-menable-unsafe-fp-math");
3061
Sanjay Patel76c9e092015-01-23 16:40:50 +00003062 if (!SignedZeros)
3063 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003064
Sanjay Patel359b1052015-04-09 15:03:23 +00003065 if (ReciprocalMath)
3066 CmdArgs.push_back("-freciprocal-math");
3067
Lang Hamesaa53b932012-07-06 00:59:19 +00003068 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003069 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003070 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003071 options::OPT_ffp_contract)) {
3072 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003073 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003074 if (Val == "fast" || Val == "on" || Val == "off") {
3075 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3076 } else {
3077 D.Diag(diag::err_drv_unsupported_option_argument)
3078 << A->getOption().getName() << Val;
3079 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003080 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3081 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003082 // If fast-math is set then set the fp-contract mode to fast.
3083 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3084 }
3085 }
3086
Bob Wilson6a039162012-07-19 03:52:53 +00003087 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3088 // and if we find them, tell the frontend to provide the appropriate
3089 // preprocessor macros. This is distinct from enabling any optimizations as
3090 // these options induce language changes which must survive serialization
3091 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003092 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3093 options::OPT_fno_fast_math))
3094 if (!A->getOption().matches(options::OPT_fno_fast_math))
3095 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003096 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3097 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003098 if (A->getOption().matches(options::OPT_ffinite_math_only))
3099 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003100
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003101 // Decide whether to use verbose asm. Verbose assembly is the default on
3102 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003103 bool IsIntegratedAssemblerDefault =
3104 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003105 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003106 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003107 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003108 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003109
Rafael Espindola298059a2015-04-06 04:36:45 +00003110 bool UsingIntegratedAssembler =
3111 Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3112 IsIntegratedAssemblerDefault);
3113 if (!UsingIntegratedAssembler)
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003114 CmdArgs.push_back("-no-integrated-as");
3115
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003116 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3117 CmdArgs.push_back("-mdebug-pass");
3118 CmdArgs.push_back("Structure");
3119 }
3120 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3121 CmdArgs.push_back("-mdebug-pass");
3122 CmdArgs.push_back("Arguments");
3123 }
3124
John McCall8517abc2010-02-19 02:45:38 +00003125 // Enable -mconstructor-aliases except on darwin, where we have to
3126 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003127 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003128 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003129
John McCall7ef5cb32011-03-18 02:56:14 +00003130 // Darwin's kernel doesn't support guard variables; just die if we
3131 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003132 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003133 CmdArgs.push_back("-fforbid-guard-variables");
3134
Douglas Gregordbe39272011-02-01 15:15:22 +00003135 if (Args.hasArg(options::OPT_mms_bitfields)) {
3136 CmdArgs.push_back("-mms-bitfields");
3137 }
John McCall8517abc2010-02-19 02:45:38 +00003138
Daniel Dunbar306945d2009-09-16 06:17:29 +00003139 // This is a coarse approximation of what llvm-gcc actually does, both
3140 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3141 // complicated ways.
3142 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003143 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3144 options::OPT_fno_asynchronous_unwind_tables,
3145 (getToolChain().IsUnwindTablesDefault() ||
3146 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3147 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003148 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3149 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003150 CmdArgs.push_back("-munwind-tables");
3151
Chandler Carruth05fb5852012-11-21 23:40:23 +00003152 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003153
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003154 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3155 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003156 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003157 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003158
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003159 // FIXME: Handle -mtune=.
3160 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003161
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003162 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003163 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003164 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003165 }
3166
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003167 // Add the target cpu
3168 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3169 llvm::Triple ETriple(ETripleStr);
3170 std::string CPU = getCPUName(Args, ETriple);
3171 if (!CPU.empty()) {
3172 CmdArgs.push_back("-target-cpu");
3173 CmdArgs.push_back(Args.MakeArgString(CPU));
3174 }
3175
Rafael Espindolaeb265472013-08-21 21:59:03 +00003176 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3177 CmdArgs.push_back("-mfpmath");
3178 CmdArgs.push_back(A->getValue());
3179 }
3180
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003181 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00003182 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003183
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003184 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003185 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003186 default:
3187 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003188
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003189 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003190 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003191 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003192 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00003193 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003194 break;
3195
Tim Northover573cbee2014-05-24 12:52:07 +00003196 case llvm::Triple::aarch64:
3197 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003198 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003199 break;
3200
Eric Christopher0b26a612010-03-02 02:41:08 +00003201 case llvm::Triple::mips:
3202 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003203 case llvm::Triple::mips64:
3204 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003205 AddMIPSTargetArgs(Args, CmdArgs);
3206 break;
3207
Ulrich Weigand8afad612014-07-28 13:17:52 +00003208 case llvm::Triple::ppc:
3209 case llvm::Triple::ppc64:
3210 case llvm::Triple::ppc64le:
3211 AddPPCTargetArgs(Args, CmdArgs);
3212 break;
3213
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003214 case llvm::Triple::sparc:
Brad Smith10cd0f42014-07-11 20:12:08 +00003215 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003216 AddSparcTargetArgs(Args, CmdArgs);
3217 break;
3218
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003219 case llvm::Triple::x86:
3220 case llvm::Triple::x86_64:
3221 AddX86TargetArgs(Args, CmdArgs);
3222 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003223
3224 case llvm::Triple::hexagon:
3225 AddHexagonTargetArgs(Args, CmdArgs);
3226 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003227 }
3228
Hans Wennborg75958c42013-08-08 00:17:41 +00003229 // Add clang-cl arguments.
3230 if (getToolChain().getDriver().IsCLMode())
3231 AddClangCLArgs(Args, CmdArgs);
3232
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003233 // Pass the linker version in use.
3234 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3235 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003236 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003237 }
3238
Eric Christopherb7d97e92013-04-03 01:58:53 +00003239 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003240 CmdArgs.push_back("-momit-leaf-frame-pointer");
3241
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003242 // Explicitly error on some things we know we don't support and can't just
3243 // ignore.
3244 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003245 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3246 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003247 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00003248 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003249 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003250 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3251 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003252 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003253 << Unsupported->getOption().getName();
3254 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003255 }
3256
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003257 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003258 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003259 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003260 CmdArgs.push_back("-header-include-file");
3261 CmdArgs.push_back(D.CCPrintHeadersFilename ?
3262 D.CCPrintHeadersFilename : "-");
3263 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003264 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003265 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003266
Chad Rosierbe10f982011-08-02 17:58:04 +00003267 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003268 CmdArgs.push_back("-diagnostic-log-file");
3269 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
3270 D.CCLogDiagnosticsFilename : "-");
3271 }
3272
Manman Ren17bdb0f2013-11-20 20:22:14 +00003273 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3274 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00003275 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003276 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Hal Finkel4add5dc2014-10-21 19:20:21 +00003277 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3278 A->getOption().matches(options::OPT_g1)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00003279 // FIXME: we should support specifying dwarf version with
3280 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003281 CmdArgs.push_back("-gline-tables-only");
Alexander Eremin670c6272014-10-16 05:55:24 +00003282 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003283 const llvm::Triple &Triple = getToolChain().getTriple();
3284 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003285 Triple.getOS() == llvm::Triple::FreeBSD ||
3286 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003287 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00003288 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00003289 CmdArgs.push_back("-gdwarf-2");
3290 else if (A->getOption().matches(options::OPT_gdwarf_3))
3291 CmdArgs.push_back("-gdwarf-3");
3292 else if (A->getOption().matches(options::OPT_gdwarf_4))
3293 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003294 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00003295 !A->getOption().matches(options::OPT_ggdb0)) {
Alexander Eremin670c6272014-10-16 05:55:24 +00003296 // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
Brad Smith378e7f9b2014-06-13 03:35:37 +00003297 const llvm::Triple &Triple = getToolChain().getTriple();
3298 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
Alexander Eremin670c6272014-10-16 05:55:24 +00003299 Triple.getOS() == llvm::Triple::FreeBSD ||
3300 Triple.getOS() == llvm::Triple::Solaris)
Adrian Prantl549c5142014-02-17 17:40:52 +00003301 CmdArgs.push_back("-gdwarf-2");
3302 else
3303 CmdArgs.push_back("-g");
3304 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003305 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003306
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003307 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3308 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Diego Novillo94b276d2014-07-10 23:29:28 +00003309 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3310 /*Default*/ true))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003311 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003312
Eric Christopher138c32b2013-09-13 22:37:55 +00003313 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003314 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3315 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003316 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00003317 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00003318 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003319 CmdArgs.push_back("-g");
3320 CmdArgs.push_back("-backend-option");
3321 CmdArgs.push_back("-split-dwarf=Enable");
3322 }
3323
Eric Christopher138c32b2013-09-13 22:37:55 +00003324 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3325 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3326 CmdArgs.push_back("-backend-option");
3327 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3328 }
Eric Christophereec89c22013-06-18 00:03:50 +00003329
Eric Christopher0d403d22014-02-14 01:27:03 +00003330 // -gdwarf-aranges turns on the emission of the aranges section in the
3331 // backend.
3332 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3333 CmdArgs.push_back("-backend-option");
3334 CmdArgs.push_back("-generate-arange-section");
3335 }
3336
David Blaikief36d9ba2014-01-27 18:52:43 +00003337 if (Args.hasFlag(options::OPT_fdebug_types_section,
3338 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003339 CmdArgs.push_back("-backend-option");
3340 CmdArgs.push_back("-generate-type-units");
3341 }
Eric Christophereec89c22013-06-18 00:03:50 +00003342
Ed Schouten6e576152015-03-26 17:50:28 +00003343 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3344 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3345
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003346 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003347 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003348 CmdArgs.push_back("-ffunction-sections");
3349 }
3350
3351 if (Args.hasFlag(options::OPT_fdata_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003352 options::OPT_fno_data_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003353 CmdArgs.push_back("-fdata-sections");
3354 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003355
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003356 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindola298059a2015-04-06 04:36:45 +00003357 options::OPT_fno_unique_section_names,
3358 !UsingIntegratedAssembler))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003359 CmdArgs.push_back("-fno-unique-section-names");
3360
Chris Lattner3c77a352010-06-22 00:03:40 +00003361 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3362
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00003363 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
3364 (Args.hasArg(options::OPT_fprofile_instr_use) ||
3365 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3366 D.Diag(diag::err_drv_argument_not_allowed_with)
3367 << "-fprofile-instr-generate" << "-fprofile-instr-use";
3368
3369 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3370
3371 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3372 A->render(Args, CmdArgs);
3373 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3374 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3375
Nick Lewycky207bce32011-04-21 23:44:07 +00003376 if (Args.hasArg(options::OPT_ftest_coverage) ||
3377 Args.hasArg(options::OPT_coverage))
3378 CmdArgs.push_back("-femit-coverage-notes");
Justin Bogner31a4aca2014-08-07 03:14:34 +00003379 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3380 false) ||
Nick Lewycky207bce32011-04-21 23:44:07 +00003381 Args.hasArg(options::OPT_coverage))
3382 CmdArgs.push_back("-femit-coverage-data");
3383
Alex Lorenzee024992014-08-04 18:41:51 +00003384 if (Args.hasArg(options::OPT_fcoverage_mapping) &&
3385 !Args.hasArg(options::OPT_fprofile_instr_generate))
3386 D.Diag(diag::err_drv_argument_only_allowed_with)
3387 << "-fcoverage-mapping" << "-fprofile-instr-generate";
3388
3389 if (Args.hasArg(options::OPT_fcoverage_mapping))
3390 CmdArgs.push_back("-fcoverage-mapping");
3391
Nick Lewycky480cb992011-05-04 20:46:58 +00003392 if (C.getArgs().hasArg(options::OPT_c) ||
3393 C.getArgs().hasArg(options::OPT_S)) {
3394 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003395 CmdArgs.push_back("-coverage-file");
Dan Albertb8e7eae2014-10-10 01:01:29 +00003396 SmallString<128> CoverageFilename;
Dan Alberta4ec57c2014-10-10 02:26:00 +00003397 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
Dan Albertb8e7eae2014-10-10 01:01:29 +00003398 CoverageFilename = FinalOutput->getValue();
3399 } else {
3400 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3401 }
Yaron Keren92e1b622015-03-18 10:17:07 +00003402 if (llvm::sys::path::is_relative(CoverageFilename)) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003403 SmallString<128> Pwd;
3404 if (!llvm::sys::fs::current_path(Pwd)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00003405 llvm::sys::path::append(Pwd, CoverageFilename);
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003406 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003407 }
3408 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003409 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003410 }
3411 }
3412
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003413 // Pass options for controlling the default header search paths.
3414 if (Args.hasArg(options::OPT_nostdinc)) {
3415 CmdArgs.push_back("-nostdsysteminc");
3416 CmdArgs.push_back("-nobuiltininc");
3417 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003418 if (Args.hasArg(options::OPT_nostdlibinc))
3419 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003420 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3421 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3422 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003423
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003424 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003425 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003426 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003427
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003428 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3429
Ted Kremenekf7639e12012-03-06 20:06:33 +00003430 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003431 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003432 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003433 options::OPT_ccc_arcmt_modify,
3434 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003435 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003436 switch (A->getOption().getID()) {
3437 default:
3438 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003439 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003440 CmdArgs.push_back("-arcmt-check");
3441 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003442 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003443 CmdArgs.push_back("-arcmt-modify");
3444 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003445 case options::OPT_ccc_arcmt_migrate:
3446 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003447 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003448 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003449
3450 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3451 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003452 break;
John McCalld70fb982011-06-15 23:25:17 +00003453 }
3454 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003455 } else {
3456 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3457 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3458 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003459 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003460
Ted Kremenekf7639e12012-03-06 20:06:33 +00003461 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3462 if (ARCMTEnabled) {
3463 D.Diag(diag::err_drv_argument_not_allowed_with)
3464 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3465 }
3466 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003467 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003468
3469 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003470 options::OPT_objcmt_migrate_subscripting,
3471 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003472 // None specified, means enable them all.
3473 CmdArgs.push_back("-objcmt-migrate-literals");
3474 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003475 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003476 } else {
3477 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3478 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003479 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003480 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003481 } else {
3482 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3483 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3484 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3485 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3486 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3487 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00003488 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003489 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3490 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3491 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3492 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3493 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3494 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3495 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003496 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003497 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003498 }
3499
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003500 // Add preprocessing options like -I, -D, etc. if we are using the
3501 // preprocessor.
3502 //
3503 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003504 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003505 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003506
Rafael Espindolaa7431922011-07-21 23:40:37 +00003507 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3508 // that "The compiler can only warn and ignore the option if not recognized".
3509 // When building with ccache, it will pass -D options to clang even on
3510 // preprocessed inputs and configure concludes that -fPIC is not supported.
3511 Args.ClaimAllArgs(options::OPT_D);
3512
Alp Toker7874bdc2013-11-15 20:40:58 +00003513 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003514 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3515 if (A->getOption().matches(options::OPT_O4)) {
3516 CmdArgs.push_back("-O3");
3517 D.Diag(diag::warn_O4_is_O3);
3518 } else {
3519 A->render(Args, CmdArgs);
3520 }
3521 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003522
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00003523 // Warn about ignored options to clang.
3524 for (arg_iterator it = Args.filtered_begin(
3525 options::OPT_clang_ignored_gcc_optimization_f_Group),
3526 ie = Args.filtered_end(); it != ie; ++it) {
3527 D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
3528 }
3529
Rafael Espindola577637a2015-01-03 00:06:04 +00003530 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00003531
Richard Smith3be1cb22014-08-07 00:24:21 +00003532 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00003533 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003534 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3535 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003536 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003537 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003538
3539 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003540 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003541 //
3542 // If a std is supplied, only add -trigraphs if it follows the
3543 // option.
3544 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3545 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003546 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003547 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003548 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003549 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003550 else
3551 Std->render(Args, CmdArgs);
3552
Nico Weber00721502014-12-23 22:32:37 +00003553 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003554 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00003555 options::OPT_ftrigraphs,
3556 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003557 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003558 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003559 } else {
3560 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003561 //
3562 // FIXME: Clang doesn't correctly handle -std= when the input language
3563 // doesn't match. For the time being just ignore this for C++ inputs;
3564 // eventually we want to do all the standard defaulting here instead of
3565 // splitting it between the driver and clang -cc1.
3566 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003567 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3568 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003569 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003570 CmdArgs.push_back("-std=c++11");
3571
Nico Weber00721502014-12-23 22:32:37 +00003572 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3573 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003574 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003575
Richard Smith282b4492013-09-04 22:50:31 +00003576 // GCC's behavior for -Wwrite-strings is a bit strange:
3577 // * In C, this "warning flag" changes the types of string literals from
3578 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3579 // for the discarded qualifier.
3580 // * In C++, this is just a normal warning flag.
3581 //
3582 // Implementing this warning correctly in C is hard, so we follow GCC's
3583 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3584 // a non-const char* in C, rather than using this crude hack.
3585 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003586 // FIXME: This should behave just like a warning flag, and thus should also
3587 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3588 Arg *WriteStrings =
3589 Args.getLastArg(options::OPT_Wwrite_strings,
3590 options::OPT_Wno_write_strings, options::OPT_w);
3591 if (WriteStrings &&
3592 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003593 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003594 }
3595
Chandler Carruth61fbf622011-04-23 09:27:53 +00003596 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003597 // during C++ compilation, which it is by default. GCC keeps this define even
3598 // in the presence of '-w', match this behavior bug-for-bug.
3599 if (types::isCXX(InputType) &&
3600 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3601 true)) {
3602 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003603 }
3604
Chandler Carruthe0391482010-05-22 02:21:53 +00003605 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3606 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3607 if (Asm->getOption().matches(options::OPT_fasm))
3608 CmdArgs.push_back("-fgnu-keywords");
3609 else
3610 CmdArgs.push_back("-fno-gnu-keywords");
3611 }
3612
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003613 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3614 CmdArgs.push_back("-fno-dwarf-directory-asm");
3615
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003616 if (ShouldDisableAutolink(Args, getToolChain()))
3617 CmdArgs.push_back("-fno-autolink");
3618
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003619 // Add in -fdebug-compilation-dir if necessary.
3620 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003621
Richard Smith9a568822011-11-21 19:36:32 +00003622 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3623 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003624 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003625 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003626 }
3627
Richard Smith79c927b2013-11-06 19:31:51 +00003628 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3629 CmdArgs.push_back("-foperator-arrow-depth");
3630 CmdArgs.push_back(A->getValue());
3631 }
3632
Richard Smith9a568822011-11-21 19:36:32 +00003633 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3634 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003635 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003636 }
3637
Richard Smitha3d3bd22013-05-08 02:12:03 +00003638 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3639 CmdArgs.push_back("-fconstexpr-steps");
3640 CmdArgs.push_back(A->getValue());
3641 }
3642
Richard Smithb3a14522013-02-22 01:59:51 +00003643 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3644 CmdArgs.push_back("-fbracket-depth");
3645 CmdArgs.push_back(A->getValue());
3646 }
3647
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003648 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3649 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003650 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003651 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003652 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3653 } else
3654 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003655 }
3656
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003657
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003658 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003659 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003660
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003661 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3662 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003663 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003664 }
David Chisnall5778fce2009-08-31 16:41:57 +00003665
Chris Lattnere23003d2010-01-09 21:54:33 +00003666 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3667 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003668 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003669 }
3670
Chris Lattnerb35583d2010-04-07 20:49:23 +00003671 CmdArgs.push_back("-ferror-limit");
3672 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003673 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003674 else
3675 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003676
Chandler Carrutha77a7272010-05-06 04:55:18 +00003677 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3678 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003679 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003680 }
3681
3682 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3683 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003684 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003685 }
3686
Richard Smithf6f003a2011-12-16 19:06:07 +00003687 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3688 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003689 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003690 }
3691
Nick Lewycky24653262014-12-16 21:39:02 +00003692 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3693 CmdArgs.push_back("-fspell-checking-limit");
3694 CmdArgs.push_back(A->getValue());
3695 }
3696
Daniel Dunbar2c978472009-11-04 06:24:47 +00003697 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003698 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003699 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003700 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003701 } else {
3702 // If -fmessage-length=N was not specified, determine whether this is a
3703 // terminal and, if so, implicitly define -fmessage-length appropriately.
3704 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003705 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003706 }
3707
John McCallb4a99d32013-02-19 01:57:35 +00003708 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3709 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3710 options::OPT_fvisibility_ms_compat)) {
3711 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3712 CmdArgs.push_back("-fvisibility");
3713 CmdArgs.push_back(A->getValue());
3714 } else {
3715 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3716 CmdArgs.push_back("-fvisibility");
3717 CmdArgs.push_back("hidden");
3718 CmdArgs.push_back("-ftype-visibility");
3719 CmdArgs.push_back("default");
3720 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003721 }
3722
Douglas Gregor08329632010-06-15 17:05:35 +00003723 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003724
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003725 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3726
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003727 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003728 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3729 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003730 CmdArgs.push_back("-ffreestanding");
3731
Daniel Dunbare357d562009-12-03 18:42:11 +00003732 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003733 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003734 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003735 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3736 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003737 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003738 // AltiVec language extensions aren't relevant for assembling.
3739 if (!isa<PreprocessJobAction>(JA) ||
3740 Output.getType() != types::TY_PP_Asm)
3741 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003742 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3743 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003744
Peter Collingbourne32701642013-11-01 18:16:25 +00003745 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3746 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003747
Eric Christopher459d2712013-02-19 06:16:53 +00003748 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003749 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003750 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003751 getToolChain().getArch() == llvm::Triple::ppc64 ||
3752 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003753 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003754 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003755
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003756 if (getToolChain().SupportsProfiling())
3757 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003758
3759 // -flax-vector-conversions is default.
3760 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3761 options::OPT_fno_lax_vector_conversions))
3762 CmdArgs.push_back("-fno-lax-vector-conversions");
3763
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003764 if (Args.getLastArg(options::OPT_fapple_kext))
3765 CmdArgs.push_back("-fapple-kext");
3766
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003767 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003768 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003769 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003770 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3771 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003772
3773 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3774 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003775 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003776 }
3777
Bob Wilson14adb362012-02-03 06:27:22 +00003778 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003779
Chandler Carruth6e501032011-03-27 00:04:55 +00003780 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3781 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3782 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3783 options::OPT_fno_wrapv)) {
3784 if (A->getOption().matches(options::OPT_fwrapv))
3785 CmdArgs.push_back("-fwrapv");
3786 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3787 options::OPT_fno_strict_overflow)) {
3788 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3789 CmdArgs.push_back("-fwrapv");
3790 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003791
3792 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3793 options::OPT_fno_reroll_loops))
3794 if (A->getOption().matches(options::OPT_freroll_loops))
3795 CmdArgs.push_back("-freroll-loops");
3796
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003797 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003798 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3799 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003800
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003801 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3802
Mahesha S6a682be42012-10-27 07:47:56 +00003803
Daniel Dunbar4930e332009-11-17 08:07:36 +00003804 // -stack-protector=0 is default.
3805 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003806 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3807 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003808 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003809 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003810 if (A->getOption().matches(options::OPT_fstack_protector)) {
3811 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3812 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3813 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003814 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003815 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003816 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003817 } else {
3818 StackProtectorLevel =
3819 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3820 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003821 if (StackProtectorLevel) {
3822 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003823 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003824 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003825
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003826 // --param ssp-buffer-size=
3827 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3828 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003829 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003830 if (Str.startswith("ssp-buffer-size=")) {
3831 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003832 CmdArgs.push_back("-stack-protector-buffer-size");
3833 // FIXME: Verify the argument is a valid integer.
3834 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003835 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003836 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003837 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003838 }
3839
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003840 // Translate -mstackrealign
3841 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3842 false)) {
3843 CmdArgs.push_back("-backend-option");
3844 CmdArgs.push_back("-force-align-stack");
3845 }
3846 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3847 false)) {
3848 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3849 }
3850
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003851 if (Args.hasArg(options::OPT_mstack_alignment)) {
3852 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3853 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003854 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003855
Hans Wennborg77dc2362015-01-20 19:45:50 +00003856 if (Args.hasArg(options::OPT_mstack_probe_size)) {
3857 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
3858
3859 if (!Size.empty())
3860 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
3861 else
3862 CmdArgs.push_back("-mstack-probe-size=0");
3863 }
3864
Oliver Stannarded8ecc82014-08-27 16:31:57 +00003865 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3866 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
3867 CmdArgs.push_back("-fallow-half-arguments-and-returns");
3868
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003869 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3870 options::OPT_mno_restrict_it)) {
3871 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3872 CmdArgs.push_back("-backend-option");
3873 CmdArgs.push_back("-arm-restrict-it");
3874 } else {
3875 CmdArgs.push_back("-backend-option");
3876 CmdArgs.push_back("-arm-no-restrict-it");
3877 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003878 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3879 TT.getArch() == llvm::Triple::thumb)) {
3880 // Windows on ARM expects restricted IT blocks
3881 CmdArgs.push_back("-backend-option");
3882 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003883 }
3884
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003885 if (TT.getArch() == llvm::Triple::arm ||
3886 TT.getArch() == llvm::Triple::thumb) {
3887 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3888 options::OPT_mno_long_calls)) {
3889 if (A->getOption().matches(options::OPT_mlong_calls)) {
3890 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003891 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003892 }
3893 }
3894 }
3895
Daniel Dunbard18049a2009-04-07 21:16:11 +00003896 // Forward -f options with positive and negative forms; we translate
3897 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003898 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3899 StringRef fname = A->getValue();
3900 if (!llvm::sys::fs::exists(fname))
3901 D.Diag(diag::err_drv_no_such_file) << fname;
3902 else
3903 A->render(Args, CmdArgs);
3904 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003905
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003906 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003907 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003908 CmdArgs.push_back("-fapple-kext");
3909 if (!Args.hasArg(options::OPT_fbuiltin))
3910 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003911 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003912 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003913 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003914 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003915 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003916
Nuno Lopes13c88c72009-12-16 16:59:22 +00003917 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3918 options::OPT_fno_assume_sane_operator_new))
3919 CmdArgs.push_back("-fno-assume-sane-operator-new");
3920
Daniel Dunbar4930e332009-11-17 08:07:36 +00003921 // -fblocks=0 is default.
3922 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003923 getToolChain().IsBlocksDefault()) ||
3924 (Args.hasArg(options::OPT_fgnu_runtime) &&
3925 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3926 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003927 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003928
3929 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3930 !getToolChain().hasBlocksRuntime())
3931 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003932 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003933
Richard Smithffb65082014-09-30 23:10:19 +00003934 // -fmodules enables modules (off by default).
3935 // Users can pass -fno-cxx-modules to turn off modules support for
3936 // C++/Objective-C++ programs, which is a little less mature.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003937 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003938 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3939 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3940 options::OPT_fno_cxx_modules,
Richard Smithffb65082014-09-30 23:10:19 +00003941 true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003942 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003943 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003944 HaveModules = true;
3945 }
3946 }
3947
Daniel Jasper07e6c402013-08-05 20:26:17 +00003948 // -fmodule-maps enables module map processing (off by default) for header
3949 // checking. It is implied by -fmodules.
3950 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3951 false)) {
3952 CmdArgs.push_back("-fmodule-maps");
3953 }
3954
Daniel Jasperac42b752013-10-21 06:34:34 +00003955 // -fmodules-decluse checks that modules used are declared so (off by
3956 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003957 if (Args.hasFlag(options::OPT_fmodules_decluse,
3958 options::OPT_fno_modules_decluse,
3959 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003960 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003961 }
3962
Daniel Jasper962b38e2014-04-11 11:47:45 +00003963 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3964 // all #included headers are part of modules.
3965 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3966 options::OPT_fno_modules_strict_decluse,
3967 false)) {
3968 CmdArgs.push_back("-fmodules-strict-decluse");
3969 }
3970
Manuel Klimekd2e8b042015-02-20 11:44:41 +00003971 // -fno-implicit-modules turns off implicitly compiling modules on demand.
3972 if (!Args.hasFlag(options::OPT_fimplicit_modules,
3973 options::OPT_fno_implicit_modules)) {
3974 CmdArgs.push_back("-fno-implicit-modules");
3975 }
3976
Daniel Jasperac42b752013-10-21 06:34:34 +00003977 // -fmodule-name specifies the module that is currently being built (or
3978 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00003979 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00003980
Richard Smith9887d792014-10-17 01:42:53 +00003981 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00003982 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00003983 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00003984
Richard Smithe842a472014-10-22 02:05:46 +00003985 // -fmodule-file can be used to specify files containing precompiled modules.
3986 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3987
3988 // -fmodule-cache-path specifies where our implicitly-built module files
3989 // should be written.
Justin Bognera88f0122014-06-20 22:59:50 +00003990 SmallString<128> ModuleCachePath;
3991 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3992 ModuleCachePath = A->getValue();
3993 if (HaveModules) {
3994 if (C.isForDiagnostics()) {
3995 // When generating crash reports, we want to emit the modules along with
3996 // the reproduction sources, so we ignore any provided module path.
3997 ModuleCachePath = Output.getFilename();
3998 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3999 llvm::sys::path::append(ModuleCachePath, "modules");
4000 } else if (ModuleCachePath.empty()) {
4001 // No module path was provided: use the default.
4002 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
4003 ModuleCachePath);
Ben Langmuir3b7b5402015-02-03 19:28:37 +00004004 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang.");
4005 appendUserToPath(ModuleCachePath);
Justin Bognera88f0122014-06-20 22:59:50 +00004006 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
4007 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004008 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00004009 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
4010 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
4011 }
4012
4013 // When building modules and generating crashdumps, we need to dump a module
4014 // dependency VFS alongside the output.
4015 if (HaveModules && C.isForDiagnostics()) {
4016 SmallString<128> VFSDir(Output.getFilename());
4017 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004018 // Add the cache directory as a temp so the crash diagnostics pick it up.
4019 C.addTempFile(Args.MakeArgString(VFSDir));
4020
Justin Bognera88f0122014-06-20 22:59:50 +00004021 llvm::sys::path::append(VFSDir, "vfs");
4022 CmdArgs.push_back("-module-dependency-dir");
4023 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004024 }
4025
Richard Smith9887d792014-10-17 01:42:53 +00004026 if (HaveModules)
4027 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004028
Douglas Gregor35b04d62013-02-07 19:01:24 +00004029 // Pass through all -fmodules-ignore-macro arguments.
4030 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004031 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4032 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004033
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004034 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4035
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004036 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4037 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4038 D.Diag(diag::err_drv_argument_not_allowed_with)
4039 << A->getAsString(Args) << "-fbuild-session-timestamp";
4040
4041 llvm::sys::fs::file_status Status;
4042 if (llvm::sys::fs::status(A->getValue(), Status))
4043 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004044 CmdArgs.push_back(Args.MakeArgString(
4045 "-fbuild-session-timestamp=" +
4046 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004047 }
4048
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004049 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004050 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4051 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004052 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4053
4054 Args.AddLastArg(CmdArgs,
4055 options::OPT_fmodules_validate_once_per_build_session);
4056 }
4057
Ben Langmuirdcf73862014-03-12 00:06:17 +00004058 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4059
John McCalldfea9982010-04-09 19:12:06 +00004060 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004061 if (Args.hasFlag(options::OPT_fno_access_control,
4062 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00004063 false))
John McCall3155f572010-04-09 19:03:51 +00004064 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004065
Anders Carlssond470fef2010-11-21 00:09:52 +00004066 // -felide-constructors is the default.
4067 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4068 options::OPT_felide_constructors,
4069 false))
4070 CmdArgs.push_back("-fno-elide-constructors");
4071
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004072 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004073
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004074 if (KernelOrKext || (types::isCXX(InputType) &&
4075 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4076 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004077 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004078
Tony Linthicum76329bf2011-12-12 21:14:55 +00004079 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004080 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00004081 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004082 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00004083 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004084 CmdArgs.push_back("-fshort-enums");
4085
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004086 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004087 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004088 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004089 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00004090
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004091 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004092 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4093 options::OPT_fno_use_cxa_atexit,
4094 !IsWindowsCygnus && !IsWindowsGNU &&
4095 getToolChain().getArch() != llvm::Triple::hexagon &&
4096 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004097 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004098 CmdArgs.push_back("-fno-use-cxa-atexit");
4099
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004100 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004101 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004102 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004103 CmdArgs.push_back("-fms-extensions");
4104
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004105 // -fno-use-line-directives is default.
4106 if (Args.hasFlag(options::OPT_fuse_line_directives,
4107 options::OPT_fno_use_line_directives, false))
4108 CmdArgs.push_back("-fuse-line-directives");
4109
Francois Pichet1b4f1632011-09-17 04:32:15 +00004110 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004111 if (Args.hasFlag(options::OPT_fms_compatibility,
4112 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004113 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
4114 options::OPT_fno_ms_extensions,
4115 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004116 CmdArgs.push_back("-fms-compatibility");
4117
David Majnemerc371ff02015-03-22 08:39:22 +00004118 // -fms-compatibility-version=18.00 is default.
4119 VersionTuple MSVT;
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004120 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
David Majnemerc371ff02015-03-22 08:39:22 +00004121 IsWindowsMSVC) ||
4122 Args.hasArg(options::OPT_fmsc_version) ||
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00004123 Args.hasArg(options::OPT_fms_compatibility_version)) {
4124 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
4125 const Arg *MSCompatibilityVersion =
4126 Args.getLastArg(options::OPT_fms_compatibility_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004127
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00004128 if (MSCVersion && MSCompatibilityVersion)
4129 D.Diag(diag::err_drv_argument_not_allowed_with)
4130 << MSCVersion->getAsString(Args)
4131 << MSCompatibilityVersion->getAsString(Args);
4132
David Majnemerc371ff02015-03-22 08:39:22 +00004133 if (MSCompatibilityVersion) {
4134 if (MSVT.tryParse(MSCompatibilityVersion->getValue()))
4135 D.Diag(diag::err_drv_invalid_value)
4136 << MSCompatibilityVersion->getAsString(Args)
4137 << MSCompatibilityVersion->getValue();
4138 } else if (MSCVersion) {
4139 unsigned Version = 0;
4140 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version))
4141 D.Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
4142 << MSCVersion->getValue();
4143 MSVT = getMSCompatibilityVersion(Version);
4144 } else {
4145 MSVT = VersionTuple(18);
4146 }
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00004147
David Majnemerc371ff02015-03-22 08:39:22 +00004148 CmdArgs.push_back(
4149 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00004150 }
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004151
Eric Christopher5ecce122013-02-18 00:38:31 +00004152 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004153 if (Args.hasFlag(options::OPT_fborland_extensions,
4154 options::OPT_fno_borland_extensions, false))
4155 CmdArgs.push_back("-fborland-extensions");
4156
David Majnemerc371ff02015-03-22 08:39:22 +00004157 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4158 // than 19.
4159 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4160 options::OPT_fno_threadsafe_statics,
4161 !IsWindowsMSVC || MSVT.getMajor() >= 19))
4162 CmdArgs.push_back("-fno-threadsafe-statics");
4163
Francois Pichet02744872011-09-01 16:38:08 +00004164 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4165 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004166 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004167 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004168 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004169
Chandler Carruthe03aa552010-04-17 20:17:31 +00004170 // -fgnu-keywords default varies depending on language; only pass if
4171 // specified.
4172 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004173 options::OPT_fno_gnu_keywords))
4174 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004175
Rafael Espindola922a6242011-06-02 17:30:53 +00004176 if (Args.hasFlag(options::OPT_fgnu89_inline,
4177 options::OPT_fno_gnu89_inline,
4178 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004179 CmdArgs.push_back("-fgnu89-inline");
4180
Chad Rosier9c76d242012-03-15 22:31:42 +00004181 if (Args.hasArg(options::OPT_fno_inline))
4182 CmdArgs.push_back("-fno-inline");
4183
Chad Rosier64d6be92012-03-06 21:17:19 +00004184 if (Args.hasArg(options::OPT_fno_inline_functions))
4185 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004186
John McCall5fb5df92012-06-20 06:18:46 +00004187 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004188
John McCall5fb5df92012-06-20 06:18:46 +00004189 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004190 // legacy is the default. Except for deployment taget of 10.5,
4191 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4192 // gets ignored silently.
4193 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004194 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4195 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004196 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004197 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004198 if (getToolChain().UseObjCMixedDispatch())
4199 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4200 else
4201 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4202 }
4203 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004204
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004205 // When ObjectiveC legacy runtime is in effect on MacOSX,
4206 // turn on the option to do Array/Dictionary subscripting
4207 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004208 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
4209 getToolChain().getTriple().isMacOSX() &&
4210 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4211 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004212 objcRuntime.isNeXTFamily())
4213 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4214
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004215 // -fencode-extended-block-signature=1 is default.
4216 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4217 CmdArgs.push_back("-fencode-extended-block-signature");
4218 }
4219
John McCall24fc0de2011-07-06 00:26:06 +00004220 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4221 // NOTE: This logic is duplicated in ToolChains.cpp.
4222 bool ARC = isObjCAutoRefCount(Args);
4223 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004224 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004225
John McCall24fc0de2011-07-06 00:26:06 +00004226 CmdArgs.push_back("-fobjc-arc");
4227
Chandler Carruth491db322011-11-04 07:34:47 +00004228 // FIXME: It seems like this entire block, and several around it should be
4229 // wrapped in isObjC, but for now we just use it here as this is where it
4230 // was being used previously.
4231 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4232 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4233 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4234 else
4235 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4236 }
4237
John McCall24fc0de2011-07-06 00:26:06 +00004238 // Allow the user to enable full exceptions code emission.
4239 // We define off for Objective-CC, on for Objective-C++.
4240 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4241 options::OPT_fno_objc_arc_exceptions,
4242 /*default*/ types::isCXX(InputType)))
4243 CmdArgs.push_back("-fobjc-arc-exceptions");
4244 }
4245
4246 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4247 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004248 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004249 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004250
John McCall24fc0de2011-07-06 00:26:06 +00004251 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4252 // takes precedence.
4253 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4254 if (!GCArg)
4255 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4256 if (GCArg) {
4257 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004258 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00004259 << GCArg->getAsString(Args);
4260 } else if (getToolChain().SupportsObjCGC()) {
4261 GCArg->render(Args, CmdArgs);
4262 } else {
4263 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004264 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00004265 << GCArg->getAsString(Args);
4266 }
4267 }
4268
Bob Wilsonb111ec92015-03-02 19:01:14 +00004269 if (Args.hasFlag(options::OPT_fapplication_extension,
4270 options::OPT_fno_application_extension, false))
4271 CmdArgs.push_back("-fapplication-extension");
4272
Reid Klecknerc542d372014-06-27 17:02:02 +00004273 // Handle GCC-style exception args.
4274 if (!C.getDriver().IsCLMode())
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004275 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext,
Reid Klecknerc542d372014-06-27 17:02:02 +00004276 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004277
4278 if (getToolChain().UseSjLjExceptions())
4279 CmdArgs.push_back("-fsjlj-exceptions");
4280
4281 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004282 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4283 options::OPT_fno_assume_sane_operator_new))
4284 CmdArgs.push_back("-fno-assume-sane-operator-new");
4285
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004286 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4287 // most platforms.
4288 if (Args.hasFlag(options::OPT_fsized_deallocation,
4289 options::OPT_fno_sized_deallocation, false))
4290 CmdArgs.push_back("-fsized-deallocation");
4291
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004292 // -fconstant-cfstrings is default, and may be subject to argument translation
4293 // on Darwin.
4294 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4295 options::OPT_fno_constant_cfstrings) ||
4296 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4297 options::OPT_mno_constant_cfstrings))
4298 CmdArgs.push_back("-fno-constant-cfstrings");
4299
John Thompsoned4e2952009-11-05 20:14:16 +00004300 // -fshort-wchar default varies depending on platform; only
4301 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004302 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4303 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004304 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004305
Hans Wennborg28c96312013-07-31 23:39:13 +00004306 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004307 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004308 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00004309 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004310 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004311
Daniel Dunbar096ed292011-10-05 21:04:55 +00004312 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4313 // -fno-pack-struct doesn't apply to -fpack-struct=.
4314 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004315 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004316 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004317 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004318 } else if (Args.hasFlag(options::OPT_fpack_struct,
4319 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004320 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004321 }
4322
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004323 // Handle -fmax-type-align=N and -fno-type-align
4324 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4325 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4326 if (!SkipMaxTypeAlign) {
4327 std::string MaxTypeAlignStr = "-fmax-type-align=";
4328 MaxTypeAlignStr += A->getValue();
4329 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4330 }
4331 } else if (getToolChain().getTriple().isOSDarwin()) {
4332 if (!SkipMaxTypeAlign) {
4333 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4334 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4335 }
4336 }
4337
Robert Lytton0e076492013-08-13 09:43:10 +00004338 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004339 if (!Args.hasArg(options::OPT_fcommon))
4340 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00004341 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004342 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00004343
Daniel Dunbard18049a2009-04-07 21:16:11 +00004344 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004345 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004346 CmdArgs.push_back("-fno-common");
4347
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004348 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004349 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004350 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004351 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004352 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004353 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4354
Daniel Dunbar6358d682010-10-15 22:30:42 +00004355 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4356 if (!Args.hasFlag(options::OPT_ffor_scope,
4357 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004358 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00004359 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4360
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004361 // -finput_charset=UTF-8 is default. Reject others
4362 if (Arg *inputCharset = Args.getLastArg(
4363 options::OPT_finput_charset_EQ)) {
4364 StringRef value = inputCharset->getValue();
4365 if (value != "UTF-8")
4366 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
4367 }
4368
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004369 // -fexec_charset=UTF-8 is default. Reject others
4370 if (Arg *execCharset = Args.getLastArg(
4371 options::OPT_fexec_charset_EQ)) {
4372 StringRef value = execCharset->getValue();
4373 if (value != "UTF-8")
4374 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
4375 }
4376
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004377 // -fcaret-diagnostics is default.
4378 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4379 options::OPT_fno_caret_diagnostics, true))
4380 CmdArgs.push_back("-fno-caret-diagnostics");
4381
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004382 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004383 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004384 options::OPT_fno_diagnostics_fixit_info))
4385 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004386
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004387 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004388 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004389 options::OPT_fno_diagnostics_show_option))
4390 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004391
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004392 if (const Arg *A =
4393 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4394 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00004395 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00004396 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004397
Douglas Gregor643c9222011-05-21 17:07:29 +00004398 if (const Arg *A =
4399 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4400 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00004401 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00004402 }
4403
Chandler Carruthb6766f02011-03-27 01:50:55 +00004404 if (Arg *A = Args.getLastArg(
4405 options::OPT_fdiagnostics_show_note_include_stack,
4406 options::OPT_fno_diagnostics_show_note_include_stack)) {
4407 if (A->getOption().matches(
4408 options::OPT_fdiagnostics_show_note_include_stack))
4409 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4410 else
4411 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4412 }
4413
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004414 // Color diagnostics are the default, unless the terminal doesn't support
4415 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00004416 // Support both clang's -f[no-]color-diagnostics and gcc's
4417 // -f[no-]diagnostics-colors[=never|always|auto].
4418 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004419 for (const auto &Arg : Args) {
4420 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00004421 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4422 !O.matches(options::OPT_fdiagnostics_color) &&
4423 !O.matches(options::OPT_fno_color_diagnostics) &&
4424 !O.matches(options::OPT_fno_diagnostics_color) &&
4425 !O.matches(options::OPT_fdiagnostics_color_EQ))
4426 continue;
4427
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004428 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00004429 if (O.matches(options::OPT_fcolor_diagnostics) ||
4430 O.matches(options::OPT_fdiagnostics_color)) {
4431 ShowColors = Colors_On;
4432 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4433 O.matches(options::OPT_fno_diagnostics_color)) {
4434 ShowColors = Colors_Off;
4435 } else {
4436 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004437 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00004438 if (value == "always")
4439 ShowColors = Colors_On;
4440 else if (value == "never")
4441 ShowColors = Colors_Off;
4442 else if (value == "auto")
4443 ShowColors = Colors_Auto;
4444 else
4445 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4446 << ("-fdiagnostics-color=" + value).str();
4447 }
4448 }
4449 if (ShowColors == Colors_On ||
4450 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00004451 CmdArgs.push_back("-fcolor-diagnostics");
4452
Nico Rieck7857d462013-09-11 00:38:02 +00004453 if (Args.hasArg(options::OPT_fansi_escape_codes))
4454 CmdArgs.push_back("-fansi-escape-codes");
4455
Daniel Dunbardb097022009-06-08 21:13:54 +00004456 if (!Args.hasFlag(options::OPT_fshow_source_location,
4457 options::OPT_fno_show_source_location))
4458 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004459
Douglas Gregor643c9222011-05-21 17:07:29 +00004460 if (!Args.hasFlag(options::OPT_fshow_column,
4461 options::OPT_fno_show_column,
4462 true))
4463 CmdArgs.push_back("-fno-show-column");
4464
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004465 if (!Args.hasFlag(options::OPT_fspell_checking,
4466 options::OPT_fno_spell_checking))
4467 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004468
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004469
Chad Rosierc8e56e82012-12-05 21:08:21 +00004470 // -fno-asm-blocks is default.
4471 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4472 false))
4473 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004474
Steven Wucb0d13f2015-01-16 23:05:28 +00004475 // -fgnu-inline-asm is default.
4476 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4477 options::OPT_fno_gnu_inline_asm, true))
4478 CmdArgs.push_back("-fno-gnu-inline-asm");
4479
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004480 // Enable vectorization per default according to the optimization level
4481 // selected. For optimization levels that want vectorization we use the alias
4482 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004483 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004484 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004485 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004486 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004487 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004488 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004489
Chad Rosier136d67d2014-04-28 19:30:57 +00004490 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004491 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4492 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004493 options::OPT_fslp_vectorize;
4494 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004495 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004496 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004497
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004498 // -fno-slp-vectorize-aggressive is default.
4499 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004500 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004501 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004502
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004503 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4504 A->render(Args, CmdArgs);
4505
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004506 // -fdollars-in-identifiers default varies depending on platform and
4507 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004508 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004509 options::OPT_fno_dollars_in_identifiers)) {
4510 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004511 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004512 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004513 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004514 }
4515
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004516 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4517 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004518 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004519 options::OPT_fno_unit_at_a_time)) {
4520 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004521 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004522 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004523
Eli Friedman055c9702011-11-02 01:53:16 +00004524 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4525 options::OPT_fno_apple_pragma_pack, false))
4526 CmdArgs.push_back("-fapple-pragma-pack");
4527
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004528 // le32-specific flags:
4529 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4530 // by default.
4531 if (getToolChain().getArch() == llvm::Triple::le32) {
4532 CmdArgs.push_back("-fno-math-builtin");
4533 }
4534
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004535 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004536 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004537 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004538#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004539 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004540 (getToolChain().getArch() == llvm::Triple::arm ||
4541 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004542 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4543 CmdArgs.push_back("-fno-builtin-strcat");
4544 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4545 CmdArgs.push_back("-fno-builtin-strcpy");
4546 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004547#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004548
Justin Bognera88f0122014-06-20 22:59:50 +00004549 // Enable rewrite includes if the user's asked for it or if we're generating
4550 // diagnostics.
4551 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4552 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004553 if (Args.hasFlag(options::OPT_frewrite_includes,
4554 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004555 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004556 CmdArgs.push_back("-frewrite-includes");
4557
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004558 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004559 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004560 options::OPT_traditional_cpp)) {
4561 if (isa<PreprocessJobAction>(JA))
4562 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004563 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004564 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004565 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004566
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004567 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004568 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004569
4570 // Handle serialized diagnostics.
4571 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4572 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004573 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004574 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004575
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004576 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4577 CmdArgs.push_back("-fretain-comments-from-system-headers");
4578
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004579 // Forward -fcomment-block-commands to -cc1.
4580 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004581 // Forward -fparse-all-comments to -cc1.
4582 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004583
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004584 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4585 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004586 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Bob Wilson23a55f12014-12-21 07:00:00 +00004587 bool OptDisabled = false;
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004588 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4589 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004590 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004591
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004592 // We translate this by hand to the -cc1 argument, since nightly test uses
4593 // it and developers have been trained to spell it with -mllvm.
Bob Wilson23a55f12014-12-21 07:00:00 +00004594 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004595 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00004596 OptDisabled = true;
4597 } else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004598 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004599 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004600
Bob Wilson23a55f12014-12-21 07:00:00 +00004601 // With -save-temps, we want to save the unoptimized bitcode output from the
4602 // CompileJobAction, so disable optimizations if they are not already
4603 // disabled.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00004604 if (C.getDriver().isSaveTempsEnabled() && !OptDisabled &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004605 isa<CompileJobAction>(JA))
4606 CmdArgs.push_back("-disable-llvm-optzns");
4607
Daniel Dunbard67a3222009-03-30 06:36:42 +00004608 if (Output.getType() == types::TY_Dependencies) {
4609 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004610 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004611 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004612 CmdArgs.push_back(Output.getFilename());
4613 } else {
4614 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004615 }
4616
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004617 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004618 addDashXForInput(Args, II, CmdArgs);
4619
Daniel Dunbarb440f562010-08-02 02:38:21 +00004620 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004621 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004622 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004623 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004624 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004625
Chris Lattnere9d7d782009-11-03 19:50:27 +00004626 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4627
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004628 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004629
4630 // Optionally embed the -cc1 level arguments into the debug info, for build
4631 // analysis.
4632 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004633 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004634 for (const auto &Arg : Args)
4635 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004636
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004637 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004638 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004639 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004640 SmallString<128> EscapedArg;
4641 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004642 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00004643 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004644 }
4645 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00004646 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004647 }
4648
Eric Christopherd3804002013-02-22 20:12:52 +00004649 // Add the split debug info name to the command lines here so we
4650 // can propagate it to the backend.
4651 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004652 getToolChain().getTriple().isOSLinux() &&
Bob Wilson23a55f12014-12-21 07:00:00 +00004653 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4654 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004655 const char *SplitDwarfOut;
4656 if (SplitDwarf) {
4657 CmdArgs.push_back("-split-dwarf-file");
4658 SplitDwarfOut = SplitDebugName(Args, Inputs);
4659 CmdArgs.push_back(SplitDwarfOut);
4660 }
4661
4662 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004663 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004664 Output.getType() == types::TY_Object &&
4665 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00004666 auto CLCommand =
4667 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4668 C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4669 std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004670 } else {
David Blaikiec11bf802014-09-04 16:04:28 +00004671 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00004672 }
4673
Daniel Dunbar17731772009-03-23 19:03:36 +00004674
Eric Christopherf1545832013-02-22 23:50:16 +00004675 // Handle the debug info splitting at object creation time if we're
4676 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004677 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00004678 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004679 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004680
Roman Divacky178e01602011-02-10 16:52:03 +00004681 if (Arg *A = Args.getLastArg(options::OPT_pg))
4682 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004683 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004684 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004685
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004686 // Claim some arguments which clang supports automatically.
4687
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004688 // -fpch-preprocess is used with gcc to add a special marker in the output to
4689 // include the PCH file. Clang's PTH solution is completely transparent, so we
4690 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004691 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004692
Daniel Dunbar17731772009-03-23 19:03:36 +00004693 // Claim some arguments which clang doesn't support, but we don't
4694 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004695 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4696 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004697
Rafael Espindolab0092d72013-09-04 19:37:35 +00004698 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004699 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004700}
4701
John McCall5fb5df92012-06-20 06:18:46 +00004702/// Add options related to the Objective-C runtime/ABI.
4703///
4704/// Returns true if the runtime is non-fragile.
4705ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4706 ArgStringList &cmdArgs,
4707 RewriteKind rewriteKind) const {
4708 // Look for the controlling runtime option.
4709 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4710 options::OPT_fgnu_runtime,
4711 options::OPT_fobjc_runtime_EQ);
4712
4713 // Just forward -fobjc-runtime= to the frontend. This supercedes
4714 // options about fragility.
4715 if (runtimeArg &&
4716 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4717 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004718 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004719 if (runtime.tryParse(value)) {
4720 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4721 << value;
4722 }
4723
4724 runtimeArg->render(args, cmdArgs);
4725 return runtime;
4726 }
4727
4728 // Otherwise, we'll need the ABI "version". Version numbers are
4729 // slightly confusing for historical reasons:
4730 // 1 - Traditional "fragile" ABI
4731 // 2 - Non-fragile ABI, version 1
4732 // 3 - Non-fragile ABI, version 2
4733 unsigned objcABIVersion = 1;
4734 // If -fobjc-abi-version= is present, use that to set the version.
4735 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004736 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004737 if (value == "1")
4738 objcABIVersion = 1;
4739 else if (value == "2")
4740 objcABIVersion = 2;
4741 else if (value == "3")
4742 objcABIVersion = 3;
4743 else
4744 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4745 << value;
4746 } else {
4747 // Otherwise, determine if we are using the non-fragile ABI.
4748 bool nonFragileABIIsDefault =
4749 (rewriteKind == RK_NonFragile ||
4750 (rewriteKind == RK_None &&
4751 getToolChain().IsObjCNonFragileABIDefault()));
4752 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4753 options::OPT_fno_objc_nonfragile_abi,
4754 nonFragileABIIsDefault)) {
4755 // Determine the non-fragile ABI version to use.
4756#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4757 unsigned nonFragileABIVersion = 1;
4758#else
4759 unsigned nonFragileABIVersion = 2;
4760#endif
4761
4762 if (Arg *abiArg = args.getLastArg(
4763 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004764 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004765 if (value == "1")
4766 nonFragileABIVersion = 1;
4767 else if (value == "2")
4768 nonFragileABIVersion = 2;
4769 else
4770 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4771 << value;
4772 }
4773
4774 objcABIVersion = 1 + nonFragileABIVersion;
4775 } else {
4776 objcABIVersion = 1;
4777 }
4778 }
4779
4780 // We don't actually care about the ABI version other than whether
4781 // it's non-fragile.
4782 bool isNonFragile = objcABIVersion != 1;
4783
4784 // If we have no runtime argument, ask the toolchain for its default runtime.
4785 // However, the rewriter only really supports the Mac runtime, so assume that.
4786 ObjCRuntime runtime;
4787 if (!runtimeArg) {
4788 switch (rewriteKind) {
4789 case RK_None:
4790 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4791 break;
4792 case RK_Fragile:
4793 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4794 break;
4795 case RK_NonFragile:
4796 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4797 break;
4798 }
4799
4800 // -fnext-runtime
4801 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4802 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004803 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004804 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4805
4806 // Otherwise, build for a generic macosx port.
4807 } else {
4808 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4809 }
4810
4811 // -fgnu-runtime
4812 } else {
4813 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004814 // Legacy behaviour is to target the gnustep runtime if we are i
4815 // non-fragile mode or the GCC runtime in fragile mode.
4816 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004817 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004818 else
4819 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004820 }
4821
4822 cmdArgs.push_back(args.MakeArgString(
4823 "-fobjc-runtime=" + runtime.getAsString()));
4824 return runtime;
4825}
4826
Reid Klecknerc542d372014-06-27 17:02:02 +00004827static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4828 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4829 I += HaveDash;
4830 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004831}
Reid Klecknerc542d372014-06-27 17:02:02 +00004832
4833struct EHFlags {
4834 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4835 bool Synch;
4836 bool Asynch;
4837 bool NoExceptC;
4838};
4839
4840/// /EH controls whether to run destructor cleanups when exceptions are
4841/// thrown. There are three modifiers:
4842/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4843/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4844/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4845/// - c: Assume that extern "C" functions are implicitly noexcept. This
4846/// modifier is an optimization, so we ignore it for now.
4847/// The default is /EHs-c-, meaning cleanups are disabled.
4848static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4849 EHFlags EH;
4850 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4851 for (auto EHVal : EHArgs) {
4852 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4853 switch (EHVal[I]) {
4854 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4855 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4856 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4857 default: break;
4858 }
4859 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4860 break;
4861 }
4862 }
4863 return EH;
4864}
4865
Hans Wennborg75958c42013-08-08 00:17:41 +00004866void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4867 unsigned RTOptionID = options::OPT__SLASH_MT;
4868
Hans Wennborgf1a74252013-09-10 20:18:04 +00004869 if (Args.hasArg(options::OPT__SLASH_LDd))
4870 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4871 // but defining _DEBUG is sticky.
4872 RTOptionID = options::OPT__SLASH_MTd;
4873
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004874 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004875 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004876
Hans Wennborg75958c42013-08-08 00:17:41 +00004877 switch(RTOptionID) {
4878 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004879 if (Args.hasArg(options::OPT__SLASH_LDd))
4880 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004881 CmdArgs.push_back("-D_MT");
4882 CmdArgs.push_back("-D_DLL");
4883 CmdArgs.push_back("--dependent-lib=msvcrt");
4884 break;
4885 case options::OPT__SLASH_MDd:
4886 CmdArgs.push_back("-D_DEBUG");
4887 CmdArgs.push_back("-D_MT");
4888 CmdArgs.push_back("-D_DLL");
4889 CmdArgs.push_back("--dependent-lib=msvcrtd");
4890 break;
4891 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004892 if (Args.hasArg(options::OPT__SLASH_LDd))
4893 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004894 CmdArgs.push_back("-D_MT");
4895 CmdArgs.push_back("--dependent-lib=libcmt");
4896 break;
4897 case options::OPT__SLASH_MTd:
4898 CmdArgs.push_back("-D_DEBUG");
4899 CmdArgs.push_back("-D_MT");
4900 CmdArgs.push_back("--dependent-lib=libcmtd");
4901 break;
4902 default:
4903 llvm_unreachable("Unexpected option ID.");
4904 }
4905
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004906 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4907 // users want. The /Za flag to cl.exe turns this off, but it's not
4908 // implemented in clang.
4909 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004910
Hans Wennborg8858a032014-07-21 23:42:07 +00004911 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
4912 // would produce interleaved output, so ignore /showIncludes in such cases.
4913 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
4914 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4915 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004916
David Majnemerf6072342014-07-01 22:24:56 +00004917 // This controls whether or not we emit RTTI data for polymorphic types.
4918 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4919 /*default=*/false))
4920 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004921
Reid Klecknerc542d372014-06-27 17:02:02 +00004922 const Driver &D = getToolChain().getDriver();
4923 EHFlags EH = parseClangCLEHFlags(D, Args);
4924 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00004925 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00004926 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00004927 CmdArgs.push_back("-fexceptions");
4928 }
Reid Klecknerc542d372014-06-27 17:02:02 +00004929
Hans Wennborge50cec32014-06-13 20:59:54 +00004930 // /EP should expand to -E -P.
4931 if (Args.hasArg(options::OPT__SLASH_EP)) {
4932 CmdArgs.push_back("-E");
4933 CmdArgs.push_back("-P");
4934 }
4935
David Majnemera5b195a2015-02-14 01:35:12 +00004936 unsigned VolatileOptionID;
4937 if (getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
4938 getToolChain().getTriple().getArch() == llvm::Triple::x86)
4939 VolatileOptionID = options::OPT__SLASH_volatile_ms;
4940 else
4941 VolatileOptionID = options::OPT__SLASH_volatile_iso;
4942
4943 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
4944 VolatileOptionID = A->getOption().getID();
4945
4946 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
4947 CmdArgs.push_back("-fms-volatile");
4948
David Majnemer86c318f2014-02-11 21:05:00 +00004949 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4950 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4951 if (MostGeneralArg && BestCaseArg)
4952 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4953 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4954
4955 if (MostGeneralArg) {
4956 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4957 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4958 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4959
4960 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4961 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4962 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4963 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4964 << FirstConflict->getAsString(Args)
4965 << SecondConflict->getAsString(Args);
4966
4967 if (SingleArg)
4968 CmdArgs.push_back("-fms-memptr-rep=single");
4969 else if (MultipleArg)
4970 CmdArgs.push_back("-fms-memptr-rep=multiple");
4971 else
4972 CmdArgs.push_back("-fms-memptr-rep=virtual");
4973 }
4974
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004975 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4976 A->render(Args, CmdArgs);
4977
Hans Wennborg81f74482013-09-10 01:07:07 +00004978 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4979 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004980 if (Args.hasArg(options::OPT__SLASH_fallback))
4981 CmdArgs.push_back("msvc-fallback");
4982 else
4983 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004984 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004985}
4986
Hans Wennborg1da044a2014-06-26 19:59:02 +00004987visualstudio::Compile *Clang::getCLFallback() const {
4988 if (!CLFallback)
4989 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4990 return CLFallback.get();
4991}
4992
Daniel Sanders7f933f42015-01-30 17:35:23 +00004993void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
4994 ArgStringList &CmdArgs) const {
4995 StringRef CPUName;
4996 StringRef ABIName;
4997 const llvm::Triple &Triple = getToolChain().getTriple();
4998 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
4999
5000 CmdArgs.push_back("-target-abi");
5001 CmdArgs.push_back(ABIName.data());
5002}
5003
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005004void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005005 const InputInfo &Output,
5006 const InputInfoList &Inputs,
5007 const ArgList &Args,
5008 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005009 ArgStringList CmdArgs;
5010
5011 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5012 const InputInfo &Input = Inputs[0];
5013
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005014 // Don't warn about "clang -w -c foo.s"
5015 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005016 // and "clang -emit-llvm -c foo.s"
5017 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005018
Rafael Espindola577637a2015-01-03 00:06:04 +00005019 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005020
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005021 // Invoke ourselves in -cc1as mode.
5022 //
5023 // FIXME: Implement custom jobs for internal actions.
5024 CmdArgs.push_back("-cc1as");
5025
5026 // Add the "effective" target triple.
5027 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00005028 std::string TripleStr =
5029 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005030 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5031
5032 // Set the output mode, we currently only expect to be used as a real
5033 // assembler.
5034 CmdArgs.push_back("-filetype");
5035 CmdArgs.push_back("obj");
5036
Eric Christopher45f2e712012-12-18 00:31:10 +00005037 // Set the main file name, so that debug info works even with
5038 // -save-temps or preprocessed assembly.
5039 CmdArgs.push_back("-main-file-name");
5040 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
5041
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005042 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005043 const llvm::Triple &Triple = getToolChain().getTriple();
5044 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005045 if (!CPU.empty()) {
5046 CmdArgs.push_back("-target-cpu");
5047 CmdArgs.push_back(Args.MakeArgString(CPU));
5048 }
5049
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005050 // Add the target features
5051 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00005052 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005053
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005054 // Ignore explicit -force_cpusubtype_ALL option.
5055 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005056
Eric Christopherfc3ee562012-01-10 00:38:01 +00005057 // Determine the original source input.
5058 const Action *SourceAction = &JA;
5059 while (SourceAction->getKind() != Action::InputClass) {
5060 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5061 SourceAction = SourceAction->getInputs()[0];
5062 }
5063
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005064 // Forward -g and handle debug info related flags, assuming we are dealing
5065 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005066 if (SourceAction->getType() == types::TY_Asm ||
5067 SourceAction->getType() == types::TY_PP_Asm) {
5068 Args.ClaimAllArgs(options::OPT_g_Group);
5069 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5070 if (!A->getOption().matches(options::OPT_g0))
5071 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005072
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005073 if (Args.hasArg(options::OPT_gdwarf_2))
5074 CmdArgs.push_back("-gdwarf-2");
5075 if (Args.hasArg(options::OPT_gdwarf_3))
5076 CmdArgs.push_back("-gdwarf-3");
5077 if (Args.hasArg(options::OPT_gdwarf_4))
5078 CmdArgs.push_back("-gdwarf-4");
5079
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005080 // Add the -fdebug-compilation-dir flag if needed.
5081 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005082
5083 // Set the AT_producer to the clang version when using the integrated
5084 // assembler on assembly source files.
5085 CmdArgs.push_back("-dwarf-debug-producer");
5086 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00005087 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005088
5089 // Optionally embed the -cc1as level arguments into the debug info, for build
5090 // analysis.
5091 if (getToolChain().UseDwarfDebugFlags()) {
5092 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005093 for (const auto &Arg : Args)
5094 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005095
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005096 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005097 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5098 Flags += Exec;
5099 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005100 SmallString<128> EscapedArg;
5101 EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005102 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005103 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005104 }
5105 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005106 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005107 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005108
5109 // FIXME: Add -static support, once we have it.
5110
Daniel Sanders7f933f42015-01-30 17:35:23 +00005111 // Add target specific flags.
5112 switch(getToolChain().getArch()) {
5113 default:
5114 break;
5115
5116 case llvm::Triple::mips:
5117 case llvm::Triple::mipsel:
5118 case llvm::Triple::mips64:
5119 case llvm::Triple::mips64el:
5120 AddMIPSTargetArgs(Args, CmdArgs);
5121 break;
5122 }
5123
David Blaikie372d9502014-01-17 03:17:40 +00005124 // Consume all the warning flags. Usually this would be handled more
5125 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5126 // doesn't handle that so rather than warning about unused flags that are
5127 // actually used, we'll lie by omission instead.
5128 // FIXME: Stop lying and consume only the appropriate driver flags
5129 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
5130 ie = Args.filtered_end();
5131 it != ie; ++it)
5132 (*it)->claim();
5133
David Blaikie9260ed62013-07-25 21:19:01 +00005134 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5135 getToolChain().getDriver());
5136
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005137 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005138
5139 assert(Output.isFilename() && "Unexpected lipo output.");
5140 CmdArgs.push_back("-o");
5141 CmdArgs.push_back(Output.getFilename());
5142
Daniel Dunbarb440f562010-08-02 02:38:21 +00005143 assert(Input.isFilename() && "Invalid input.");
5144 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005145
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005146 const char *Exec = getToolChain().getDriver().getClangProgramPath();
David Blaikiec11bf802014-09-04 16:04:28 +00005147 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00005148
5149 // Handle the debug info splitting at object creation time if we're
5150 // creating an object.
5151 // TODO: Currently only works on linux with newer objcopy.
5152 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005153 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005154 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
5155 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005156}
5157
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005158void GnuTool::anchor() {}
5159
Daniel Dunbara3246a02009-03-18 08:07:30 +00005160void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005161 const InputInfo &Output,
5162 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005163 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005164 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005165 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005166 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005167
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005168 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005169 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005170 // Don't forward any -g arguments to assembly steps.
5171 if (isa<AssembleJobAction>(JA) &&
5172 A->getOption().matches(options::OPT_g_Group))
5173 continue;
5174
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005175 // Don't forward any -W arguments to assembly and link steps.
5176 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5177 A->getOption().matches(options::OPT_W_Group))
5178 continue;
5179
Daniel Dunbar2da02722009-03-19 07:55:12 +00005180 // It is unfortunate that we have to claim here, as this means
5181 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005182 // platforms using a generic gcc, even if we are just using gcc
5183 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005184 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005185 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005186 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005187 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005188
Daniel Dunbar4e295052010-01-25 22:35:08 +00005189 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005190
5191 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005192 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005193 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005194 CmdArgs.push_back(
5195 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005196 }
5197
Daniel Dunbar5716d872009-05-02 21:41:52 +00005198 // Try to force gcc to match the tool chain we want, if we recognize
5199 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005200 //
5201 // FIXME: The triple class should directly provide the information we want
5202 // here.
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005203 llvm::Triple::ArchType Arch = getToolChain().getArch();
Rafael Espindola35ca7d92012-10-07 04:44:33 +00005204 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005205 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00005206 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5207 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00005208 CmdArgs.push_back("-m64");
5209
Daniel Dunbarb440f562010-08-02 02:38:21 +00005210 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005211 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005212 CmdArgs.push_back(Output.getFilename());
5213 } else {
5214 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005215 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005216 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005217
Tony Linthicum76329bf2011-12-12 21:14:55 +00005218 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5219 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005220
5221 // Only pass -x if gcc will understand it; otherwise hope gcc
5222 // understands the suffix correctly. The main use case this would go
5223 // wrong in is for linker inputs if they happened to have an odd
5224 // suffix; really the only way to get this to happen is a command
5225 // like '-x foobar a.c' which will treat a.c like a linker input.
5226 //
5227 // FIXME: For the linker case specifically, can we safely convert
5228 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005229 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005230 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005231 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5232 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005233 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005234 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005235 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005236 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005237 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005238 else if (II.getType() == types::TY_ModuleFile)
5239 D.Diag(diag::err_drv_no_module_support)
5240 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005241
Daniel Dunbara3246a02009-03-18 08:07:30 +00005242 if (types::canTypeBeUserSpecified(II.getType())) {
5243 CmdArgs.push_back("-x");
5244 CmdArgs.push_back(types::getTypeName(II.getType()));
5245 }
5246
Daniel Dunbarb440f562010-08-02 02:38:21 +00005247 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005248 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005249 else {
5250 const Arg &A = II.getInputArg();
5251
5252 // Reverse translate some rewritten options.
5253 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5254 CmdArgs.push_back("-lstdc++");
5255 continue;
5256 }
5257
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005258 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005259 A.render(Args, CmdArgs);
5260 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005261 }
5262
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005263 const std::string customGCCName = D.getCCCGenericGCCName();
5264 const char *GCCName;
5265 if (!customGCCName.empty())
5266 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005267 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005268 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005269 } else
5270 GCCName = "gcc";
5271
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005272 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005273 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005274 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005275}
5276
Daniel Dunbar4e295052010-01-25 22:35:08 +00005277void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
5278 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005279 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005280}
5281
Daniel Dunbar4e295052010-01-25 22:35:08 +00005282void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
5283 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005284 const Driver &D = getToolChain().getDriver();
5285
Eric Christophercc7ff502015-01-29 00:56:17 +00005286 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005287 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005288 case types::TY_LLVM_IR:
5289 case types::TY_LTO_IR:
5290 case types::TY_LLVM_BC:
5291 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005292 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005293 break;
5294 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005295 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005296 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005297 case types::TY_Nothing:
5298 CmdArgs.push_back("-fsyntax-only");
5299 break;
5300 default:
5301 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005302 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005303}
5304
Daniel Dunbar4e295052010-01-25 22:35:08 +00005305void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
5306 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005307 // The types are (hopefully) good enough.
5308}
5309
Tony Linthicum76329bf2011-12-12 21:14:55 +00005310// Hexagon tools start.
5311void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
5312 ArgStringList &CmdArgs) const {
5313
5314}
5315void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5316 const InputInfo &Output,
5317 const InputInfoList &Inputs,
5318 const ArgList &Args,
5319 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005320 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005321
5322 const Driver &D = getToolChain().getDriver();
5323 ArgStringList CmdArgs;
5324
5325 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00005326 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005327 CmdArgs.push_back(Args.MakeArgString(MarchString));
5328
5329 RenderExtraToolArgs(JA, CmdArgs);
5330
5331 if (Output.isFilename()) {
5332 CmdArgs.push_back("-o");
5333 CmdArgs.push_back(Output.getFilename());
5334 } else {
5335 assert(Output.isNothing() && "Unexpected output");
5336 CmdArgs.push_back("-fsyntax-only");
5337 }
5338
Matthew Curtise8f80a12012-12-06 17:49:03 +00005339 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5340 if (!SmallDataThreshold.empty())
5341 CmdArgs.push_back(
5342 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005343
Matthew Curtise5df3812012-12-07 17:23:04 +00005344 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5345 options::OPT_Xassembler);
5346
Tony Linthicum76329bf2011-12-12 21:14:55 +00005347 // Only pass -x if gcc will understand it; otherwise hope gcc
5348 // understands the suffix correctly. The main use case this would go
5349 // wrong in is for linker inputs if they happened to have an odd
5350 // suffix; really the only way to get this to happen is a command
5351 // like '-x foobar a.c' which will treat a.c like a linker input.
5352 //
5353 // FIXME: For the linker case specifically, can we safely convert
5354 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005355 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005356 // Don't try to pass LLVM or AST inputs to a generic gcc.
5357 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5358 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5359 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5360 << getToolChain().getTripleString();
5361 else if (II.getType() == types::TY_AST)
5362 D.Diag(clang::diag::err_drv_no_ast_support)
5363 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005364 else if (II.getType() == types::TY_ModuleFile)
5365 D.Diag(diag::err_drv_no_module_support)
5366 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00005367
5368 if (II.isFilename())
5369 CmdArgs.push_back(II.getFilename());
5370 else
5371 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
5372 II.getInputArg().render(Args, CmdArgs);
5373 }
5374
5375 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005376 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
David Blaikiec11bf802014-09-04 16:04:28 +00005377 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005378}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005379
Tony Linthicum76329bf2011-12-12 21:14:55 +00005380void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
5381 ArgStringList &CmdArgs) const {
5382 // The types are (hopefully) good enough.
5383}
5384
5385void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
5386 const InputInfo &Output,
5387 const InputInfoList &Inputs,
5388 const ArgList &Args,
5389 const char *LinkingOutput) const {
5390
Matthew Curtise689b052012-12-06 15:46:07 +00005391 const toolchains::Hexagon_TC& ToolChain =
5392 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
5393 const Driver &D = ToolChain.getDriver();
5394
Tony Linthicum76329bf2011-12-12 21:14:55 +00005395 ArgStringList CmdArgs;
5396
Matthew Curtise689b052012-12-06 15:46:07 +00005397 //----------------------------------------------------------------------------
5398 //
5399 //----------------------------------------------------------------------------
5400 bool hasStaticArg = Args.hasArg(options::OPT_static);
5401 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00005402 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00005403 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5404 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5405 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5406 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005407
Matthew Curtise689b052012-12-06 15:46:07 +00005408 //----------------------------------------------------------------------------
5409 // Silence warnings for various options
5410 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00005411
Matthew Curtise689b052012-12-06 15:46:07 +00005412 Args.ClaimAllArgs(options::OPT_g_Group);
5413 Args.ClaimAllArgs(options::OPT_emit_llvm);
5414 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5415 // handled somewhere else.
5416 Args.ClaimAllArgs(options::OPT_static_libgcc);
5417
5418 //----------------------------------------------------------------------------
5419 //
5420 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005421 for (const auto &Opt : ToolChain.ExtraOpts)
5422 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005423
Matthew Curtisf10a5952012-12-06 14:16:43 +00005424 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5425 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00005426
Matthew Curtise689b052012-12-06 15:46:07 +00005427 if (buildingLib) {
5428 CmdArgs.push_back("-shared");
5429 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5430 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00005431 }
5432
Matthew Curtise689b052012-12-06 15:46:07 +00005433 if (hasStaticArg)
5434 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005435
Matthew Curtise8f80a12012-12-06 17:49:03 +00005436 if (buildPIE && !buildingLib)
5437 CmdArgs.push_back("-pie");
5438
5439 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
5440 if (!SmallDataThreshold.empty()) {
5441 CmdArgs.push_back(
5442 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
5443 }
5444
Matthew Curtise689b052012-12-06 15:46:07 +00005445 //----------------------------------------------------------------------------
5446 //
5447 //----------------------------------------------------------------------------
5448 CmdArgs.push_back("-o");
5449 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00005450
Matthew Curtise689b052012-12-06 15:46:07 +00005451 const std::string MarchSuffix = "/" + MarchString;
5452 const std::string G0Suffix = "/G0";
5453 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Samuel Antaoc909c992014-11-07 17:48:03 +00005454 const std::string RootDir =
5455 toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
Matthew Curtise689b052012-12-06 15:46:07 +00005456 const std::string StartFilesDir = RootDir
5457 + "hexagon/lib"
5458 + (buildingLib
5459 ? MarchG0Suffix : MarchSuffix);
5460
5461 //----------------------------------------------------------------------------
5462 // moslib
5463 //----------------------------------------------------------------------------
5464 std::vector<std::string> oslibs;
5465 bool hasStandalone= false;
5466
5467 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
5468 ie = Args.filtered_end(); it != ie; ++it) {
5469 (*it)->claim();
5470 oslibs.push_back((*it)->getValue());
5471 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005472 }
Matthew Curtise689b052012-12-06 15:46:07 +00005473 if (oslibs.empty()) {
5474 oslibs.push_back("standalone");
5475 hasStandalone = true;
5476 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005477
Matthew Curtise689b052012-12-06 15:46:07 +00005478 //----------------------------------------------------------------------------
5479 // Start Files
5480 //----------------------------------------------------------------------------
5481 if (incStdLib && incStartFiles) {
5482
5483 if (!buildingLib) {
5484 if (hasStandalone) {
5485 CmdArgs.push_back(
5486 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5487 }
5488 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5489 }
5490 std::string initObj = useShared ? "/initS.o" : "/init.o";
5491 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5492 }
5493
5494 //----------------------------------------------------------------------------
5495 // Library Search Paths
5496 //----------------------------------------------------------------------------
5497 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005498 for (const auto &LibPath : LibPaths)
5499 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00005500
5501 //----------------------------------------------------------------------------
5502 //
5503 //----------------------------------------------------------------------------
5504 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5505 Args.AddAllArgs(CmdArgs, options::OPT_e);
5506 Args.AddAllArgs(CmdArgs, options::OPT_s);
5507 Args.AddAllArgs(CmdArgs, options::OPT_t);
5508 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5509
5510 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5511
5512 //----------------------------------------------------------------------------
5513 // Libraries
5514 //----------------------------------------------------------------------------
5515 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005516 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005517 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5518 CmdArgs.push_back("-lm");
5519 }
5520
5521 CmdArgs.push_back("--start-group");
5522
5523 if (!buildingLib) {
5524 for(std::vector<std::string>::iterator i = oslibs.begin(),
5525 e = oslibs.end(); i != e; ++i)
5526 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5527 CmdArgs.push_back("-lc");
5528 }
5529 CmdArgs.push_back("-lgcc");
5530
5531 CmdArgs.push_back("--end-group");
5532 }
5533
5534 //----------------------------------------------------------------------------
5535 // End files
5536 //----------------------------------------------------------------------------
5537 if (incStdLib && incStartFiles) {
5538 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5539 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5540 }
5541
5542 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00005543 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5544 CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005545}
5546// Hexagon tools end.
5547
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005548/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Bernard Ogden31561762013-12-12 13:27:11 +00005549const char *arm::getARMCPUForMArch(const ArgList &Args,
5550 const llvm::Triple &Triple) {
5551 StringRef MArch;
5552 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5553 // Otherwise, if we have -march= choose the base CPU for that arch.
5554 MArch = A->getValue();
5555 } else {
5556 // Otherwise, use the Arch from the triple.
5557 MArch = Triple.getArchName();
5558 }
5559
5560 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005561 if (MArch == "native") {
5562 std::string CPU = llvm::sys::getHostCPUName();
5563 if (CPU != "generic") {
5564 // Translate the native cpu into the architecture. The switch below will
5565 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005566 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005567 }
5568 }
5569
Argyrios Kyrtzidisbaa97662014-07-11 23:47:48 +00005570 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00005571}
5572
5573/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005574StringRef arm::getARMTargetCPU(const ArgList &Args,
5575 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005576 // FIXME: Warn on inconsistent use of -mcpu and -march.
5577 // If we have -mcpu=, use that.
5578 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5579 StringRef MCPU = A->getValue();
5580 // Handle -mcpu=native.
5581 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005582 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005583 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005584 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005585 }
5586
5587 return getARMCPUForMArch(Args, Triple);
5588}
5589
5590/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5591/// CPU.
5592//
5593// FIXME: This is redundant with -mcpu, why does LLVM use this.
5594// FIXME: tblgen this, or kill it!
5595const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5596 return llvm::StringSwitch<const char *>(CPU)
5597 .Case("strongarm", "v4")
5598 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5599 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5600 .Cases("arm920", "arm920t", "arm922t", "v4t")
5601 .Cases("arm940t", "ep9312","v4t")
5602 .Cases("arm10tdmi", "arm1020t", "v5")
5603 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5604 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5605 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
Renato Goline11531f2015-03-17 11:55:43 +00005606 .Cases("arm1136j-s", "arm1136jf-s", "v6")
5607 .Cases("arm1176jz-s", "arm1176jzf-s", "v6k")
5608 .Cases("mpcorenovfp", "mpcore", "v6k")
Bernard Ogden31561762013-12-12 13:27:11 +00005609 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Charlie Turner2919cbd2014-11-06 14:59:30 +00005610 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
Renato Golin5886bc32014-10-13 10:22:48 +00005611 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "v7")
Javed Absar879d18b82015-04-09 14:12:10 +00005612 .Cases("cortex-r4", "cortex-r4f", "cortex-r5", "cortex-r7", "v7r")
Bradley Smithd86d6702015-02-18 10:34:48 +00005613 .Cases("sc000", "cortex-m0", "cortex-m0plus", "cortex-m1", "v6m")
5614 .Cases("sc300", "cortex-m3", "v7m")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00005615 .Cases("cortex-m4", "cortex-m7", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005616 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005617 .Case("cyclone", "v8")
Renato Golin84545d72015-02-04 13:31:56 +00005618 .Cases("cortex-a53", "cortex-a57", "cortex-a72", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005619 .Default("");
5620}
5621
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005622void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple) {
5623 if (Args.hasArg(options::OPT_r))
5624 return;
5625
5626 StringRef Suffix = getLLVMArchSuffixForARM(getARMCPUForMArch(Args, Triple));
5627 const char *LinkFlag = llvm::StringSwitch<const char *>(Suffix)
5628 .Cases("v4", "v4t", "v5", "v5e", nullptr)
Renato Goline11531f2015-03-17 11:55:43 +00005629 .Cases("v6", "v6k", "v6t2", nullptr)
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00005630 .Default("--be8");
5631
5632 if (LinkFlag)
5633 CmdArgs.push_back(LinkFlag);
5634}
5635
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005636bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5637 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5638 return A && (A->getValue() == StringRef(Value));
5639}
5640
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005641bool mips::isUCLibc(const ArgList &Args) {
5642 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00005643 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00005644}
5645
Daniel Sanders2bf13662014-07-10 14:40:57 +00005646bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005647 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5648 return llvm::StringSwitch<bool>(NaNArg->getValue())
5649 .Case("2008", true)
5650 .Case("legacy", false)
5651 .Default(false);
5652
5653 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00005654 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5655 .Cases("mips32r6", "mips64r6", true)
5656 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005657
5658 return false;
5659}
5660
Daniel Sanders379d44b2014-07-16 11:52:23 +00005661bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5662 StringRef ABIName) {
5663 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00005664 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005665 return false;
5666
5667 if (ABIName != "32")
5668 return false;
5669
5670 return llvm::StringSwitch<bool>(CPUName)
5671 .Cases("mips2", "mips3", "mips4", "mips5", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005672 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
5673 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
Daniel Sanders379d44b2014-07-16 11:52:23 +00005674 .Default(false);
5675}
5676
Tim Northover157d9112014-01-16 08:48:16 +00005677llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005678 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5679 // archs which Darwin doesn't use.
5680
5681 // The matching this routine does is fairly pointless, since it is neither the
5682 // complete architecture list, nor a reasonable subset. The problem is that
5683 // historically the driver driver accepts this and also ties its -march=
5684 // handling to the architecture name, so we need to be careful before removing
5685 // support for it.
5686
5687 // This code must be kept in sync with Clang's Darwin specific argument
5688 // translation.
5689
5690 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5691 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5692 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5693 .Case("ppc64", llvm::Triple::ppc64)
5694 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5695 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5696 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005697 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005698 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005699 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005700 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005701 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northover40956e62014-07-23 12:32:58 +00005702 .Case("arm64", llvm::Triple::aarch64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005703 .Case("r600", llvm::Triple::r600)
Tom Stellardd8e38a32015-01-06 20:34:47 +00005704 .Case("amdgcn", llvm::Triple::amdgcn)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005705 .Case("nvptx", llvm::Triple::nvptx)
5706 .Case("nvptx64", llvm::Triple::nvptx64)
5707 .Case("amdil", llvm::Triple::amdil)
5708 .Case("spir", llvm::Triple::spir)
5709 .Default(llvm::Triple::UnknownArch);
5710}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005711
Tim Northover157d9112014-01-16 08:48:16 +00005712void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5713 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5714 T.setArch(Arch);
5715
5716 if (Str == "x86_64h")
5717 T.setArchName(Str);
5718 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5719 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005720 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005721 }
5722}
5723
Bob Wilsondecc03e2012-11-23 06:14:39 +00005724const char *Clang::getBaseInputName(const ArgList &Args,
5725 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005726 return Args.MakeArgString(
5727 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005728}
5729
Bob Wilsondecc03e2012-11-23 06:14:39 +00005730const char *Clang::getBaseInputStem(const ArgList &Args,
5731 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005732 const char *Str = getBaseInputName(Args, Inputs);
5733
Chris Lattner906bb902011-01-16 08:14:11 +00005734 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005735 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005736
5737 return Str;
5738}
5739
Bob Wilsondecc03e2012-11-23 06:14:39 +00005740const char *Clang::getDependencyFileName(const ArgList &Args,
5741 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005742 // FIXME: Think about this more.
5743 std::string Res;
5744
5745 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005746 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005747 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005748 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005749 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005750 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005751 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005752}
5753
Ed Schouten3c3e58c2015-03-26 11:13:44 +00005754void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA,
5755 const InputInfo &Output,
5756 const InputInfoList &Inputs,
5757 const ArgList &Args,
5758 const char *LinkingOutput) const {
5759 const ToolChain &ToolChain = getToolChain();
5760 const Driver &D = ToolChain.getDriver();
5761 ArgStringList CmdArgs;
5762
5763 // Silence warning for "clang -g foo.o -o foo"
5764 Args.ClaimAllArgs(options::OPT_g_Group);
5765 // and "clang -emit-llvm foo.o -o foo"
5766 Args.ClaimAllArgs(options::OPT_emit_llvm);
5767 // and for "clang -w foo.o -o foo". Other warning options are already
5768 // handled somewhere else.
5769 Args.ClaimAllArgs(options::OPT_w);
5770
5771 if (!D.SysRoot.empty())
5772 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5773
5774 // CloudABI only supports static linkage.
5775 CmdArgs.push_back("-Bstatic");
5776 CmdArgs.push_back("--eh-frame-hdr");
5777 CmdArgs.push_back("--gc-sections");
5778
5779 if (Output.isFilename()) {
5780 CmdArgs.push_back("-o");
5781 CmdArgs.push_back(Output.getFilename());
5782 } else {
5783 assert(Output.isNothing() && "Invalid output.");
5784 }
5785
5786 if (!Args.hasArg(options::OPT_nostdlib) &&
5787 !Args.hasArg(options::OPT_nostartfiles)) {
5788 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
5789 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
5790 }
5791
5792 Args.AddAllArgs(CmdArgs, options::OPT_L);
5793 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
5794 for (const auto &Path : Paths)
5795 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
5796 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5797 Args.AddAllArgs(CmdArgs, options::OPT_e);
5798 Args.AddAllArgs(CmdArgs, options::OPT_s);
5799 Args.AddAllArgs(CmdArgs, options::OPT_t);
5800 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5801 Args.AddAllArgs(CmdArgs, options::OPT_r);
5802
5803 if (D.IsUsingLTO(ToolChain, Args))
5804 AddGoldPlugin(ToolChain, Args, CmdArgs);
5805
5806 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5807
5808 if (!Args.hasArg(options::OPT_nostdlib) &&
5809 !Args.hasArg(options::OPT_nodefaultlibs)) {
5810 if (D.CCCIsCXX())
5811 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5812 CmdArgs.push_back("-lc");
5813 CmdArgs.push_back("-lcompiler_rt");
5814 }
5815
5816 if (!Args.hasArg(options::OPT_nostdlib) &&
5817 !Args.hasArg(options::OPT_nostartfiles))
5818 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
5819
5820 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
5821 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
5822}
5823
Daniel Dunbarbe220842009-03-20 16:06:39 +00005824void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005825 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005826 const InputInfoList &Inputs,
5827 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005828 const char *LinkingOutput) const {
5829 ArgStringList CmdArgs;
5830
5831 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5832 const InputInfo &Input = Inputs[0];
5833
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005834 // Determine the original source input.
5835 const Action *SourceAction = &JA;
5836 while (SourceAction->getKind() != Action::InputClass) {
5837 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5838 SourceAction = SourceAction->getInputs()[0];
5839 }
5840
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005841 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005842 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005843 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5844 // FIXME: at run-time detect assembler capabilities or rely on version
5845 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005846 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005847 const llvm::Triple &T(getToolChain().getTriple());
5848 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005849 CmdArgs.push_back("-Q");
5850 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005851
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005852 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005853 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005854 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005855 if (Args.hasArg(options::OPT_gstabs))
5856 CmdArgs.push_back("--gstabs");
5857 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005858 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005859 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005860
Daniel Dunbarbe220842009-03-20 16:06:39 +00005861 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005862 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005863
Daniel Dunbar6d484762010-07-22 01:47:22 +00005864 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005865 if (getToolChain().getArch() == llvm::Triple::x86 ||
5866 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005867 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5868 CmdArgs.push_back("-force_cpusubtype_ALL");
5869
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005870 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005871 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005872 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005873 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005874 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005875 CmdArgs.push_back("-static");
5876
Daniel Dunbarbe220842009-03-20 16:06:39 +00005877 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5878 options::OPT_Xassembler);
5879
5880 assert(Output.isFilename() && "Unexpected lipo output.");
5881 CmdArgs.push_back("-o");
5882 CmdArgs.push_back(Output.getFilename());
5883
Daniel Dunbarb440f562010-08-02 02:38:21 +00005884 assert(Input.isFilename() && "Invalid input.");
5885 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005886
5887 // asm_final spec is empty.
5888
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005889 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005890 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00005891 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005892}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005893
Tim Northover157d9112014-01-16 08:48:16 +00005894void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005895
Tim Northover157d9112014-01-16 08:48:16 +00005896void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5897 ArgStringList &CmdArgs) const {
5898 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005899
Daniel Dunbarc1964212009-03-26 16:23:12 +00005900 // Derived from darwin_arch spec.
5901 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005902 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005903
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005904 // FIXME: Is this needed anymore?
5905 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005906 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005907}
5908
Bill Wendling3b2000f2012-10-02 18:02:50 +00005909bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5910 // We only need to generate a temp path for LTO if we aren't compiling object
5911 // files. When compiling source files, we run 'dsymutil' after linking. We
5912 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005913 for (const auto &Input : Inputs)
5914 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005915 return true;
5916
5917 return false;
5918}
5919
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005920void darwin::Link::AddLinkArgs(Compilation &C,
5921 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005922 ArgStringList &CmdArgs,
5923 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005924 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005925 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005926
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005927 unsigned Version[3] = { 0, 0, 0 };
5928 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5929 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005930 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005931 Version[1], Version[2], HadExtra) ||
5932 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005933 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005934 << A->getAsString(Args);
5935 }
5936
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005937 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005938 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005939 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5940 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005941
Bob Wilson3d27dad2013-08-02 22:25:34 +00005942 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5943 CmdArgs.push_back("-export_dynamic");
5944
Bob Wilsonb111ec92015-03-02 19:01:14 +00005945 // If we are using App Extension restrictions, pass a flag to the linker
5946 // telling it that the compiled code has been audited.
5947 if (Args.hasFlag(options::OPT_fapplication_extension,
5948 options::OPT_fno_application_extension, false))
5949 CmdArgs.push_back("-application_extension");
5950
Bill Wendling313b6bf2012-11-16 23:03:00 +00005951 // If we are using LTO, then automatically create a temporary file path for
5952 // the linker to use, so that it's lifetime will extend past a possible
5953 // dsymutil step.
Peter Collingbournea4ccff32015-02-20 20:30:56 +00005954 if (Version[0] >= 116 && D.IsUsingLTO(getToolChain(), Args) &&
5955 NeedsTempPath(Inputs)) {
Bill Wendling313b6bf2012-11-16 23:03:00 +00005956 const char *TmpPath = C.getArgs().MakeArgString(
5957 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5958 C.addTempFile(TmpPath);
5959 CmdArgs.push_back("-object_path_lto");
5960 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005961 }
5962
Daniel Dunbarc1964212009-03-26 16:23:12 +00005963 // Derived from the "link" spec.
5964 Args.AddAllArgs(CmdArgs, options::OPT_static);
5965 if (!Args.hasArg(options::OPT_static))
5966 CmdArgs.push_back("-dynamic");
5967 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5968 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5969 // here. How do we wish to handle such things?
5970 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005971
Daniel Dunbarc1964212009-03-26 16:23:12 +00005972 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005973 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005974 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005975 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005976
5977 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5978 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5979 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5980
5981 Arg *A;
5982 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5983 (A = Args.getLastArg(options::OPT_current__version)) ||
5984 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005985 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005986 << A->getAsString(Args) << "-dynamiclib";
5987
5988 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5989 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5990 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5991 } else {
5992 CmdArgs.push_back("-dylib");
5993
5994 Arg *A;
5995 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5996 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5997 (A = Args.getLastArg(options::OPT_client__name)) ||
5998 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5999 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6000 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006001 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00006002 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006003
Daniel Dunbarc1964212009-03-26 16:23:12 +00006004 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6005 "-dylib_compatibility_version");
6006 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6007 "-dylib_current_version");
6008
Tim Northover157d9112014-01-16 08:48:16 +00006009 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006010
6011 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6012 "-dylib_install_name");
6013 }
6014
6015 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6016 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6017 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006018 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006019 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006020 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6021 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6022 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6023 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6024 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6025 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006026 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006027 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6028 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6029 Args.AddAllArgs(CmdArgs, options::OPT_init);
6030
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006031 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006032 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006033
Daniel Dunbarc1964212009-03-26 16:23:12 +00006034 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6035 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6036 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6037 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6038 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006039
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006040 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6041 options::OPT_fno_pie,
6042 options::OPT_fno_PIE)) {
6043 if (A->getOption().matches(options::OPT_fpie) ||
6044 A->getOption().matches(options::OPT_fPIE))
6045 CmdArgs.push_back("-pie");
6046 else
6047 CmdArgs.push_back("-no_pie");
6048 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006049
6050 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6051 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6052 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6053 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6054 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6055 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6056 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6057 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6058 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6059 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6060 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6061 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6062 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6063 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6064 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6065 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006066
Daniel Dunbar84384642011-05-02 21:03:47 +00006067 // Give --sysroot= preference, over the Apple specific behavior to also use
6068 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006069 StringRef sysroot = C.getSysRoot();
6070 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006071 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006072 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006073 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6074 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006075 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006076 }
6077
Daniel Dunbarc1964212009-03-26 16:23:12 +00006078 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6079 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6080 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6081 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6082 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006083 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006084 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6085 Args.AddAllArgs(CmdArgs, options::OPT_y);
6086 Args.AddLastArg(CmdArgs, options::OPT_w);
6087 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6088 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6089 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6090 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6091 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6092 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6093 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6094 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6095 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6096 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6097 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6098 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6099}
6100
Alexey Bataev186b28a2014-03-06 05:43:53 +00006101enum LibOpenMP {
6102 LibUnknown,
6103 LibGOMP,
6104 LibIOMP5
6105};
6106
Daniel Dunbarc1964212009-03-26 16:23:12 +00006107void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006108 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006109 const InputInfoList &Inputs,
6110 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00006111 const char *LinkingOutput) const {
6112 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006113
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006114 // If the number of arguments surpasses the system limits, we will encode the
6115 // input files in a separate file, shortening the command line. To this end,
6116 // build a list of input file names that can be passed via a file with the
6117 // -filelist linker option.
6118 llvm::opt::ArgStringList InputFileList;
6119
Daniel Dunbarc1964212009-03-26 16:23:12 +00006120 // The logic here is derived from gcc's behavior; most of which
6121 // comes from specs (starting with link_command). Consult gcc for
6122 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006123 ArgStringList CmdArgs;
6124
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006125 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6126 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6127 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006128 for (const auto &Arg : Args)
6129 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006130 const char *Exec =
6131 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
6132 CmdArgs.push_back(Output.getFilename());
David Blaikiec11bf802014-09-04 16:04:28 +00006133 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006134 return;
6135 }
6136
Daniel Dunbarc1964212009-03-26 16:23:12 +00006137 // I'm not sure why this particular decomposition exists in gcc, but
6138 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006139 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006140
Daniel Dunbarc1964212009-03-26 16:23:12 +00006141 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6142 Args.AddAllArgs(CmdArgs, options::OPT_s);
6143 Args.AddAllArgs(CmdArgs, options::OPT_t);
6144 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6145 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006146 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006147 Args.AddAllArgs(CmdArgs, options::OPT_r);
6148
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006149 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6150 // members of static archive libraries which implement Objective-C classes or
6151 // categories.
6152 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6153 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006154
Daniel Dunbarc1964212009-03-26 16:23:12 +00006155 CmdArgs.push_back("-o");
6156 CmdArgs.push_back(Output.getFilename());
6157
Chad Rosier06fd3c62012-05-16 23:45:12 +00006158 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006159 !Args.hasArg(options::OPT_nostartfiles))
6160 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006161
6162 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006163
Alexey Bataev186b28a2014-03-06 05:43:53 +00006164 LibOpenMP UsedOpenMPLib = LibUnknown;
6165 if (Args.hasArg(options::OPT_fopenmp)) {
6166 UsedOpenMPLib = LibGOMP;
6167 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
6168 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
6169 .Case("libgomp", LibGOMP)
6170 .Case("libiomp5", LibIOMP5)
6171 .Default(LibUnknown);
6172 if (UsedOpenMPLib == LibUnknown)
6173 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
6174 << A->getOption().getName() << A->getValue();
6175 }
6176 switch (UsedOpenMPLib) {
6177 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00006178 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00006179 break;
6180 case LibIOMP5:
6181 CmdArgs.push_back("-liomp5");
6182 break;
6183 case LibUnknown:
6184 break;
6185 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006186
Douglas Gregor9295df02012-05-15 21:00:27 +00006187 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006188 // Build the input file for -filelist (list of linker input files) in case we
6189 // need it later
6190 for (const auto &II : Inputs) {
6191 if (!II.isFilename()) {
6192 // This is a linker input argument.
6193 // We cannot mix input arguments and file names in a -filelist input, thus
6194 // we prematurely stop our list (remaining files shall be passed as
6195 // arguments).
6196 if (InputFileList.size() > 0)
6197 break;
6198
6199 continue;
6200 }
6201
6202 InputFileList.push_back(II.getFilename());
6203 }
6204
Bob Wilson16d93952012-05-15 18:57:39 +00006205 if (isObjCRuntimeLinked(Args) &&
6206 !Args.hasArg(options::OPT_nostdlib) &&
6207 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006208 // We use arclite library for both ARC and subscripting support.
6209 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6210
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006211 CmdArgs.push_back("-framework");
6212 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006213 // Link libobj.
6214 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006215 }
John McCall31168b02011-06-15 23:02:42 +00006216
Daniel Dunbarc1964212009-03-26 16:23:12 +00006217 if (LinkingOutput) {
6218 CmdArgs.push_back("-arch_multiple");
6219 CmdArgs.push_back("-final_output");
6220 CmdArgs.push_back(LinkingOutput);
6221 }
6222
Daniel Dunbarc1964212009-03-26 16:23:12 +00006223 if (Args.hasArg(options::OPT_fnested_functions))
6224 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006225
Daniel Dunbarc1964212009-03-26 16:23:12 +00006226 if (!Args.hasArg(options::OPT_nostdlib) &&
6227 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006228 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006229 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006230
Daniel Dunbarc1964212009-03-26 16:23:12 +00006231 // link_ssp spec is empty.
6232
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006233 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006234 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006235 }
6236
Chad Rosier06fd3c62012-05-16 23:45:12 +00006237 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006238 !Args.hasArg(options::OPT_nostartfiles)) {
6239 // endfile_spec is empty.
6240 }
6241
6242 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6243 Args.AddAllArgs(CmdArgs, options::OPT_F);
6244
Steven Wu3ffb61b2015-02-06 18:08:29 +00006245 // -iframework should be forwarded as -F.
6246 for (auto it = Args.filtered_begin(options::OPT_iframework),
6247 ie = Args.filtered_end(); it != ie; ++it)
6248 CmdArgs.push_back(Args.MakeArgString(std::string("-F") +
6249 (*it)->getValue()));
6250
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006251 if (!Args.hasArg(options::OPT_nostdlib) &&
6252 !Args.hasArg(options::OPT_nodefaultlibs)) {
6253 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6254 if (A->getValue() == StringRef("Accelerate")) {
6255 CmdArgs.push_back("-framework");
6256 CmdArgs.push_back("Accelerate");
6257 }
6258 }
6259 }
6260
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006261 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006262 Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006263 std::unique_ptr<Command> Cmd =
6264 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
6265 Cmd->setInputFileList(std::move(InputFileList));
6266 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006267}
6268
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006269void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006270 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006271 const InputInfoList &Inputs,
6272 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006273 const char *LinkingOutput) const {
6274 ArgStringList CmdArgs;
6275
6276 CmdArgs.push_back("-create");
6277 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006278
6279 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006280 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00006281
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006282 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006283 assert(II.isFilename() && "Unexpected lipo input.");
6284 CmdArgs.push_back(II.getFilename());
6285 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006286
6287 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
David Blaikiec11bf802014-09-04 16:04:28 +00006288 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006289}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006290
Daniel Dunbar88299622010-06-04 18:28:36 +00006291void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006292 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00006293 const InputInfoList &Inputs,
6294 const ArgList &Args,
6295 const char *LinkingOutput) const {
6296 ArgStringList CmdArgs;
6297
Daniel Dunbareb86b042011-05-09 17:23:16 +00006298 CmdArgs.push_back("-o");
6299 CmdArgs.push_back(Output.getFilename());
6300
Daniel Dunbar88299622010-06-04 18:28:36 +00006301 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6302 const InputInfo &Input = Inputs[0];
6303 assert(Input.isFilename() && "Unexpected dsymutil input.");
6304 CmdArgs.push_back(Input.getFilename());
6305
Daniel Dunbar88299622010-06-04 18:28:36 +00006306 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006307 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
David Blaikiec11bf802014-09-04 16:04:28 +00006308 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00006309}
6310
Eric Christopher551ef452011-08-23 17:56:55 +00006311void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00006312 const InputInfo &Output,
6313 const InputInfoList &Inputs,
6314 const ArgList &Args,
6315 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00006316 ArgStringList CmdArgs;
6317 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00006318 CmdArgs.push_back("--debug-info");
6319 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00006320 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00006321
6322 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6323 const InputInfo &Input = Inputs[0];
6324 assert(Input.isFilename() && "Unexpected verify input");
6325
6326 // Grabbing the output of the earlier dsymutil run.
6327 CmdArgs.push_back(Input.getFilename());
6328
6329 const char *Exec =
6330 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
David Blaikiec11bf802014-09-04 16:04:28 +00006331 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher551ef452011-08-23 17:56:55 +00006332}
6333
David Chisnallf571cde2012-02-15 13:39:01 +00006334void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6335 const InputInfo &Output,
6336 const InputInfoList &Inputs,
6337 const ArgList &Args,
6338 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006339 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00006340 ArgStringList CmdArgs;
6341
6342 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6343 options::OPT_Xassembler);
6344
6345 CmdArgs.push_back("-o");
6346 CmdArgs.push_back(Output.getFilename());
6347
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006348 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00006349 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00006350
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006351 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006352 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006353}
6354
David Chisnallf571cde2012-02-15 13:39:01 +00006355void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
6356 const InputInfo &Output,
6357 const InputInfoList &Inputs,
6358 const ArgList &Args,
6359 const char *LinkingOutput) const {
6360 // FIXME: Find a real GCC, don't hard-code versions here
6361 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6362 const llvm::Triple &T = getToolChain().getTriple();
6363 std::string LibPath = "/usr/lib/";
6364 llvm::Triple::ArchType Arch = T.getArch();
6365 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006366 case llvm::Triple::x86:
6367 GCCLibPath +=
6368 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6369 break;
6370 case llvm::Triple::x86_64:
6371 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6372 GCCLibPath += "/4.5.2/amd64/";
6373 LibPath += "amd64/";
6374 break;
6375 default:
6376 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00006377 }
6378
6379 ArgStringList CmdArgs;
6380
David Chisnall272a0712012-02-29 15:06:12 +00006381 // Demangle C++ names in errors
6382 CmdArgs.push_back("-C");
6383
David Chisnallf571cde2012-02-15 13:39:01 +00006384 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6385 (!Args.hasArg(options::OPT_shared))) {
6386 CmdArgs.push_back("-e");
6387 CmdArgs.push_back("_start");
6388 }
6389
6390 if (Args.hasArg(options::OPT_static)) {
6391 CmdArgs.push_back("-Bstatic");
6392 CmdArgs.push_back("-dn");
6393 } else {
6394 CmdArgs.push_back("-Bdynamic");
6395 if (Args.hasArg(options::OPT_shared)) {
6396 CmdArgs.push_back("-shared");
6397 } else {
6398 CmdArgs.push_back("--dynamic-linker");
6399 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6400 }
6401 }
6402
6403 if (Output.isFilename()) {
6404 CmdArgs.push_back("-o");
6405 CmdArgs.push_back(Output.getFilename());
6406 } else {
6407 assert(Output.isNothing() && "Invalid output.");
6408 }
6409
6410 if (!Args.hasArg(options::OPT_nostdlib) &&
6411 !Args.hasArg(options::OPT_nostartfiles)) {
6412 if (!Args.hasArg(options::OPT_shared)) {
6413 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6414 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006415 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006416 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6417 } else {
6418 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00006419 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6420 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006421 }
Hans Wennborg70850d82013-07-18 20:29:38 +00006422 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00006423 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006424 }
6425
6426 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6427
6428 Args.AddAllArgs(CmdArgs, options::OPT_L);
6429 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6430 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00006431 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00006432
6433 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6434
6435 if (!Args.hasArg(options::OPT_nostdlib) &&
6436 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006437 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00006438 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00006439 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006440 if (!Args.hasArg(options::OPT_shared)) {
6441 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00006442 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00006443 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00006444 }
David Chisnallf571cde2012-02-15 13:39:01 +00006445 }
6446
6447 if (!Args.hasArg(options::OPT_nostdlib) &&
6448 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00006449 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006450 }
David Chisnall96de9932012-02-16 16:00:47 +00006451 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00006452
Alexey Samsonov7811d192014-02-20 13:57:37 +00006453 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00006454
6455 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006456 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006457 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
David Chisnallf571cde2012-02-15 13:39:01 +00006458}
6459
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006460void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006461 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006462 const InputInfoList &Inputs,
6463 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006464 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006465 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006466 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00006467 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006468
Rafael Espindolacc126272014-02-28 01:55:21 +00006469 switch (getToolChain().getArch()) {
6470 case llvm::Triple::x86:
6471 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6472 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006473 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00006474 break;
6475
6476 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006477 CmdArgs.push_back("-mppc");
6478 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00006479 break;
6480
6481 case llvm::Triple::sparc:
6482 CmdArgs.push_back("-32");
6483 NeedsKPIC = true;
6484 break;
6485
6486 case llvm::Triple::sparcv9:
6487 CmdArgs.push_back("-64");
6488 CmdArgs.push_back("-Av9a");
6489 NeedsKPIC = true;
6490 break;
6491
6492 case llvm::Triple::mips64:
6493 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006494 StringRef CPUName;
6495 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006496 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006497
6498 CmdArgs.push_back("-mabi");
6499 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6500
6501 if (getToolChain().getArch() == llvm::Triple::mips64)
6502 CmdArgs.push_back("-EB");
6503 else
6504 CmdArgs.push_back("-EL");
6505
Rafael Espindolacc126272014-02-28 01:55:21 +00006506 NeedsKPIC = true;
6507 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006508 }
6509
Rafael Espindolacc126272014-02-28 01:55:21 +00006510 default:
6511 break;
6512 }
6513
6514 if (NeedsKPIC)
6515 addAssemblerKPIC(Args, CmdArgs);
6516
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006517 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6518 options::OPT_Xassembler);
6519
6520 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006521 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006522
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006523 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006524 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006525
6526 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006527 Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006528 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006529}
6530
6531void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006532 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006533 const InputInfoList &Inputs,
6534 const ArgList &Args,
6535 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006536 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006537 ArgStringList CmdArgs;
6538
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006539 // Silence warning for "clang -g foo.o -o foo"
6540 Args.ClaimAllArgs(options::OPT_g_Group);
6541 // and "clang -emit-llvm foo.o -o foo"
6542 Args.ClaimAllArgs(options::OPT_emit_llvm);
6543 // and for "clang -w foo.o -o foo". Other warning options are already
6544 // handled somewhere else.
6545 Args.ClaimAllArgs(options::OPT_w);
6546
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006547 if (getToolChain().getArch() == llvm::Triple::mips64)
6548 CmdArgs.push_back("-EB");
6549 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6550 CmdArgs.push_back("-EL");
6551
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006552 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006553 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006554 CmdArgs.push_back("-e");
6555 CmdArgs.push_back("__start");
6556 }
6557
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006558 if (Args.hasArg(options::OPT_static)) {
6559 CmdArgs.push_back("-Bstatic");
6560 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006561 if (Args.hasArg(options::OPT_rdynamic))
6562 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006563 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006564 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006565 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006566 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006567 } else {
6568 CmdArgs.push_back("-dynamic-linker");
6569 CmdArgs.push_back("/usr/libexec/ld.so");
6570 }
6571 }
6572
Rafael Espindola044f7832013-06-05 04:28:55 +00006573 if (Args.hasArg(options::OPT_nopie))
6574 CmdArgs.push_back("-nopie");
6575
Daniel Dunbarb440f562010-08-02 02:38:21 +00006576 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006577 CmdArgs.push_back("-o");
6578 CmdArgs.push_back(Output.getFilename());
6579 } else {
6580 assert(Output.isNothing() && "Invalid output.");
6581 }
6582
6583 if (!Args.hasArg(options::OPT_nostdlib) &&
6584 !Args.hasArg(options::OPT_nostartfiles)) {
6585 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006586 if (Args.hasArg(options::OPT_pg))
6587 CmdArgs.push_back(Args.MakeArgString(
6588 getToolChain().GetFilePath("gcrt0.o")));
6589 else
6590 CmdArgs.push_back(Args.MakeArgString(
6591 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006592 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006593 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006594 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006595 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006596 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006597 }
6598 }
6599
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006600 std::string Triple = getToolChain().getTripleString();
6601 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006602 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006603 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006604 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006605
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006606 Args.AddAllArgs(CmdArgs, options::OPT_L);
6607 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6608 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006609 Args.AddAllArgs(CmdArgs, options::OPT_s);
6610 Args.AddAllArgs(CmdArgs, options::OPT_t);
6611 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6612 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006613
Daniel Dunbar54423b22010-09-17 00:24:54 +00006614 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006615
6616 if (!Args.hasArg(options::OPT_nostdlib) &&
6617 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006618 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006619 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006620 if (Args.hasArg(options::OPT_pg))
6621 CmdArgs.push_back("-lm_p");
6622 else
6623 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006624 }
6625
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006626 // FIXME: For some reason GCC passes -lgcc before adding
6627 // the default system libraries. Just mimic this for now.
6628 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006629
Eric Christopher17674ec2012-09-13 06:32:34 +00006630 if (Args.hasArg(options::OPT_pthread)) {
6631 if (!Args.hasArg(options::OPT_shared) &&
6632 Args.hasArg(options::OPT_pg))
6633 CmdArgs.push_back("-lpthread_p");
6634 else
6635 CmdArgs.push_back("-lpthread");
6636 }
6637
Chandler Carruth45661652011-12-17 22:32:42 +00006638 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006639 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006640 CmdArgs.push_back("-lc_p");
6641 else
6642 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006643 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006644
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006645 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006646 }
6647
6648 if (!Args.hasArg(options::OPT_nostdlib) &&
6649 !Args.hasArg(options::OPT_nostartfiles)) {
6650 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006651 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006652 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006653 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006654 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006655 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006656 }
6657
6658 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006659 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006660 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006661}
Ed Schoutene33194b2009-04-02 19:13:12 +00006662
Eli Friedman9fa28852012-08-08 23:57:20 +00006663void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6664 const InputInfo &Output,
6665 const InputInfoList &Inputs,
6666 const ArgList &Args,
6667 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006668 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00006669 ArgStringList CmdArgs;
6670
6671 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6672 options::OPT_Xassembler);
6673
6674 CmdArgs.push_back("-o");
6675 CmdArgs.push_back(Output.getFilename());
6676
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006677 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006678 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006679
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006680 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006681 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006682}
6683
6684void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6685 const InputInfo &Output,
6686 const InputInfoList &Inputs,
6687 const ArgList &Args,
6688 const char *LinkingOutput) const {
6689 const Driver &D = getToolChain().getDriver();
6690 ArgStringList CmdArgs;
6691
6692 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6693 (!Args.hasArg(options::OPT_shared))) {
6694 CmdArgs.push_back("-e");
6695 CmdArgs.push_back("__start");
6696 }
6697
6698 if (Args.hasArg(options::OPT_static)) {
6699 CmdArgs.push_back("-Bstatic");
6700 } else {
6701 if (Args.hasArg(options::OPT_rdynamic))
6702 CmdArgs.push_back("-export-dynamic");
6703 CmdArgs.push_back("--eh-frame-hdr");
6704 CmdArgs.push_back("-Bdynamic");
6705 if (Args.hasArg(options::OPT_shared)) {
6706 CmdArgs.push_back("-shared");
6707 } else {
6708 CmdArgs.push_back("-dynamic-linker");
6709 CmdArgs.push_back("/usr/libexec/ld.so");
6710 }
6711 }
6712
6713 if (Output.isFilename()) {
6714 CmdArgs.push_back("-o");
6715 CmdArgs.push_back(Output.getFilename());
6716 } else {
6717 assert(Output.isNothing() && "Invalid output.");
6718 }
6719
6720 if (!Args.hasArg(options::OPT_nostdlib) &&
6721 !Args.hasArg(options::OPT_nostartfiles)) {
6722 if (!Args.hasArg(options::OPT_shared)) {
6723 if (Args.hasArg(options::OPT_pg))
6724 CmdArgs.push_back(Args.MakeArgString(
6725 getToolChain().GetFilePath("gcrt0.o")));
6726 else
6727 CmdArgs.push_back(Args.MakeArgString(
6728 getToolChain().GetFilePath("crt0.o")));
6729 CmdArgs.push_back(Args.MakeArgString(
6730 getToolChain().GetFilePath("crtbegin.o")));
6731 } else {
6732 CmdArgs.push_back(Args.MakeArgString(
6733 getToolChain().GetFilePath("crtbeginS.o")));
6734 }
6735 }
6736
6737 Args.AddAllArgs(CmdArgs, options::OPT_L);
6738 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6739 Args.AddAllArgs(CmdArgs, options::OPT_e);
6740
6741 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6742
6743 if (!Args.hasArg(options::OPT_nostdlib) &&
6744 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006745 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006746 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6747 if (Args.hasArg(options::OPT_pg))
6748 CmdArgs.push_back("-lm_p");
6749 else
6750 CmdArgs.push_back("-lm");
6751 }
6752
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006753 if (Args.hasArg(options::OPT_pthread)) {
6754 if (!Args.hasArg(options::OPT_shared) &&
6755 Args.hasArg(options::OPT_pg))
6756 CmdArgs.push_back("-lpthread_p");
6757 else
6758 CmdArgs.push_back("-lpthread");
6759 }
6760
Eli Friedman9fa28852012-08-08 23:57:20 +00006761 if (!Args.hasArg(options::OPT_shared)) {
6762 if (Args.hasArg(options::OPT_pg))
6763 CmdArgs.push_back("-lc_p");
6764 else
6765 CmdArgs.push_back("-lc");
6766 }
6767
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006768 StringRef MyArch;
6769 switch (getToolChain().getTriple().getArch()) {
6770 case llvm::Triple::arm:
6771 MyArch = "arm";
6772 break;
6773 case llvm::Triple::x86:
6774 MyArch = "i386";
6775 break;
6776 case llvm::Triple::x86_64:
6777 MyArch = "amd64";
6778 break;
6779 default:
6780 llvm_unreachable("Unsupported architecture");
6781 }
6782 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006783 }
6784
6785 if (!Args.hasArg(options::OPT_nostdlib) &&
6786 !Args.hasArg(options::OPT_nostartfiles)) {
6787 if (!Args.hasArg(options::OPT_shared))
6788 CmdArgs.push_back(Args.MakeArgString(
6789 getToolChain().GetFilePath("crtend.o")));
6790 else
6791 CmdArgs.push_back(Args.MakeArgString(
6792 getToolChain().GetFilePath("crtendS.o")));
6793 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006794
6795 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006796 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00006797 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006798}
6799
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006800void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006801 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006802 const InputInfoList &Inputs,
6803 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006804 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006805 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006806 ArgStringList CmdArgs;
6807
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006808 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6809 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006810 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006811 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006812 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006813 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006814 else if (getToolChain().getArch() == llvm::Triple::mips ||
6815 getToolChain().getArch() == llvm::Triple::mipsel ||
6816 getToolChain().getArch() == llvm::Triple::mips64 ||
6817 getToolChain().getArch() == llvm::Triple::mips64el) {
6818 StringRef CPUName;
6819 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00006820 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006821
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006822 CmdArgs.push_back("-march");
6823 CmdArgs.push_back(CPUName.data());
6824
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006825 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006826 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006827
6828 if (getToolChain().getArch() == llvm::Triple::mips ||
6829 getToolChain().getArch() == llvm::Triple::mips64)
6830 CmdArgs.push_back("-EB");
6831 else
6832 CmdArgs.push_back("-EL");
6833
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006834 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006835 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006836 getToolChain().getArch() == llvm::Triple::armeb ||
6837 getToolChain().getArch() == llvm::Triple::thumb ||
6838 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006839 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006840 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006841 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6842
6843 if (FloatABI == "hard") {
6844 CmdArgs.push_back("-mfpu=vfp");
6845 } else {
6846 CmdArgs.push_back("-mfpu=softvfp");
6847 }
6848
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006849 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006850 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006851 case llvm::Triple::GNUEABI:
6852 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006853 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006854 break;
6855
6856 default:
6857 CmdArgs.push_back("-matpcs");
6858 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006859 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006860 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006861 if (getToolChain().getArch() == llvm::Triple::sparc)
6862 CmdArgs.push_back("-Av8plusa");
6863 else
6864 CmdArgs.push_back("-Av9a");
6865
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006866 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006867 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006868
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006869 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6870 options::OPT_Xassembler);
6871
6872 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006873 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006874
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006875 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006876 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006877
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006878 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00006879 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006880}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006881
6882void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006883 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006884 const InputInfoList &Inputs,
6885 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006886 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006887 const toolchains::FreeBSD& ToolChain =
6888 static_cast<const toolchains::FreeBSD&>(getToolChain());
6889 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006890 const bool IsPIE =
6891 !Args.hasArg(options::OPT_shared) &&
6892 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006893 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006894
6895 // Silence warning for "clang -g foo.o -o foo"
6896 Args.ClaimAllArgs(options::OPT_g_Group);
6897 // and "clang -emit-llvm foo.o -o foo"
6898 Args.ClaimAllArgs(options::OPT_emit_llvm);
6899 // and for "clang -w foo.o -o foo". Other warning options are already
6900 // handled somewhere else.
6901 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006902
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006903 if (!D.SysRoot.empty())
6904 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6905
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006906 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006907 CmdArgs.push_back("-pie");
6908
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006909 if (Args.hasArg(options::OPT_static)) {
6910 CmdArgs.push_back("-Bstatic");
6911 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006912 if (Args.hasArg(options::OPT_rdynamic))
6913 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006914 CmdArgs.push_back("--eh-frame-hdr");
6915 if (Args.hasArg(options::OPT_shared)) {
6916 CmdArgs.push_back("-Bshareable");
6917 } else {
6918 CmdArgs.push_back("-dynamic-linker");
6919 CmdArgs.push_back("/libexec/ld-elf.so.1");
6920 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006921 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6922 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006923 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6924 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6925 CmdArgs.push_back("--hash-style=both");
6926 }
6927 }
6928 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006929 }
6930
6931 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6932 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006933 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006934 CmdArgs.push_back("-m");
6935 CmdArgs.push_back("elf_i386_fbsd");
6936 }
6937
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006938 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006939 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006940 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006941 }
6942
Daniel Dunbarb440f562010-08-02 02:38:21 +00006943 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006944 CmdArgs.push_back("-o");
6945 CmdArgs.push_back(Output.getFilename());
6946 } else {
6947 assert(Output.isNothing() && "Invalid output.");
6948 }
6949
6950 if (!Args.hasArg(options::OPT_nostdlib) &&
6951 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006952 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006953 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006954 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006955 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006956 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006957 crt1 = "Scrt1.o";
6958 else
6959 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006960 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006961 if (crt1)
6962 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6963
6964 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6965
Craig Topper92fc2df2014-05-17 16:56:41 +00006966 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006967 if (Args.hasArg(options::OPT_static))
6968 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006969 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006970 crtbegin = "crtbeginS.o";
6971 else
6972 crtbegin = "crtbegin.o";
6973
6974 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006975 }
6976
6977 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00006978 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006979 for (const auto &Path : Paths)
6980 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006981 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6982 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006983 Args.AddAllArgs(CmdArgs, options::OPT_s);
6984 Args.AddAllArgs(CmdArgs, options::OPT_t);
6985 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6986 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006987
Peter Collingbournea4ccff32015-02-20 20:30:56 +00006988 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00006989 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006990
Alexey Samsonov52550342014-09-15 19:58:40 +00006991 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00006992 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006993
6994 if (!Args.hasArg(options::OPT_nostdlib) &&
6995 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006996 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006997 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006998 if (Args.hasArg(options::OPT_pg))
6999 CmdArgs.push_back("-lm_p");
7000 else
7001 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007002 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007003 if (NeedsSanitizerDeps)
7004 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007005 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7006 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007007 if (Args.hasArg(options::OPT_pg))
7008 CmdArgs.push_back("-lgcc_p");
7009 else
7010 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007011 if (Args.hasArg(options::OPT_static)) {
7012 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007013 } else if (Args.hasArg(options::OPT_pg)) {
7014 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007015 } else {
7016 CmdArgs.push_back("--as-needed");
7017 CmdArgs.push_back("-lgcc_s");
7018 CmdArgs.push_back("--no-as-needed");
7019 }
7020
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007021 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007022 if (Args.hasArg(options::OPT_pg))
7023 CmdArgs.push_back("-lpthread_p");
7024 else
7025 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007026 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007027
Roman Divacky66f22762011-02-10 16:59:40 +00007028 if (Args.hasArg(options::OPT_pg)) {
7029 if (Args.hasArg(options::OPT_shared))
7030 CmdArgs.push_back("-lc");
7031 else
7032 CmdArgs.push_back("-lc_p");
7033 CmdArgs.push_back("-lgcc_p");
7034 } else {
7035 CmdArgs.push_back("-lc");
7036 CmdArgs.push_back("-lgcc");
7037 }
7038
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007039 if (Args.hasArg(options::OPT_static)) {
7040 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007041 } else if (Args.hasArg(options::OPT_pg)) {
7042 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007043 } else {
7044 CmdArgs.push_back("--as-needed");
7045 CmdArgs.push_back("-lgcc_s");
7046 CmdArgs.push_back("--no-as-needed");
7047 }
7048 }
7049
7050 if (!Args.hasArg(options::OPT_nostdlib) &&
7051 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007052 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007053 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007054 else
7055 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007056 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007057 }
7058
Alexey Samsonov7811d192014-02-20 13:57:37 +00007059 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007060
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007061 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00007062 Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007063 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007064}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007065
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007066void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7067 const InputInfo &Output,
7068 const InputInfoList &Inputs,
7069 const ArgList &Args,
7070 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007071 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007072 ArgStringList CmdArgs;
7073
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007074 // GNU as needs different flags for creating the correct output format
7075 // on architectures with different ABIs or optional feature sets.
7076 switch (getToolChain().getArch()) {
7077 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007078 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007079 break;
7080 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007081 case llvm::Triple::armeb:
7082 case llvm::Triple::thumb:
7083 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00007084 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007085 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007086 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007087 }
7088
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007089 case llvm::Triple::mips:
7090 case llvm::Triple::mipsel:
7091 case llvm::Triple::mips64:
7092 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007093 StringRef CPUName;
7094 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007095 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007096
7097 CmdArgs.push_back("-march");
7098 CmdArgs.push_back(CPUName.data());
7099
7100 CmdArgs.push_back("-mabi");
7101 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7102
7103 if (getToolChain().getArch() == llvm::Triple::mips ||
7104 getToolChain().getArch() == llvm::Triple::mips64)
7105 CmdArgs.push_back("-EB");
7106 else
7107 CmdArgs.push_back("-EL");
7108
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007109 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007110 break;
7111 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007112
7113 case llvm::Triple::sparc:
7114 CmdArgs.push_back("-32");
7115 addAssemblerKPIC(Args, CmdArgs);
7116 break;
7117
7118 case llvm::Triple::sparcv9:
7119 CmdArgs.push_back("-64");
7120 CmdArgs.push_back("-Av9");
7121 addAssemblerKPIC(Args, CmdArgs);
7122 break;
7123
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007124 default:
7125 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007126 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007127
7128 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7129 options::OPT_Xassembler);
7130
7131 CmdArgs.push_back("-o");
7132 CmdArgs.push_back(Output.getFilename());
7133
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007134 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007135 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007136
David Chisnallddbd68f2011-09-27 22:03:18 +00007137 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
David Blaikiec11bf802014-09-04 16:04:28 +00007138 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007139}
7140
7141void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
7142 const InputInfo &Output,
7143 const InputInfoList &Inputs,
7144 const ArgList &Args,
7145 const char *LinkingOutput) const {
7146 const Driver &D = getToolChain().getDriver();
7147 ArgStringList CmdArgs;
7148
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007149 if (!D.SysRoot.empty())
7150 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7151
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007152 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007153 if (Args.hasArg(options::OPT_static)) {
7154 CmdArgs.push_back("-Bstatic");
7155 } else {
7156 if (Args.hasArg(options::OPT_rdynamic))
7157 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007158 if (Args.hasArg(options::OPT_shared)) {
7159 CmdArgs.push_back("-Bshareable");
7160 } else {
7161 CmdArgs.push_back("-dynamic-linker");
7162 CmdArgs.push_back("/libexec/ld.elf_so");
7163 }
7164 }
7165
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007166 // Many NetBSD architectures support more than one ABI.
7167 // Determine the correct emulation for ld.
7168 switch (getToolChain().getArch()) {
7169 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007170 CmdArgs.push_back("-m");
7171 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007172 break;
7173 case llvm::Triple::arm:
7174 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007175 CmdArgs.push_back("-m");
7176 switch (getToolChain().getTriple().getEnvironment()) {
7177 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007178 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007179 CmdArgs.push_back("armelf_nbsd_eabi");
7180 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007181 case llvm::Triple::EABIHF:
7182 case llvm::Triple::GNUEABIHF:
7183 CmdArgs.push_back("armelf_nbsd_eabihf");
7184 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007185 default:
7186 CmdArgs.push_back("armelf_nbsd");
7187 break;
7188 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007189 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007190 case llvm::Triple::armeb:
7191 case llvm::Triple::thumbeb:
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007192 arm::appendEBLinkFlags(Args, CmdArgs, getToolChain().getTriple());
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007193 CmdArgs.push_back("-m");
7194 switch (getToolChain().getTriple().getEnvironment()) {
7195 case llvm::Triple::EABI:
7196 case llvm::Triple::GNUEABI:
7197 CmdArgs.push_back("armelfb_nbsd_eabi");
7198 break;
7199 case llvm::Triple::EABIHF:
7200 case llvm::Triple::GNUEABIHF:
7201 CmdArgs.push_back("armelfb_nbsd_eabihf");
7202 break;
7203 default:
7204 CmdArgs.push_back("armelfb_nbsd");
7205 break;
7206 }
7207 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007208 case llvm::Triple::mips64:
7209 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007210 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007211 CmdArgs.push_back("-m");
7212 if (getToolChain().getArch() == llvm::Triple::mips64)
7213 CmdArgs.push_back("elf32btsmip");
7214 else
7215 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007216 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007217 CmdArgs.push_back("-m");
7218 if (getToolChain().getArch() == llvm::Triple::mips64)
7219 CmdArgs.push_back("elf64btsmip");
7220 else
7221 CmdArgs.push_back("elf64ltsmip");
7222 }
7223 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007224 case llvm::Triple::ppc:
7225 CmdArgs.push_back("-m");
7226 CmdArgs.push_back("elf32ppc_nbsd");
7227 break;
7228
7229 case llvm::Triple::ppc64:
7230 case llvm::Triple::ppc64le:
7231 CmdArgs.push_back("-m");
7232 CmdArgs.push_back("elf64ppc");
7233 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007234
7235 case llvm::Triple::sparc:
7236 CmdArgs.push_back("-m");
7237 CmdArgs.push_back("elf32_sparc");
7238 break;
7239
7240 case llvm::Triple::sparcv9:
7241 CmdArgs.push_back("-m");
7242 CmdArgs.push_back("elf64_sparc");
7243 break;
7244
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007245 default:
7246 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007247 }
7248
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007249 if (Output.isFilename()) {
7250 CmdArgs.push_back("-o");
7251 CmdArgs.push_back(Output.getFilename());
7252 } else {
7253 assert(Output.isNothing() && "Invalid output.");
7254 }
7255
7256 if (!Args.hasArg(options::OPT_nostdlib) &&
7257 !Args.hasArg(options::OPT_nostartfiles)) {
7258 if (!Args.hasArg(options::OPT_shared)) {
7259 CmdArgs.push_back(Args.MakeArgString(
7260 getToolChain().GetFilePath("crt0.o")));
7261 CmdArgs.push_back(Args.MakeArgString(
7262 getToolChain().GetFilePath("crti.o")));
7263 CmdArgs.push_back(Args.MakeArgString(
7264 getToolChain().GetFilePath("crtbegin.o")));
7265 } else {
7266 CmdArgs.push_back(Args.MakeArgString(
7267 getToolChain().GetFilePath("crti.o")));
7268 CmdArgs.push_back(Args.MakeArgString(
7269 getToolChain().GetFilePath("crtbeginS.o")));
7270 }
7271 }
7272
7273 Args.AddAllArgs(CmdArgs, options::OPT_L);
7274 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7275 Args.AddAllArgs(CmdArgs, options::OPT_e);
7276 Args.AddAllArgs(CmdArgs, options::OPT_s);
7277 Args.AddAllArgs(CmdArgs, options::OPT_t);
7278 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7279 Args.AddAllArgs(CmdArgs, options::OPT_r);
7280
7281 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7282
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007283 unsigned Major, Minor, Micro;
7284 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7285 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007286 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007287 switch(getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007288 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00007289 case llvm::Triple::arm:
7290 case llvm::Triple::armeb:
7291 case llvm::Triple::thumb:
7292 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007293 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007294 case llvm::Triple::ppc64:
7295 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007296 case llvm::Triple::x86:
7297 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007298 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00007299 break;
7300 default:
7301 break;
7302 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007303 }
7304
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007305 if (!Args.hasArg(options::OPT_nostdlib) &&
7306 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007307 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007308 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7309 CmdArgs.push_back("-lm");
7310 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007311 if (Args.hasArg(options::OPT_pthread))
7312 CmdArgs.push_back("-lpthread");
7313 CmdArgs.push_back("-lc");
7314
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007315 if (useLibgcc) {
7316 if (Args.hasArg(options::OPT_static)) {
7317 // libgcc_eh depends on libc, so resolve as much as possible,
7318 // pull in any new requirements from libc and then get the rest
7319 // of libgcc.
7320 CmdArgs.push_back("-lgcc_eh");
7321 CmdArgs.push_back("-lc");
7322 CmdArgs.push_back("-lgcc");
7323 } else {
7324 CmdArgs.push_back("-lgcc");
7325 CmdArgs.push_back("--as-needed");
7326 CmdArgs.push_back("-lgcc_s");
7327 CmdArgs.push_back("--no-as-needed");
7328 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007329 }
7330 }
7331
7332 if (!Args.hasArg(options::OPT_nostdlib) &&
7333 !Args.hasArg(options::OPT_nostartfiles)) {
7334 if (!Args.hasArg(options::OPT_shared))
7335 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7336 "crtend.o")));
7337 else
7338 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7339 "crtendS.o")));
7340 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
7341 "crtn.o")));
7342 }
7343
Alexey Samsonov7811d192014-02-20 13:57:37 +00007344 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007345
Logan Chieneb9162f2014-06-26 14:23:45 +00007346 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00007347 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007348}
7349
Thomas Schwinge4e555262013-03-28 19:04:25 +00007350void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7351 const InputInfo &Output,
7352 const InputInfoList &Inputs,
7353 const ArgList &Args,
7354 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007355 claimNoWarnArgs(Args);
7356
Rafael Espindola92b00932010-08-10 00:25:48 +00007357 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007358 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00007359
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007360 switch (getToolChain().getArch()) {
7361 default:
7362 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00007363 // Add --32/--64 to make sure we get the format we want.
7364 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007365 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00007366 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007367 break;
7368 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00007369 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7370 CmdArgs.push_back("--x32");
7371 else
7372 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007373 break;
7374 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007375 CmdArgs.push_back("-a32");
7376 CmdArgs.push_back("-mppc");
7377 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007378 break;
7379 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00007380 CmdArgs.push_back("-a64");
7381 CmdArgs.push_back("-mppc64");
7382 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007383 break;
7384 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00007385 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007386 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00007387 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007388 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007389 break;
7390 case llvm::Triple::sparc:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007391 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007392 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007393 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007394 break;
7395 case llvm::Triple::sparcv9:
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00007396 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00007397 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007398 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007399 break;
7400 case llvm::Triple::arm:
7401 case llvm::Triple::armeb:
7402 case llvm::Triple::thumb:
7403 case llvm::Triple::thumbeb: {
Scott Douglass3205f522015-03-23 10:54:24 +00007404 const llvm::Triple &Triple = getToolChain().getTriple();
7405 switch (Triple.getSubArch()) {
7406 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00007407 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00007408 break;
7409 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00007410 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00007411 break;
7412 default:
7413 break;
7414 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007415
Tim Northover9c7e0352013-12-12 11:55:52 +00007416 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
Scott Douglass3205f522015-03-23 10:54:24 +00007417 getToolChain().getDriver(), Args, Triple);
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00007418 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007419
7420 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00007421
7422 // FIXME: remove krait check when GNU tools support krait cpu
7423 // for now replace it with -march=armv7-a to avoid a lower
7424 // march from being picked in the absence of a cpu flag.
7425 Arg *A;
7426 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7427 StringRef(A->getValue()) == "krait")
7428 CmdArgs.push_back("-march=armv7-a");
7429 else
7430 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00007431 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007432 break;
7433 }
7434 case llvm::Triple::mips:
7435 case llvm::Triple::mipsel:
7436 case llvm::Triple::mips64:
7437 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007438 StringRef CPUName;
7439 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007440 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007441 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00007442
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007443 CmdArgs.push_back("-march");
7444 CmdArgs.push_back(CPUName.data());
7445
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00007446 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00007447 CmdArgs.push_back(ABIName.data());
7448
Daniel Sanders54d8ee62014-07-23 12:06:13 +00007449 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7450 // or -mshared (not implemented) is in effect.
7451 bool IsPicOrPie = false;
7452 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7453 options::OPT_fpic, options::OPT_fno_pic,
7454 options::OPT_fPIE, options::OPT_fno_PIE,
7455 options::OPT_fpie, options::OPT_fno_pie)) {
7456 if (A->getOption().matches(options::OPT_fPIC) ||
7457 A->getOption().matches(options::OPT_fpic) ||
7458 A->getOption().matches(options::OPT_fPIE) ||
7459 A->getOption().matches(options::OPT_fpie))
7460 IsPicOrPie = true;
7461 }
7462 if (!IsPicOrPie)
7463 CmdArgs.push_back("-mno-shared");
7464
Daniel Sanders379d44b2014-07-16 11:52:23 +00007465 // LLVM doesn't support -mplt yet and acts as if it is always given.
7466 // However, -mplt has no effect with the N64 ABI.
7467 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00007468
7469 if (getToolChain().getArch() == llvm::Triple::mips ||
7470 getToolChain().getArch() == llvm::Triple::mips64)
7471 CmdArgs.push_back("-EB");
7472 else
7473 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00007474
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007475 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7476 if (StringRef(A->getValue()) == "2008")
7477 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7478 }
7479
Daniel Sanders379d44b2014-07-16 11:52:23 +00007480 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7481 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7482 options::OPT_mfp64)) {
7483 A->claim();
7484 A->render(Args, CmdArgs);
7485 } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
7486 ABIName))
7487 CmdArgs.push_back("-mfpxx");
7488
7489 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7490 // -mno-mips16 is actually -no-mips16.
7491 if (Arg *A = Args.getLastArg(options::OPT_mips16,
7492 options::OPT_mno_mips16)) {
7493 if (A->getOption().matches(options::OPT_mips16)) {
7494 A->claim();
7495 A->render(Args, CmdArgs);
7496 } else {
7497 A->claim();
7498 CmdArgs.push_back("-no-mips16");
7499 }
7500 }
7501
Simon Atanasyan036d16d2013-04-30 07:47:13 +00007502 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7503 options::OPT_mno_micromips);
7504 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7505 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7506
Simon Atanasyanbd986632013-11-26 11:58:04 +00007507 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7508 // Do not use AddLastArg because not all versions of MIPS assembler
7509 // support -mmsa / -mno-msa options.
7510 if (A->getOption().matches(options::OPT_mmsa))
7511 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7512 }
7513
Daniel Sanders379d44b2014-07-16 11:52:23 +00007514 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7515 options::OPT_msoft_float);
7516
7517 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7518 options::OPT_mno_odd_spreg);
7519
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007520 NeedsKPIC = true;
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007521 break;
7522 }
7523 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007524 // Always pass an -march option, since our default of z10 is later
7525 // than the GNU assembler's default.
7526 StringRef CPUName = getSystemZTargetCPU(Args);
7527 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00007528 break;
7529 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00007530 }
7531
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00007532 if (NeedsKPIC)
7533 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00007534
7535 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7536 options::OPT_Xassembler);
7537
7538 CmdArgs.push_back("-o");
7539 CmdArgs.push_back(Output.getFilename());
7540
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007541 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00007542 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00007543
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007544 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00007545 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00007546
7547 // Handle the debug info splitting at object creation time if we're
7548 // creating an object.
7549 // TODO: Currently only works on linux with newer objcopy.
7550 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00007551 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00007552 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7553 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00007554}
7555
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00007556static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007557 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00007558 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00007559 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7560 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00007561 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007562 CmdArgs.push_back("-lgcc");
7563
Logan Chien3d3373c2012-11-19 12:04:11 +00007564 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007565 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007566 CmdArgs.push_back("-lgcc");
7567 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00007568 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007569 CmdArgs.push_back("--as-needed");
7570 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00007571 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007572 CmdArgs.push_back("--no-as-needed");
7573 }
7574
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007575 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00007576 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00007577 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00007578 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00007579
7580 // According to Android ABI, we have to link with libdl if we are
7581 // linking with non-static libgcc.
7582 //
7583 // NOTE: This fixes a link error on Android MIPS as well. The non-static
7584 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7585 if (isAndroid && !StaticLibgcc)
7586 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00007587}
7588
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007589static std::string getLinuxDynamicLinker(const ArgList &Args,
7590 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00007591 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7592 if (ToolChain.getTriple().isArch64Bit())
7593 return "/system/bin/linker64";
7594 else
7595 return "/system/bin/linker";
7596 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
7597 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007598 return "/lib/ld-linux.so.2";
Tim Northover40956e62014-07-23 12:32:58 +00007599 else if (ToolChain.getArch() == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007600 return "/lib/ld-linux-aarch64.so.1";
Tim Northover40956e62014-07-23 12:32:58 +00007601 else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007602 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007603 else if (ToolChain.getArch() == llvm::Triple::arm ||
7604 ToolChain.getArch() == llvm::Triple::thumb) {
7605 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7606 return "/lib/ld-linux-armhf.so.3";
7607 else
7608 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007609 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7610 ToolChain.getArch() == llvm::Triple::thumbeb) {
7611 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7612 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7613 else
7614 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007615 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007616 ToolChain.getArch() == llvm::Triple::mipsel ||
7617 ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007618 ToolChain.getArch() == llvm::Triple::mips64el) {
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007619 StringRef CPUName;
7620 StringRef ABIName;
7621 mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7622 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7623
7624 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7625 .Case("o32", "/lib")
7626 .Case("n32", "/lib32")
7627 .Case("n64", "/lib64")
7628 .Default("/lib");
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007629 StringRef LibName;
7630 if (mips::isUCLibc(Args))
7631 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7632 else
7633 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00007634
7635 return (LibDir + "/" + LibName).str();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007636 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7637 return "/lib/ld.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007638 else if (ToolChain.getArch() == llvm::Triple::ppc64) {
7639 if (ppc::hasPPCAbiArg(Args, "elfv2"))
7640 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007641 return "/lib64/ld64.so.1";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007642 } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
7643 if (ppc::hasPPCAbiArg(Args, "elfv1"))
7644 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007645 return "/lib64/ld64.so.2";
Ulrich Weigand8afad612014-07-28 13:17:52 +00007646 } else if (ToolChain.getArch() == llvm::Triple::systemz)
7647 return "/lib64/ld64.so.1";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007648 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7649 return "/lib64/ld-linux.so.2";
Zinovy Nis1db95732014-07-10 15:27:19 +00007650 else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
7651 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7652 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007653 else
7654 return "/lib64/ld-linux-x86-64.so.2";
7655}
7656
Renato Golinc4b49242014-02-13 10:01:16 +00007657static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00007658 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00007659 // Make use of compiler-rt if --rtlib option is used
7660 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7661
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007662 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00007663 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007664 switch (TC.getTriple().getOS()) {
7665 default: llvm_unreachable("unsupported OS");
7666 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007667 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00007668 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00007669 break;
7670 }
Renato Golinc4b49242014-02-13 10:01:16 +00007671 break;
7672 case ToolChain::RLT_Libgcc:
7673 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7674 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007675 }
7676}
7677
Rafael Espindola1e085772014-08-15 17:14:35 +00007678static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7679 switch (T.getArch()) {
7680 case llvm::Triple::x86:
7681 return "elf_i386";
7682 case llvm::Triple::aarch64:
7683 return "aarch64linux";
7684 case llvm::Triple::aarch64_be:
7685 return "aarch64_be_linux";
7686 case llvm::Triple::arm:
7687 case llvm::Triple::thumb:
7688 return "armelf_linux_eabi";
7689 case llvm::Triple::armeb:
7690 case llvm::Triple::thumbeb:
7691 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
7692 case llvm::Triple::ppc:
7693 return "elf32ppclinux";
7694 case llvm::Triple::ppc64:
7695 return "elf64ppc";
7696 case llvm::Triple::ppc64le:
7697 return "elf64lppc";
7698 case llvm::Triple::sparc:
7699 return "elf32_sparc";
7700 case llvm::Triple::sparcv9:
7701 return "elf64_sparc";
7702 case llvm::Triple::mips:
7703 return "elf32btsmip";
7704 case llvm::Triple::mipsel:
7705 return "elf32ltsmip";
7706 case llvm::Triple::mips64:
7707 if (mips::hasMipsAbiArg(Args, "n32"))
7708 return "elf32btsmipn32";
7709 return "elf64btsmip";
7710 case llvm::Triple::mips64el:
7711 if (mips::hasMipsAbiArg(Args, "n32"))
7712 return "elf32ltsmipn32";
7713 return "elf64ltsmip";
7714 case llvm::Triple::systemz:
7715 return "elf64_s390";
7716 case llvm::Triple::x86_64:
7717 if (T.getEnvironment() == llvm::Triple::GNUX32)
7718 return "elf32_x86_64";
7719 return "elf_x86_64";
7720 default:
7721 llvm_unreachable("Unexpected arch");
7722 }
7723}
7724
Thomas Schwinge4e555262013-03-28 19:04:25 +00007725void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7726 const InputInfo &Output,
7727 const InputInfoList &Inputs,
7728 const ArgList &Args,
7729 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007730 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007731 static_cast<const toolchains::Linux&>(getToolChain());
7732 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007733 const bool isAndroid =
7734 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007735 const bool IsPIE =
7736 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007737 !Args.hasArg(options::OPT_static) &&
Dan Albert77214a42015-03-03 18:24:57 +00007738 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007739
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007740 ArgStringList CmdArgs;
7741
Rafael Espindolad1002f62010-11-15 18:28:16 +00007742 // Silence warning for "clang -g foo.o -o foo"
7743 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007744 // and "clang -emit-llvm foo.o -o foo"
7745 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007746 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007747 // handled somewhere else.
7748 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007749
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007750 if (!D.SysRoot.empty())
7751 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007752
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007753 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007754 CmdArgs.push_back("-pie");
7755
Rafael Espindola1c76c592010-11-07 22:57:16 +00007756 if (Args.hasArg(options::OPT_rdynamic))
7757 CmdArgs.push_back("-export-dynamic");
7758
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007759 if (Args.hasArg(options::OPT_s))
7760 CmdArgs.push_back("-s");
7761
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007762 if (ToolChain.getArch() == llvm::Triple::armeb ||
7763 ToolChain.getArch() == llvm::Triple::thumbeb)
7764 arm::appendEBLinkFlags(Args, CmdArgs, getToolChain().getTriple());
7765
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007766 for (const auto &Opt : ToolChain.ExtraOpts)
7767 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007768
7769 if (!Args.hasArg(options::OPT_static)) {
7770 CmdArgs.push_back("--eh-frame-hdr");
7771 }
7772
7773 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00007774 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007775
7776 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007777 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007778 ToolChain.getArch() == llvm::Triple::armeb ||
7779 ToolChain.getArch() == llvm::Triple::thumb ||
7780 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007781 CmdArgs.push_back("-Bstatic");
7782 else
7783 CmdArgs.push_back("-static");
7784 } else if (Args.hasArg(options::OPT_shared)) {
7785 CmdArgs.push_back("-shared");
7786 }
7787
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007788 if (ToolChain.getArch() == llvm::Triple::arm ||
7789 ToolChain.getArch() == llvm::Triple::armeb ||
7790 ToolChain.getArch() == llvm::Triple::thumb ||
7791 ToolChain.getArch() == llvm::Triple::thumbeb ||
7792 (!Args.hasArg(options::OPT_static) &&
7793 !Args.hasArg(options::OPT_shared))) {
7794 CmdArgs.push_back("-dynamic-linker");
7795 CmdArgs.push_back(Args.MakeArgString(
7796 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7797 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007798
7799 CmdArgs.push_back("-o");
7800 CmdArgs.push_back(Output.getFilename());
7801
Rafael Espindola81937ec2010-12-01 01:52:43 +00007802 if (!Args.hasArg(options::OPT_nostdlib) &&
7803 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007804 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007805 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007806 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007807 if (Args.hasArg(options::OPT_pg))
7808 crt1 = "gcrt1.o";
7809 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007810 crt1 = "Scrt1.o";
7811 else
7812 crt1 = "crt1.o";
7813 }
7814 if (crt1)
7815 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007816
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007817 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7818 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007819
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007820 const char *crtbegin;
7821 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007822 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007823 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007824 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007825 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007826 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007827 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007828 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007829 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007830
7831 // Add crtfastmath.o if available and fast math is enabled.
7832 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007833 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007834
7835 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007836 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007837
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007838 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007839
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007840 for (const auto &Path : Paths)
7841 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007842
Peter Collingbournea4ccff32015-02-20 20:30:56 +00007843 if (D.IsUsingLTO(getToolChain(), Args))
Alp Tokerce365ca2013-12-02 12:43:03 +00007844 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007845
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007846 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7847 CmdArgs.push_back("--no-demangle");
7848
Alexey Samsonov52550342014-09-15 19:58:40 +00007849 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007850 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007851 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007852 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007853
Hans Wennborg70850d82013-07-18 20:29:38 +00007854 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007855 !Args.hasArg(options::OPT_nostdlib) &&
7856 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007857 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7858 !Args.hasArg(options::OPT_static);
7859 if (OnlyLibstdcxxStatic)
7860 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007861 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007862 if (OnlyLibstdcxxStatic)
7863 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007864 CmdArgs.push_back("-lm");
7865 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00007866 // Silence warnings when linking C code with a C++ '-stdlib' argument.
7867 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007868
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007869 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007870 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7871 if (Args.hasArg(options::OPT_static))
7872 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007873
Alexey Samsonov52550342014-09-15 19:58:40 +00007874 if (NeedsSanitizerDeps)
7875 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7876
Alexey Bataev186b28a2014-03-06 05:43:53 +00007877 LibOpenMP UsedOpenMPLib = LibUnknown;
7878 if (Args.hasArg(options::OPT_fopenmp)) {
7879 UsedOpenMPLib = LibGOMP;
7880 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7881 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7882 .Case("libgomp", LibGOMP)
7883 .Case("libiomp5", LibIOMP5)
7884 .Default(LibUnknown);
7885 if (UsedOpenMPLib == LibUnknown)
7886 D.Diag(diag::err_drv_unsupported_option_argument)
7887 << A->getOption().getName() << A->getValue();
7888 }
7889 switch (UsedOpenMPLib) {
7890 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007891 CmdArgs.push_back("-lgomp");
7892
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007893 // FIXME: Exclude this for platforms with libgomp that don't require
7894 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007895 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007896 break;
7897 case LibIOMP5:
7898 CmdArgs.push_back("-liomp5");
7899 break;
7900 case LibUnknown:
7901 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007902 }
Renato Golinc4b49242014-02-13 10:01:16 +00007903 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007904
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007905 if ((Args.hasArg(options::OPT_pthread) ||
7906 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7907 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007908 CmdArgs.push_back("-lpthread");
7909
7910 CmdArgs.push_back("-lc");
7911
7912 if (Args.hasArg(options::OPT_static))
7913 CmdArgs.push_back("--end-group");
7914 else
Renato Golinc4b49242014-02-13 10:01:16 +00007915 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007916 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007917
Rafael Espindola81937ec2010-12-01 01:52:43 +00007918 if (!Args.hasArg(options::OPT_nostartfiles)) {
7919 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007920 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007921 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007922 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007923 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007924 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007925 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007926
Rafael Espindola81937ec2010-12-01 01:52:43 +00007927 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007928 if (!isAndroid)
7929 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007930 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007931 }
7932
David Blaikiec11bf802014-09-04 16:04:28 +00007933 C.addCommand(
7934 llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007935}
7936
Derek Schuff6ab52fa2015-03-30 20:31:33 +00007937
7938// NaCl ARM assembly (inline or standalone) can be written with a set of macros
7939// for the various SFI requirements like register masking. The assembly tool
7940// inserts the file containing the macros as an input into all the assembly
7941// jobs.
7942void nacltools::AssembleARM::ConstructJob(Compilation &C, const JobAction &JA,
7943 const InputInfo &Output,
7944 const InputInfoList &Inputs,
7945 const ArgList &Args,
7946 const char *LinkingOutput) const {
7947 const toolchains::NaCl_TC& ToolChain =
7948 static_cast<const toolchains::NaCl_TC&>(getToolChain());
7949 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
7950 "nacl-arm-macros.s");
7951 InputInfoList NewInputs;
7952 NewInputs.push_back(NaClMacros);
7953 NewInputs.append(Inputs.begin(), Inputs.end());
7954 gnutools::Assemble::ConstructJob(C, JA, Output, NewInputs, Args,
7955 LinkingOutput);
7956}
7957
7958
7959// This is quite similar to gnutools::link::ConstructJob with changes that
7960// we use static by default, do not yet support sanitizers or LTO, and a few
7961// others. Eventually we can support more of that and hopefully migrate back
7962// to gnutools::link.
7963void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7964 const InputInfo &Output,
7965 const InputInfoList &Inputs,
7966 const ArgList &Args,
7967 const char *LinkingOutput) const {
7968
7969 const toolchains::NaCl_TC& ToolChain =
7970 static_cast<const toolchains::NaCl_TC&>(getToolChain());
7971 const Driver &D = ToolChain.getDriver();
7972 const bool IsStatic =
7973 !Args.hasArg(options::OPT_dynamic) &&
7974 !Args.hasArg(options::OPT_shared);
7975
7976 ArgStringList CmdArgs;
7977
7978 // Silence warning for "clang -g foo.o -o foo"
7979 Args.ClaimAllArgs(options::OPT_g_Group);
7980 // and "clang -emit-llvm foo.o -o foo"
7981 Args.ClaimAllArgs(options::OPT_emit_llvm);
7982 // and for "clang -w foo.o -o foo". Other warning options are already
7983 // handled somewhere else.
7984 Args.ClaimAllArgs(options::OPT_w);
7985
7986 if (!D.SysRoot.empty())
7987 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7988
7989 if (Args.hasArg(options::OPT_rdynamic))
7990 CmdArgs.push_back("-export-dynamic");
7991
7992 if (Args.hasArg(options::OPT_s))
7993 CmdArgs.push_back("-s");
7994
7995 // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from
7996 // there is --build-id, which we do want.
7997 CmdArgs.push_back("--build-id");
7998
7999 if (!IsStatic)
8000 CmdArgs.push_back("--eh-frame-hdr");
8001
8002 CmdArgs.push_back("-m");
8003 if (ToolChain.getArch() == llvm::Triple::x86)
8004 CmdArgs.push_back("elf_i386_nacl");
8005 else if (ToolChain.getArch() == llvm::Triple::arm)
8006 CmdArgs.push_back("armelf_nacl");
8007 else if (ToolChain.getArch() == llvm::Triple::x86_64)
8008 CmdArgs.push_back("elf_x86_64_nacl");
8009 else
8010 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName() <<
8011 "Native Client";
8012
8013
8014 if (IsStatic)
8015 CmdArgs.push_back("-static");
8016 else if (Args.hasArg(options::OPT_shared))
8017 CmdArgs.push_back("-shared");
8018
8019 CmdArgs.push_back("-o");
8020 CmdArgs.push_back(Output.getFilename());
8021 if (!Args.hasArg(options::OPT_nostdlib) &&
8022 !Args.hasArg(options::OPT_nostartfiles)) {
8023 if (!Args.hasArg(options::OPT_shared))
8024 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8025 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8026
8027 const char *crtbegin;
8028 if (IsStatic)
8029 crtbegin = "crtbeginT.o";
8030 else if (Args.hasArg(options::OPT_shared))
8031 crtbegin = "crtbeginS.o";
8032 else
8033 crtbegin = "crtbegin.o";
8034 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8035 }
8036
8037 Args.AddAllArgs(CmdArgs, options::OPT_L);
8038 Args.AddAllArgs(CmdArgs, options::OPT_u);
8039
8040 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8041
8042 for (const auto &Path : Paths)
8043 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8044
8045 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8046 CmdArgs.push_back("--no-demangle");
8047
8048 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8049
8050 if (D.CCCIsCXX() &&
8051 !Args.hasArg(options::OPT_nostdlib) &&
8052 !Args.hasArg(options::OPT_nodefaultlibs)) {
8053 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8054 !IsStatic;
8055 if (OnlyLibstdcxxStatic)
8056 CmdArgs.push_back("-Bstatic");
8057 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8058 if (OnlyLibstdcxxStatic)
8059 CmdArgs.push_back("-Bdynamic");
8060 CmdArgs.push_back("-lm");
8061 }
8062
8063 if (!Args.hasArg(options::OPT_nostdlib)) {
8064 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8065 // Always use groups, since it has no effect on dynamic libraries.
8066 CmdArgs.push_back("--start-group");
8067 CmdArgs.push_back("-lc");
8068 // NaCl's libc++ currently requires libpthread, so just always include it
8069 // in the group for C++.
8070 if (Args.hasArg(options::OPT_pthread) ||
8071 Args.hasArg(options::OPT_pthreads) ||
8072 D.CCCIsCXX()) {
8073 CmdArgs.push_back("-lpthread");
8074 }
8075
8076 CmdArgs.push_back("-lgcc");
8077 CmdArgs.push_back("--as-needed");
8078 if (IsStatic)
8079 CmdArgs.push_back("-lgcc_eh");
8080 else
8081 CmdArgs.push_back("-lgcc_s");
8082 CmdArgs.push_back("--no-as-needed");
8083 CmdArgs.push_back("--end-group");
8084 }
8085
8086 if (!Args.hasArg(options::OPT_nostartfiles)) {
8087 const char *crtend;
8088 if (Args.hasArg(options::OPT_shared))
8089 crtend = "crtendS.o";
8090 else
8091 crtend = "crtend.o";
8092
8093 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8094 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8095 }
8096 }
8097
8098 C.addCommand(llvm::make_unique<Command>(JA, *this,
8099 ToolChain.Linker.c_str(), CmdArgs));
8100}
8101
8102
Chris Lattner3e2ee142010-07-07 16:01:42 +00008103void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008104 const InputInfo &Output,
8105 const InputInfoList &Inputs,
8106 const ArgList &Args,
8107 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008108 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008109 ArgStringList CmdArgs;
8110
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008111 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008112
8113 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008114 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008115
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008116 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008117 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008118
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008119 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008120 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008121}
8122
8123void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008124 const InputInfo &Output,
8125 const InputInfoList &Inputs,
8126 const ArgList &Args,
8127 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008128 const Driver &D = getToolChain().getDriver();
8129 ArgStringList CmdArgs;
8130
Daniel Dunbarb440f562010-08-02 02:38:21 +00008131 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008132 CmdArgs.push_back("-o");
8133 CmdArgs.push_back(Output.getFilename());
8134 } else {
8135 assert(Output.isNothing() && "Invalid output.");
8136 }
8137
8138 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008139 !Args.hasArg(options::OPT_nostartfiles)) {
8140 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8141 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8142 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8143 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8144 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008145
8146 Args.AddAllArgs(CmdArgs, options::OPT_L);
8147 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8148 Args.AddAllArgs(CmdArgs, options::OPT_e);
8149
Daniel Dunbar54423b22010-09-17 00:24:54 +00008150 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008151
Alexey Samsonov7811d192014-02-20 13:57:37 +00008152 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008153
Chris Lattner3e2ee142010-07-07 16:01:42 +00008154 if (!Args.hasArg(options::OPT_nostdlib) &&
8155 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008156 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008157 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008158 CmdArgs.push_back("-lm");
8159 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008160 }
8161
8162 if (!Args.hasArg(options::OPT_nostdlib) &&
8163 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008164 if (Args.hasArg(options::OPT_pthread))
8165 CmdArgs.push_back("-lpthread");
8166 CmdArgs.push_back("-lc");
8167 CmdArgs.push_back("-lCompilerRT-Generic");
8168 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8169 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00008170 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008171 }
8172
Logan Chieneb9162f2014-06-26 14:23:45 +00008173 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008174 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008175}
8176
Daniel Dunbarcc912342009-05-02 18:28:39 +00008177/// DragonFly Tools
8178
8179// For now, DragonFly Assemble does just about the same as for
8180// FreeBSD, but this may change soon.
8181void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008182 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00008183 const InputInfoList &Inputs,
8184 const ArgList &Args,
8185 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008186 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008187 ArgStringList CmdArgs;
8188
8189 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8190 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008191 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008192 CmdArgs.push_back("--32");
8193
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008194 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008195
8196 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008197 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008198
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008199 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008200 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008201
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008202 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Blaikiec11bf802014-09-04 16:04:28 +00008203 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008204}
8205
8206void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00008207 const InputInfo &Output,
8208 const InputInfoList &Inputs,
8209 const ArgList &Args,
8210 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008211 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008212 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008213 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008214
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008215 if (!D.SysRoot.empty())
8216 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8217
John McCall65b8da02013-04-11 22:55:55 +00008218 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008219 if (Args.hasArg(options::OPT_static)) {
8220 CmdArgs.push_back("-Bstatic");
8221 } else {
John McCall65b8da02013-04-11 22:55:55 +00008222 if (Args.hasArg(options::OPT_rdynamic))
8223 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008224 if (Args.hasArg(options::OPT_shared))
8225 CmdArgs.push_back("-Bshareable");
8226 else {
8227 CmdArgs.push_back("-dynamic-linker");
8228 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8229 }
John McCall65b8da02013-04-11 22:55:55 +00008230 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008231 }
8232
8233 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8234 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008235 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008236 CmdArgs.push_back("-m");
8237 CmdArgs.push_back("elf_i386");
8238 }
8239
Daniel Dunbarb440f562010-08-02 02:38:21 +00008240 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008241 CmdArgs.push_back("-o");
8242 CmdArgs.push_back(Output.getFilename());
8243 } else {
8244 assert(Output.isNothing() && "Invalid output.");
8245 }
8246
8247 if (!Args.hasArg(options::OPT_nostdlib) &&
8248 !Args.hasArg(options::OPT_nostartfiles)) {
8249 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008250 if (Args.hasArg(options::OPT_pg))
8251 CmdArgs.push_back(Args.MakeArgString(
8252 getToolChain().GetFilePath("gcrt1.o")));
8253 else {
8254 if (Args.hasArg(options::OPT_pie))
8255 CmdArgs.push_back(Args.MakeArgString(
8256 getToolChain().GetFilePath("Scrt1.o")));
8257 else
8258 CmdArgs.push_back(Args.MakeArgString(
8259 getToolChain().GetFilePath("crt1.o")));
8260 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008261 }
John McCall65b8da02013-04-11 22:55:55 +00008262 CmdArgs.push_back(Args.MakeArgString(
8263 getToolChain().GetFilePath("crti.o")));
8264 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8265 CmdArgs.push_back(Args.MakeArgString(
8266 getToolChain().GetFilePath("crtbeginS.o")));
8267 else
8268 CmdArgs.push_back(Args.MakeArgString(
8269 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008270 }
8271
8272 Args.AddAllArgs(CmdArgs, options::OPT_L);
8273 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8274 Args.AddAllArgs(CmdArgs, options::OPT_e);
8275
Daniel Dunbar54423b22010-09-17 00:24:54 +00008276 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008277
8278 if (!Args.hasArg(options::OPT_nostdlib) &&
8279 !Args.hasArg(options::OPT_nodefaultlibs)) {
8280 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8281 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00008282 if (UseGCC47)
8283 CmdArgs.push_back("-L/usr/lib/gcc47");
8284 else
8285 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008286
8287 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00008288 if (UseGCC47) {
8289 CmdArgs.push_back("-rpath");
8290 CmdArgs.push_back("/usr/lib/gcc47");
8291 } else {
8292 CmdArgs.push_back("-rpath");
8293 CmdArgs.push_back("/usr/lib/gcc44");
8294 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008295 }
8296
Hans Wennborg70850d82013-07-18 20:29:38 +00008297 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008298 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00008299 CmdArgs.push_back("-lm");
8300 }
8301
Daniel Dunbarcc912342009-05-02 18:28:39 +00008302 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00008303 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008304
8305 if (!Args.hasArg(options::OPT_nolibc)) {
8306 CmdArgs.push_back("-lc");
8307 }
8308
John McCall65b8da02013-04-11 22:55:55 +00008309 if (UseGCC47) {
8310 if (Args.hasArg(options::OPT_static) ||
8311 Args.hasArg(options::OPT_static_libgcc)) {
8312 CmdArgs.push_back("-lgcc");
8313 CmdArgs.push_back("-lgcc_eh");
8314 } else {
8315 if (Args.hasArg(options::OPT_shared_libgcc)) {
8316 CmdArgs.push_back("-lgcc_pic");
8317 if (!Args.hasArg(options::OPT_shared))
8318 CmdArgs.push_back("-lgcc");
8319 } else {
8320 CmdArgs.push_back("-lgcc");
8321 CmdArgs.push_back("--as-needed");
8322 CmdArgs.push_back("-lgcc_pic");
8323 CmdArgs.push_back("--no-as-needed");
8324 }
8325 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008326 } else {
John McCall65b8da02013-04-11 22:55:55 +00008327 if (Args.hasArg(options::OPT_shared)) {
8328 CmdArgs.push_back("-lgcc_pic");
8329 } else {
8330 CmdArgs.push_back("-lgcc");
8331 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00008332 }
8333 }
8334
8335 if (!Args.hasArg(options::OPT_nostdlib) &&
8336 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00008337 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00008338 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00008339 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00008340 else
8341 CmdArgs.push_back(Args.MakeArgString(
8342 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008343 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00008344 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008345 }
8346
Alexey Samsonov7811d192014-02-20 13:57:37 +00008347 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008348
Logan Chieneb9162f2014-06-26 14:23:45 +00008349 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008350 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008351}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008352
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008353// Try to find Exe from a Visual Studio distribution. This first tries to find
8354// an installed copy of Visual Studio and, failing that, looks in the PATH,
8355// making sure that whatever executable that's found is not a same-named exe
8356// from clang itself to prevent clang from falling back to itself.
8357static std::string FindVisualStudioExecutable(const ToolChain &TC,
8358 const char *Exe,
8359 const char *ClangProgramPath) {
8360 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8361 std::string visualStudioBinDir;
8362 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8363 visualStudioBinDir)) {
8364 SmallString<128> FilePath(visualStudioBinDir);
8365 llvm::sys::path::append(FilePath, Exe);
8366 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8367 return FilePath.str();
8368 }
8369
8370 return Exe;
8371}
8372
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008373void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
8374 const InputInfo &Output,
8375 const InputInfoList &Inputs,
8376 const ArgList &Args,
8377 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008378 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008379 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008380
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008381 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8382 if (Output.isFilename())
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00008383 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
8384 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008385
8386 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008387 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008388 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008389
Zachary Turner10d75b22014-10-22 20:40:43 +00008390 if (!llvm::sys::Process::GetEnv("LIB")) {
8391 // If the VC environment hasn't been configured (perhaps because the user
8392 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00008393 // the environment variable is set however, assume the user knows what
8394 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00008395 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008396 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00008397 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8398 SmallString<128> LibDir(VisualStudioDir);
8399 llvm::sys::path::append(LibDir, "VC", "lib");
8400 switch (MSVC.getArch()) {
8401 case llvm::Triple::x86:
8402 // x86 just puts the libraries directly in lib
8403 break;
8404 case llvm::Triple::x86_64:
8405 llvm::sys::path::append(LibDir, "amd64");
8406 break;
8407 case llvm::Triple::arm:
8408 llvm::sys::path::append(LibDir, "arm");
8409 break;
8410 default:
8411 break;
8412 }
8413 CmdArgs.push_back(
8414 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8415 }
8416
8417 std::string WindowsSdkLibPath;
8418 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8419 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8420 WindowsSdkLibPath.c_str()));
8421 }
8422
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008423 CmdArgs.push_back("-nologo");
8424
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00008425 if (Args.hasArg(options::OPT_g_Group))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008426 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00008427
Hans Wennborge4c47f22015-03-04 23:16:21 +00008428 bool DLL = Args.hasArg(options::OPT__SLASH_LD,
8429 options::OPT__SLASH_LDd,
8430 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00008431 if (DLL) {
8432 CmdArgs.push_back(Args.MakeArgString("-dll"));
8433
8434 SmallString<128> ImplibName(Output.getFilename());
8435 llvm::sys::path::replace_extension(ImplibName, "lib");
8436 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
Yaron Keren92e1b622015-03-18 10:17:07 +00008437 ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00008438 }
8439
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008440 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00008441 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00008442 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008443 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008444 static const char *CompilerRTComponents[] = {
8445 "asan_dynamic",
8446 "asan_dynamic_runtime_thunk",
8447 };
8448 for (const auto &Component : CompilerRTComponents)
8449 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00008450 // Make sure the dynamic runtime thunk is not optimized out at link time
8451 // to ensure proper SEH handling.
8452 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00008453 } else if (DLL) {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008454 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008455 } else {
Saleem Abdulrasool1d59f492015-01-02 20:00:55 +00008456 static const char *CompilerRTComponents[] = {
8457 "asan",
8458 "asan_cxx",
8459 };
8460 for (const auto &Component : CompilerRTComponents)
8461 CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
Alexey Samsonov6424e022014-05-12 20:20:20 +00008462 }
Hans Wennborg65f17522013-08-27 18:10:21 +00008463 }
8464
Hans Wennborg2e274592013-08-13 23:38:57 +00008465 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00008466
Reid Kleckner337188f2014-09-16 19:22:00 +00008467 // Add filenames, libraries, and other linker inputs.
8468 for (const auto &Input : Inputs) {
8469 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008470 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00008471 continue;
8472 }
8473
8474 const Arg &A = Input.getInputArg();
8475
8476 // Render -l options differently for the MSVC linker.
8477 if (A.getOption().matches(options::OPT_l)) {
8478 StringRef Lib = A.getValue();
8479 const char *LinkLibArg;
8480 if (Lib.endswith(".lib"))
8481 LinkLibArg = Args.MakeArgString(Lib);
8482 else
8483 LinkLibArg = Args.MakeArgString(Lib + ".lib");
8484 CmdArgs.push_back(LinkLibArg);
8485 continue;
8486 }
8487
8488 // Otherwise, this is some other kind of linker input option like -Wl, -z,
8489 // or -L. Render it, even if MSVC doesn't understand it.
8490 A.renderAsInput(Args, CmdArgs);
8491 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008492
Zachary Turner719f58c2014-12-01 23:06:47 +00008493 // We need to special case some linker paths. In the case of lld, we need to
8494 // translate 'lld' into 'lld-link', and in the case of the regular msvc
8495 // linker, we need to use a special search algorithm.
8496 llvm::SmallString<128> linkPath;
8497 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8498 if (Linker.equals_lower("lld"))
8499 Linker = "lld-link";
8500
8501 if (Linker.equals_lower("link")) {
8502 // If we're using the MSVC linker, it's not sufficient to just use link
8503 // from the program PATH, because other environments like GnuWin32 install
8504 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008505 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00008506 C.getDriver().getClangProgramPath());
8507 } else {
8508 linkPath = Linker;
8509 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00008510 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00008511 }
8512
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008513 const char *Exec = Args.MakeArgString(linkPath);
David Blaikiec11bf802014-09-04 16:04:28 +00008514 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00008515}
Hans Wennborg87cfa712013-09-19 20:32:16 +00008516
8517void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
8518 const InputInfo &Output,
8519 const InputInfoList &Inputs,
8520 const ArgList &Args,
8521 const char *LinkingOutput) const {
8522 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8523}
8524
David Blaikiec11bf802014-09-04 16:04:28 +00008525std::unique_ptr<Command> visualstudio::Compile::GetCommand(
8526 Compilation &C, const JobAction &JA, const InputInfo &Output,
8527 const InputInfoList &Inputs, const ArgList &Args,
8528 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00008529 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00008530 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008531 CmdArgs.push_back("/c"); // Compile only.
8532 CmdArgs.push_back("/W0"); // No warnings.
8533
8534 // The goal is to be able to invoke this tool correctly based on
8535 // any flag accepted by clang-cl.
8536
8537 // These are spelled the same way in clang and cl.exe,.
8538 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8539 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00008540
8541 // Optimization level.
8542 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8543 if (A->getOption().getID() == options::OPT_O0) {
8544 CmdArgs.push_back("/Od");
8545 } else {
8546 StringRef OptLevel = A->getValue();
8547 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8548 A->render(Args, CmdArgs);
8549 else if (OptLevel == "3")
8550 CmdArgs.push_back("/Ox");
8551 }
8552 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00008553
Nico Weber3f8dafb2015-03-12 19:37:10 +00008554 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00008555 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8556
David Majnemerf6072342014-07-01 22:24:56 +00008557 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8558 /*default=*/false))
8559 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00008560 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8561 options::OPT_fno_function_sections))
8562 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8563 ? "/Gy"
8564 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00008565 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8566 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00008567 CmdArgs.push_back(
8568 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008569 if (Args.hasArg(options::OPT_fsyntax_only))
8570 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00008571 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8572 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00008573
Nico Weber3f8dafb2015-03-12 19:37:10 +00008574 std::vector<std::string> Includes =
8575 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008576 for (const auto &Include : Includes)
8577 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00008578
Hans Wennborg87cfa712013-09-19 20:32:16 +00008579 // Flags that can simply be passed through.
8580 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8581 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00008582 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008583
8584 // The order of these flags is relevant, so pick the last one.
8585 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8586 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8587 A->render(Args, CmdArgs);
8588
8589
8590 // Input filename.
8591 assert(Inputs.size() == 1);
8592 const InputInfo &II = Inputs[0];
8593 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8594 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8595 if (II.isFilename())
8596 CmdArgs.push_back(II.getFilename());
8597 else
8598 II.getInputArg().renderAsInput(Args, CmdArgs);
8599
8600 // Output filename.
8601 assert(Output.getType() == types::TY_Object);
8602 const char *Fo = Args.MakeArgString(std::string("/Fo") +
8603 Output.getFilename());
8604 CmdArgs.push_back(Fo);
8605
Hans Wennborg188382e2013-09-20 18:16:35 +00008606 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00008607 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8608 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00008609 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8610 CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00008611}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008612
8613
8614/// XCore Tools
8615// We pass assemble and link construction to the xcc tool.
8616
8617void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8618 const InputInfo &Output,
8619 const InputInfoList &Inputs,
8620 const ArgList &Args,
8621 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008622 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008623 ArgStringList CmdArgs;
8624
8625 CmdArgs.push_back("-o");
8626 CmdArgs.push_back(Output.getFilename());
8627
8628 CmdArgs.push_back("-c");
8629
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008630 if (Args.hasArg(options::OPT_v))
8631 CmdArgs.push_back("-v");
8632
Robert Lytton894d25c2014-05-02 09:33:25 +00008633 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
8634 if (!A->getOption().matches(options::OPT_g0))
8635 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008636
Robert Lytton8e95d4e2014-02-11 10:34:45 +00008637 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
8638 false))
8639 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008640
8641 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
8642 options::OPT_Xassembler);
8643
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008644 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008645 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008646
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008647 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008648 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008649}
8650
8651void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
8652 const InputInfo &Output,
8653 const InputInfoList &Inputs,
8654 const ArgList &Args,
8655 const char *LinkingOutput) const {
8656 ArgStringList CmdArgs;
8657
8658 if (Output.isFilename()) {
8659 CmdArgs.push_back("-o");
8660 CmdArgs.push_back(Output.getFilename());
8661 } else {
8662 assert(Output.isNothing() && "Invalid output.");
8663 }
8664
Robert Lytton9e8c1a42014-02-13 10:40:12 +00008665 if (Args.hasArg(options::OPT_v))
8666 CmdArgs.push_back("-v");
8667
David Majnemer8de68642014-12-05 08:11:58 +00008668 if (exceptionSettings(Args, getToolChain().getTriple()))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00008669 CmdArgs.push_back("-fexceptions");
8670
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008671 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8672
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008673 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
David Blaikiec11bf802014-09-04 16:04:28 +00008674 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00008675}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008676
8677void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
8678 const InputInfo &Output,
8679 const InputInfoList &Inputs,
8680 const ArgList &Args,
8681 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008682 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008683 const auto &TC =
8684 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8685 ArgStringList CmdArgs;
8686 const char *Exec;
8687
8688 switch (TC.getArch()) {
8689 default: llvm_unreachable("unsupported architecture");
8690 case llvm::Triple::arm:
8691 case llvm::Triple::thumb:
8692 break;
8693 case llvm::Triple::x86:
8694 CmdArgs.push_back("--32");
8695 break;
8696 case llvm::Triple::x86_64:
8697 CmdArgs.push_back("--64");
8698 break;
8699 }
8700
8701 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8702
8703 CmdArgs.push_back("-o");
8704 CmdArgs.push_back(Output.getFilename());
8705
8706 for (const auto &Input : Inputs)
8707 CmdArgs.push_back(Input.getFilename());
8708
8709 const std::string Assembler = TC.GetProgramPath("as");
8710 Exec = Args.MakeArgString(Assembler);
8711
8712 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8713}
8714
8715void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
8716 const InputInfo &Output,
8717 const InputInfoList &Inputs,
8718 const ArgList &Args,
8719 const char *LinkingOutput) const {
8720 const auto &TC =
8721 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
8722 const llvm::Triple &T = TC.getTriple();
8723 const Driver &D = TC.getDriver();
8724 SmallString<128> EntryPoint;
8725 ArgStringList CmdArgs;
8726 const char *Exec;
8727
8728 // Silence warning for "clang -g foo.o -o foo"
8729 Args.ClaimAllArgs(options::OPT_g_Group);
8730 // and "clang -emit-llvm foo.o -o foo"
8731 Args.ClaimAllArgs(options::OPT_emit_llvm);
8732 // and for "clang -w foo.o -o foo"
8733 Args.ClaimAllArgs(options::OPT_w);
8734 // Other warning options are already handled somewhere else.
8735
8736 if (!D.SysRoot.empty())
8737 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8738
8739 if (Args.hasArg(options::OPT_pie))
8740 CmdArgs.push_back("-pie");
8741 if (Args.hasArg(options::OPT_rdynamic))
8742 CmdArgs.push_back("-export-dynamic");
8743 if (Args.hasArg(options::OPT_s))
8744 CmdArgs.push_back("--strip-all");
8745
8746 CmdArgs.push_back("-m");
8747 switch (TC.getArch()) {
8748 default: llvm_unreachable("unsupported architecture");
8749 case llvm::Triple::arm:
8750 case llvm::Triple::thumb:
8751 // FIXME: this is incorrect for WinCE
8752 CmdArgs.push_back("thumb2pe");
8753 break;
8754 case llvm::Triple::x86:
8755 CmdArgs.push_back("i386pe");
8756 EntryPoint.append("_");
8757 break;
8758 case llvm::Triple::x86_64:
8759 CmdArgs.push_back("i386pep");
8760 break;
8761 }
8762
8763 if (Args.hasArg(options::OPT_shared)) {
8764 switch (T.getArch()) {
8765 default: llvm_unreachable("unsupported architecture");
8766 case llvm::Triple::arm:
8767 case llvm::Triple::thumb:
8768 case llvm::Triple::x86_64:
8769 EntryPoint.append("_DllMainCRTStartup");
8770 break;
8771 case llvm::Triple::x86:
8772 EntryPoint.append("_DllMainCRTStartup@12");
8773 break;
8774 }
8775
8776 CmdArgs.push_back("-shared");
8777 CmdArgs.push_back("-Bdynamic");
8778
8779 CmdArgs.push_back("--enable-auto-image-base");
8780
8781 CmdArgs.push_back("--entry");
8782 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8783 } else {
8784 EntryPoint.append("mainCRTStartup");
8785
8786 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
8787 : "-Bdynamic");
8788
8789 if (!Args.hasArg(options::OPT_nostdlib) &&
8790 !Args.hasArg(options::OPT_nostartfiles)) {
8791 CmdArgs.push_back("--entry");
8792 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
8793 }
8794
8795 // FIXME: handle subsystem
8796 }
8797
8798 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00008799 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008800
8801 CmdArgs.push_back("-o");
8802 CmdArgs.push_back(Output.getFilename());
8803
8804 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
8805 SmallString<261> ImpLib(Output.getFilename());
8806 llvm::sys::path::replace_extension(ImpLib, ".lib");
8807
8808 CmdArgs.push_back("--out-implib");
8809 CmdArgs.push_back(Args.MakeArgString(ImpLib));
8810 }
8811
8812 if (!Args.hasArg(options::OPT_nostdlib) &&
8813 !Args.hasArg(options::OPT_nostartfiles)) {
8814 const std::string CRTPath(D.SysRoot + "/usr/lib/");
8815 const char *CRTBegin;
8816
8817 CRTBegin =
8818 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
8819 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
8820 }
8821
8822 Args.AddAllArgs(CmdArgs, options::OPT_L);
8823
8824 const auto &Paths = TC.getFilePaths();
8825 for (const auto &Path : Paths)
8826 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8827
8828 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
8829
8830 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8831 !Args.hasArg(options::OPT_nodefaultlibs)) {
8832 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
8833 !Args.hasArg(options::OPT_static);
8834 if (StaticCXX)
8835 CmdArgs.push_back("-Bstatic");
8836 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
8837 if (StaticCXX)
8838 CmdArgs.push_back("-Bdynamic");
8839 }
8840
8841 if (!Args.hasArg(options::OPT_nostdlib)) {
8842 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8843 // TODO handle /MT[d] /MD[d]
8844 CmdArgs.push_back("-lmsvcrt");
8845 AddRunTimeLibs(TC, D, CmdArgs, Args);
8846 }
8847 }
8848
8849 const std::string Linker = TC.GetProgramPath("ld");
8850 Exec = Args.MakeArgString(Linker);
8851
8852 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8853}