blob: de03ce6fa40b02b7793f6aec4192513d58d61aa3 [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"
Josh Mageee0fc1a82014-02-11 01:35:14 +000013#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000015#include "clang/Basic/Version.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000016#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000018#include "clang/Driver/Driver.h"
19#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000020#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000021#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000022#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000023#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000024#include "clang/Driver/Util.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000025#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000026#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000027#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000028#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000029#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
David Blaikie24bbfed22014-03-31 23:29:38 +000032#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000033#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000034#include "llvm/Support/FileSystem.h"
Daniel Dunbarc1964212009-03-26 16:23:12 +000035#include "llvm/Support/Format.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000036#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000037#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000038#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000039#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/Support/raw_ostream.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000041#include <sys/stat.h>
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000042
Daniel Dunbar1a093d22009-03-18 06:00:36 +000043using namespace clang::driver;
44using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000045using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000046using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000047
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +000048static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
49 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
50 options::OPT_fpic, options::OPT_fno_pic,
51 options::OPT_fPIE, options::OPT_fno_PIE,
52 options::OPT_fpie, options::OPT_fno_pie);
53 if (!LastPICArg)
54 return;
55 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
56 LastPICArg->getOption().matches(options::OPT_fpic) ||
57 LastPICArg->getOption().matches(options::OPT_fPIE) ||
58 LastPICArg->getOption().matches(options::OPT_fpie)) {
59 CmdArgs.push_back("-KPIC");
60 }
61}
62
Daniel Dunbar64198ef2009-09-10 01:21:05 +000063/// CheckPreprocessingOptions - Perform some validation of preprocessing
64/// arguments that is shared with gcc.
65static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000066 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
67 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
68 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000069 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000070 << A->getBaseArg().getAsString(Args)
71 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
72 }
73 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000074}
75
Daniel Dunbar4eadb602009-09-10 01:21:12 +000076/// CheckCodeGenerationOptions - Perform some validation of code generation
77/// arguments that is shared with gcc.
78static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
79 // In gcc, only ARM checks this, but it seems reasonable to check universally.
80 if (Args.hasArg(options::OPT_static))
81 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
82 options::OPT_mdynamic_no_pic))
Chris Lattner0e62c1c2011-07-23 10:55:15 +000083 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbar4eadb602009-09-10 01:21:12 +000084 << A->getAsString(Args) << "-static";
85}
86
Chris Lattnerbf2803f2010-03-29 17:55:58 +000087// Quote target names for inclusion in GNU Make dependency files.
88// Only the characters '$', '#', ' ', '\t' are quoted.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000089static void QuoteTarget(StringRef Target,
90 SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +000091 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
92 switch (Target[i]) {
93 case ' ':
94 case '\t':
95 // Escape the preceding backslashes
96 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
97 Res.push_back('\\');
98
99 // Escape the space/tab
100 Res.push_back('\\');
101 break;
102 case '$':
103 Res.push_back('$');
104 break;
105 case '#':
106 Res.push_back('\\');
107 break;
108 default:
109 break;
110 }
111
112 Res.push_back(Target[i]);
113 }
114}
115
Bill Wendlingc0938f32012-03-12 22:10:06 +0000116static void addDirectoryList(const ArgList &Args,
Bill Wendling281ca292012-03-12 21:22:35 +0000117 ArgStringList &CmdArgs,
118 const char *ArgName,
Bill Wendlingc0938f32012-03-12 22:10:06 +0000119 const char *EnvVar) {
120 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000121 bool CombinedArg = false;
122
Bill Wendling281ca292012-03-12 21:22:35 +0000123 if (!DirList)
124 return; // Nothing to do.
125
Chad Rosier616e8a52012-10-30 21:42:09 +0000126 StringRef Name(ArgName);
127 if (Name.equals("-I") || Name.equals("-L"))
128 CombinedArg = true;
129
Bill Wendling281ca292012-03-12 21:22:35 +0000130 StringRef Dirs(DirList);
131 if (Dirs.empty()) // Empty string should not add '.'.
132 return;
133
134 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000135 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000136 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000137 if (CombinedArg) {
138 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
139 } else {
140 CmdArgs.push_back(ArgName);
141 CmdArgs.push_back(".");
142 }
Bill Wendling281ca292012-03-12 21:22:35 +0000143 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000144 if (CombinedArg) {
145 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
146 } else {
147 CmdArgs.push_back(ArgName);
148 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
149 }
Bill Wendling281ca292012-03-12 21:22:35 +0000150 }
Nico Weber89355782012-03-19 15:00:03 +0000151 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000152 }
153
154 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000155 if (CombinedArg) {
156 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
157 } else {
158 CmdArgs.push_back(ArgName);
159 CmdArgs.push_back(".");
160 }
Bill Wendling281ca292012-03-12 21:22:35 +0000161 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000162 if (CombinedArg) {
163 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
164 } else {
165 CmdArgs.push_back(ArgName);
166 CmdArgs.push_back(Args.MakeArgString(Dirs));
167 }
Bill Wendling281ca292012-03-12 21:22:35 +0000168 }
169}
170
Daniel Dunbar54423b22010-09-17 00:24:54 +0000171static void AddLinkerInputs(const ToolChain &TC,
172 const InputInfoList &Inputs, const ArgList &Args,
173 ArgStringList &CmdArgs) {
174 const Driver &D = TC.getDriver();
175
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000176 // Add extra linker input arguments which are not treated as inputs
177 // (constructed via -Xarch_).
178 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
179
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000180 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000181 if (!TC.HasNativeLLVMSupport()) {
182 // Don't try to pass LLVM inputs unless we have native support.
183 if (II.getType() == types::TY_LLVM_IR ||
184 II.getType() == types::TY_LTO_IR ||
185 II.getType() == types::TY_LLVM_BC ||
186 II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000187 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar54423b22010-09-17 00:24:54 +0000188 << TC.getTripleString();
189 }
190
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000191 // Add filenames immediately.
192 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000193 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000194 continue;
195 }
196
197 // Otherwise, this is a linker input argument.
198 const Arg &A = II.getInputArg();
199
200 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000201 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000202 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000203 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000204 TC.AddCCKextLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000205 else
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000206 A.renderAsInput(Args, CmdArgs);
Daniel Dunbar54423b22010-09-17 00:24:54 +0000207 }
Bill Wendling281ca292012-03-12 21:22:35 +0000208
209 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000210 // and only supported on native toolchains.
211 if (!TC.isCrossCompiling())
212 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000213}
214
John McCall31168b02011-06-15 23:02:42 +0000215/// \brief Determine whether Objective-C automated reference counting is
216/// enabled.
217static bool isObjCAutoRefCount(const ArgList &Args) {
218 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
219}
220
Ted Kremeneke65b0862012-03-06 20:05:56 +0000221/// \brief Determine whether we are linking the ObjC runtime.
222static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000223 if (isObjCAutoRefCount(Args)) {
224 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000225 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000226 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000227 return Args.hasArg(options::OPT_fobjc_link_runtime);
228}
229
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000230static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000231 // Don't forward inputs from the original command line. They are added from
232 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000233 return O.getKind() != Option::InputClass &&
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000234 !O.hasFlag(options::DriverOption) &&
235 !O.hasFlag(options::LinkerInput);
236}
237
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000238void Clang::AddPreprocessingOptions(Compilation &C,
Chad Rosier633dcdc2013-01-24 19:14:47 +0000239 const JobAction &JA,
Peter Collingbourne9b515cb2011-11-06 00:40:05 +0000240 const Driver &D,
Douglas Gregor111af7d2009-04-18 00:34:01 +0000241 const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000242 ArgStringList &CmdArgs,
243 const InputInfo &Output,
244 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000245 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000246
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000247 CheckPreprocessingOptions(D, Args);
248
249 Args.AddLastArg(CmdArgs, options::OPT_C);
250 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000251
252 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000253 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000254 (A = Args.getLastArg(options::OPT_MD)) ||
255 (A = Args.getLastArg(options::OPT_MMD))) {
256 // Determine the output location.
257 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000258 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000259 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000260 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000261 } else if (Output.getType() == types::TY_Dependencies) {
262 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000263 } else if (A->getOption().matches(options::OPT_M) ||
264 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000265 DepFile = "-";
266 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000267 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000268 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000269 }
270 CmdArgs.push_back("-dependency-file");
271 CmdArgs.push_back(DepFile);
272
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000273 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000274 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
275 const char *DepTarget;
276
277 // If user provided -o, that is the dependency target, except
278 // when we are only generating a dependency file.
279 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
280 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000281 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000282 } else {
283 // Otherwise derive from the base input.
284 //
285 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000286 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000287 llvm::sys::path::replace_extension(P, "o");
288 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000289 }
290
291 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000292 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000293 QuoteTarget(DepTarget, Quoted);
294 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000295 }
296
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000297 if (A->getOption().matches(options::OPT_M) ||
298 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000299 CmdArgs.push_back("-sys-header-deps");
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000300
301 if (isa<PrecompileJobAction>(JA))
302 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000303 }
304
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000305 if (Args.hasArg(options::OPT_MG)) {
306 if (!A || A->getOption().matches(options::OPT_MD) ||
307 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000308 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000309 CmdArgs.push_back("-MG");
310 }
311
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000312 Args.AddLastArg(CmdArgs, options::OPT_MP);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000313
314 // Convert all -MQ <target> args to -MT <quoted target>
315 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
316 options::OPT_MQ),
317 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000318 const Arg *A = *it;
319 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000320
Daniel Dunbara442fd52010-06-11 22:00:13 +0000321 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000322 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000323 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000324 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000325 CmdArgs.push_back(Args.MakeArgString(Quoted));
326
327 // -MT flag - no change
328 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000329 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000330 }
331 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000332
Douglas Gregor111af7d2009-04-18 00:34:01 +0000333 // Add -i* options, and automatically translate to
334 // -include-pch/-include-pth for transparent PCH support. It's
335 // wonky, but we include looking for .gch so we can support seamless
336 // replacement into a build system already set up to be generating
337 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000338 bool RenderedImplicitInclude = false;
Daniel Dunbar44b36ee2009-11-25 11:53:23 +0000339 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
340 ie = Args.filtered_end(); it != ie; ++it) {
341 const Arg *A = it;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000342
343 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000344 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
345 RenderedImplicitInclude = true;
346
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000347 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000348 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000349
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000350 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000351 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000352 SmallString<128> P(A->getValue());
353 // We want the files to have a name like foo.h.pch. Add a dummy extension
354 // so that replace_extension does the right thing.
355 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000356 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000357 llvm::sys::path::replace_extension(P, "pch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000358 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000359 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000360 }
361
Douglas Gregor111af7d2009-04-18 00:34:01 +0000362 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000363 llvm::sys::path::replace_extension(P, "pth");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000364 if (llvm::sys::fs::exists(P.str()))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000365 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000366 }
367
Douglas Gregor111af7d2009-04-18 00:34:01 +0000368 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000369 llvm::sys::path::replace_extension(P, "gch");
Rafael Espindola54bbaad2013-06-25 14:48:00 +0000370 if (llvm::sys::fs::exists(P.str())) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000371 FoundPCH = UsePCH;
372 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000373 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000374 }
375
376 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000377 if (IsFirstImplicitInclude) {
378 A->claim();
379 if (UsePCH)
380 CmdArgs.push_back("-include-pch");
381 else
382 CmdArgs.push_back("-include-pth");
383 CmdArgs.push_back(Args.MakeArgString(P.str()));
384 continue;
385 } else {
386 // Ignore the PCH if not first on command line and emit warning.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000387 D.Diag(diag::warn_drv_pch_not_first_include)
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000388 << P.str() << A->getAsString(Args);
389 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000390 }
391 }
392
393 // Not translated, render as usual.
394 A->claim();
395 A->render(Args, CmdArgs);
396 }
397
398 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
Douglas Gregor9f93e382011-07-28 04:45:53 +0000399 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
400 options::OPT_index_header_map);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000401
402 // Add -Wp, and -Xassembler if using the preprocessor.
403
404 // FIXME: There is a very unfortunate problem here, some troubled
405 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
406 // really support that we would have to parse and then translate
407 // those options. :(
408 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
409 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000410
411 // -I- is a deprecated GCC feature, reject it.
412 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000413 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000414
415 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
416 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000417 StringRef sysroot = C.getSysRoot();
418 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000419 if (!Args.hasArg(options::OPT_isysroot)) {
420 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000421 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000422 }
423 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000424
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000425 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000426 // FIXME: We should probably sink the logic for handling these from the
427 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000428 // CPATH - included following the user specified includes (but prior to
429 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000430 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000431 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000432 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000433 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000434 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000435 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000436 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000437 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000438 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000439
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000440 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000441 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000442 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000443
444 // Add system include arguments.
445 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000446}
447
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000448// FIXME: Move to target hook.
449static bool isSignedCharDefault(const llvm::Triple &Triple) {
450 switch (Triple.getArch()) {
451 default:
452 return true;
453
Tim Northover9bb857a2013-01-31 12:13:10 +0000454 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000455 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +0000456 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +0000457 case llvm::Triple::arm64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000458 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000459 case llvm::Triple::armeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000460 if (Triple.isOSDarwin() || Triple.isOSWindows())
461 return true;
462 return false;
463
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000464 case llvm::Triple::ppc:
465 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000466 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000467 return true;
468 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000469
Bill Schmidt778d3872013-07-26 01:36:11 +0000470 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000471 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000472 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000473 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000474 }
475}
476
Robert Lytton0e076492013-08-13 09:43:10 +0000477static bool isNoCommonDefault(const llvm::Triple &Triple) {
478 switch (Triple.getArch()) {
479 default:
480 return false;
481
482 case llvm::Triple::xcore:
483 return true;
484 }
485}
486
Chad Rosiercfbfc582012-04-04 20:51:35 +0000487// Handle -mfpu=.
488//
489// FIXME: Centralize feature selection, defaulting shouldn't be also in the
490// frontend target.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000491static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
492 const ArgList &Args,
493 std::vector<const char *> &Features) {
494 StringRef FPU = A->getValue();
495 if (FPU == "fp-armv8") {
496 Features.push_back("+fp-armv8");
497 } else if (FPU == "neon-fp-armv8") {
498 Features.push_back("+fp-armv8");
499 Features.push_back("+neon");
500 } else if (FPU == "crypto-neon-fp-armv8") {
501 Features.push_back("+fp-armv8");
502 Features.push_back("+neon");
503 Features.push_back("+crypto");
504 } else if (FPU == "neon") {
505 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000506 } else
507 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
508}
509
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000510// Handle -mhwdiv=.
511static void getARMHWDivFeatures(const Driver &D, const Arg *A,
512 const ArgList &Args,
513 std::vector<const char *> &Features) {
514 StringRef HWDiv = A->getValue();
515 if (HWDiv == "arm") {
516 Features.push_back("+hwdiv-arm");
517 Features.push_back("-hwdiv");
518 } else if (HWDiv == "thumb") {
519 Features.push_back("-hwdiv-arm");
520 Features.push_back("+hwdiv");
521 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
522 Features.push_back("+hwdiv-arm");
523 Features.push_back("+hwdiv");
524 } else if (HWDiv == "none") {
525 Features.push_back("-hwdiv-arm");
526 Features.push_back("-hwdiv");
527 } else
528 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
529}
530
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000531// Handle -mfpu=.
532//
533// FIXME: Centralize feature selection, defaulting shouldn't be also in the
534// frontend target.
535static void getARMFPUFeatures(const Driver &D, const Arg *A,
536 const ArgList &Args,
537 std::vector<const char *> &Features) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000538 StringRef FPU = A->getValue();
Chad Rosiercfbfc582012-04-04 20:51:35 +0000539
540 // Set the target features based on the FPU.
541 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
542 // Disable any default FPU support.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000543 Features.push_back("-vfp2");
544 Features.push_back("-vfp3");
545 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000546 } else if (FPU == "vfp") {
547 Features.push_back("+vfp2");
548 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000549 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000550 Features.push_back("+vfp3");
551 Features.push_back("+d16");
552 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000553 } else if (FPU == "vfp3" || FPU == "vfpv3") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000554 Features.push_back("+vfp3");
555 Features.push_back("-neon");
Artyom Skrobov53b000a82013-11-21 14:04:38 +0000556 } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
557 Features.push_back("+vfp4");
558 Features.push_back("+d16");
559 Features.push_back("-neon");
560 } else if (FPU == "vfp4" || FPU == "vfpv4") {
561 Features.push_back("+vfp4");
562 Features.push_back("-neon");
Oliver Stannard96601ca2014-02-21 10:39:15 +0000563 } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
564 Features.push_back("+vfp4");
565 Features.push_back("+d16");
566 Features.push_back("+fp-only-sp");
567 Features.push_back("-neon");
Joey Gouly7db275b2013-06-27 13:19:54 +0000568 } else if (FPU == "fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000569 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000570 Features.push_back("-neon");
571 Features.push_back("-crypto");
Joey Gouly7db275b2013-06-27 13:19:54 +0000572 } else if (FPU == "neon-fp-armv8") {
Joey Goulybe8c2732013-09-13 13:48:33 +0000573 Features.push_back("+fp-armv8");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000574 Features.push_back("+neon");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000575 Features.push_back("-crypto");
Amara Emersonfc362c62013-09-19 13:54:03 +0000576 } else if (FPU == "crypto-neon-fp-armv8") {
Amara Emersonfc362c62013-09-19 13:54:03 +0000577 Features.push_back("+fp-armv8");
Bernard Ogdenda13af32013-10-24 18:32:51 +0000578 Features.push_back("+neon");
579 Features.push_back("+crypto");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000580 } else if (FPU == "neon") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000581 Features.push_back("+neon");
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000582 } else if (FPU == "none") {
583 Features.push_back("-vfp2");
584 Features.push_back("-vfp3");
585 Features.push_back("-vfp4");
586 Features.push_back("-fp-armv8");
587 Features.push_back("-crypto");
588 Features.push_back("-neon");
Chad Rosiercfbfc582012-04-04 20:51:35 +0000589 } else
590 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
591}
592
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000593// Select the float ABI as determined by -msoft-float, -mhard-float, and
594// -mfloat-abi=.
Tim Northover9c7e0352013-12-12 11:55:52 +0000595StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
596 const llvm::Triple &Triple) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000597 StringRef FloatABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000598 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
599 options::OPT_mhard_float,
600 options::OPT_mfloat_abi_EQ)) {
601 if (A->getOption().matches(options::OPT_msoft_float))
602 FloatABI = "soft";
603 else if (A->getOption().matches(options::OPT_mhard_float))
604 FloatABI = "hard";
605 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000606 FloatABI = A->getValue();
Daniel Dunbar78485922009-09-10 23:00:09 +0000607 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000608 D.Diag(diag::err_drv_invalid_mfloat_abi)
Daniel Dunbar78485922009-09-10 23:00:09 +0000609 << A->getAsString(Args);
610 FloatABI = "soft";
611 }
612 }
613 }
614
615 // If unspecified, choose the default based on the platform.
616 if (FloatABI.empty()) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000617 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000618 case llvm::Triple::Darwin:
619 case llvm::Triple::MacOSX:
620 case llvm::Triple::IOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000621 // Darwin defaults to "softfp" for v6 and v7.
622 //
623 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
Benjamin Kramer09811c72012-06-26 22:20:06 +0000624 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000625 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000626 if (StringRef(ArchName).startswith("v6") ||
627 StringRef(ArchName).startswith("v7"))
Daniel Dunbar78485922009-09-10 23:00:09 +0000628 FloatABI = "softfp";
629 else
630 FloatABI = "soft";
631 break;
632 }
633
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000634 // FIXME: this is invalid for WindowsCE
635 case llvm::Triple::Win32:
636 FloatABI = "hard";
637 break;
638
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000639 case llvm::Triple::FreeBSD:
Renato Golinf4421f72014-02-19 10:44:07 +0000640 switch(Triple.getEnvironment()) {
641 case llvm::Triple::GNUEABIHF:
642 FloatABI = "hard";
643 break;
644 default:
645 // FreeBSD defaults to soft float
646 FloatABI = "soft";
647 break;
648 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000649 break;
650
Daniel Dunbar78485922009-09-10 23:00:09 +0000651 default:
Bob Wilsond1447c42011-02-04 17:59:28 +0000652 switch(Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000653 case llvm::Triple::GNUEABIHF:
654 FloatABI = "hard";
655 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000656 case llvm::Triple::GNUEABI:
657 FloatABI = "softfp";
658 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000659 case llvm::Triple::EABIHF:
660 FloatABI = "hard";
661 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000662 case llvm::Triple::EABI:
663 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
664 FloatABI = "softfp";
665 break;
Logan Chienc6fd8202012-09-02 09:30:11 +0000666 case llvm::Triple::Android: {
Benjamin Kramer09811c72012-06-26 22:20:06 +0000667 std::string ArchName =
Bernard Ogden31561762013-12-12 13:27:11 +0000668 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
Benjamin Kramer09811c72012-06-26 22:20:06 +0000669 if (StringRef(ArchName).startswith("v7"))
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000670 FloatABI = "softfp";
671 else
672 FloatABI = "soft";
673 break;
674 }
Bob Wilsond1447c42011-02-04 17:59:28 +0000675 default:
676 // Assume "soft", but warn the user we are guessing.
677 FloatABI = "soft";
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000678 if (Triple.getOS() != llvm::Triple::UnknownOS ||
679 !Triple.isOSBinFormatMachO())
680 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000681 break;
682 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000683 }
684 }
685
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000686 return FloatABI;
687}
688
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000689static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
690 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000691 std::vector<const char *> &Features,
692 bool ForAS) {
Tim Northover9c7e0352013-12-12 11:55:52 +0000693 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000694 if (!ForAS) {
695 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
696 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
697 // stripped out by the ARM target. We should probably pass this a new
698 // -target-option, which is handled by the -cc1/-cc1as invocation.
699 //
700 // FIXME2: For consistency, it would be ideal if we set up the target
701 // machine state the same when using the frontend or the assembler. We don't
702 // currently do that for the assembler, we pass the options directly to the
703 // backend and never even instantiate the frontend TargetInfo. If we did,
704 // and used its handleTargetFeatures hook, then we could ensure the
705 // assembler and the frontend behave the same.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000706
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000707 // Use software floating point operations?
708 if (FloatABI == "soft")
709 Features.push_back("+soft-float");
710
711 // Use software floating point argument passing?
712 if (FloatABI != "hard")
713 Features.push_back("+soft-float-abi");
714 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000715
716 // Honor -mfpu=.
717 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000718 getARMFPUFeatures(D, A, Args, Features);
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000719 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
720 getARMHWDivFeatures(D, A, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000721
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000722 // Setting -msoft-float effectively disables NEON because of the GCC
723 // implementation, although the same isn't true of VFP or VFP3.
Amara Emersonecbe18e2014-02-12 10:22:35 +0000724 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000725 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000726 // Also need to explicitly disable features which imply NEON.
727 Features.push_back("-crypto");
728 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000729
730 // En/disable crc
731 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
732 options::OPT_mnocrc)) {
733 if (A->getOption().matches(options::OPT_mcrc))
734 Features.push_back("+crc");
735 else
736 Features.push_back("-crc");
737 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000738}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000739
740void Clang::AddARMTargetArgs(const ArgList &Args,
741 ArgStringList &CmdArgs,
742 bool KernelOrKext) const {
743 const Driver &D = getToolChain().getDriver();
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000744 // Get the effective triple, which takes into account the deployment target.
745 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
746 llvm::Triple Triple(TripleStr);
Bernard Ogden31561762013-12-12 13:27:11 +0000747 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000748
749 // Select the ABI to use.
750 //
751 // FIXME: Support -meabi.
Craig Topper92fc2df2014-05-17 16:56:41 +0000752 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000753 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000754 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000755 } else if (Triple.isOSBinFormatMachO()) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000756 // The backend is hardwired to assume AAPCS for M-class processors, ensure
757 // the frontend matches that.
Tim Northovere66c9462013-10-03 14:23:28 +0000758 if (Triple.getEnvironment() == llvm::Triple::EABI ||
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +0000759 (Triple.getOS() == llvm::Triple::UnknownOS &&
760 Triple.getObjectFormat() == llvm::Triple::MachO) ||
Tim Northovere66c9462013-10-03 14:23:28 +0000761 StringRef(CPUName).startswith("cortex-m")) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000762 ABIName = "aapcs";
763 } else {
764 ABIName = "apcs-gnu";
765 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000766 } else if (Triple.isOSWindows()) {
767 // FIXME: this is invalid for WindowsCE
768 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000769 } else {
770 // Select the default based on the platform.
771 switch(Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000772 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000773 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000774 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000775 ABIName = "aapcs-linux";
776 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000777 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000778 case llvm::Triple::EABI:
779 ABIName = "aapcs";
780 break;
781 default:
782 ABIName = "apcs-gnu";
783 }
784 }
785 CmdArgs.push_back("-target-abi");
786 CmdArgs.push_back(ABIName);
787
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000788 // Determine floating point ABI from the options & target defaults.
Tim Northover9c7e0352013-12-12 11:55:52 +0000789 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
Daniel Dunbar78485922009-09-10 23:00:09 +0000790 if (FloatABI == "soft") {
791 // Floating point operations and argument passing are soft.
792 //
793 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000794 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000795 CmdArgs.push_back("-mfloat-abi");
796 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000797 } else if (FloatABI == "softfp") {
798 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000799 CmdArgs.push_back("-mfloat-abi");
800 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000801 } else {
802 // Floating point operations and argument passing are hard.
803 assert(FloatABI == "hard" && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000804 CmdArgs.push_back("-mfloat-abi");
805 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000806 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000807
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000808 // Kernel code has more strict alignment requirements.
809 if (KernelOrKext) {
Cameron Esfahani556d91e2013-09-14 01:09:11 +0000810 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
Daniel Dunbarbd847cc2012-10-15 22:23:53 +0000811 CmdArgs.push_back("-backend-option");
812 CmdArgs.push_back("-arm-long-calls");
813 }
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000814
Daniel Dunbar12100e22011-03-22 16:48:17 +0000815 CmdArgs.push_back("-backend-option");
Daniel Dunbarc9388c12011-03-17 17:10:06 +0000816 CmdArgs.push_back("-arm-strict-align");
Daniel Dunbared904c82011-04-18 21:26:42 +0000817
818 // The kext linker doesn't know how to deal with movw/movt.
Daniel Dunbared904c82011-04-18 21:26:42 +0000819 CmdArgs.push_back("-backend-option");
Renato Golin3d510b32013-08-15 20:54:45 +0000820 CmdArgs.push_back("-arm-use-movt=0");
Daniel Dunbarb1db4b62011-03-17 00:07:34 +0000821 }
Chad Rosierba3df1d2011-08-26 00:26:29 +0000822
823 // Setting -mno-global-merge disables the codegen global merge pass. Setting
824 // -mglobal-merge has no effect as the pass is enabled by default.
825 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
826 options::OPT_mno_global_merge)) {
827 if (A->getOption().matches(options::OPT_mno_global_merge))
828 CmdArgs.push_back("-mno-global-merge");
829 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000830
Bob Wilson9c8af452013-04-11 18:53:25 +0000831 if (!Args.hasFlag(options::OPT_mimplicit_float,
832 options::OPT_mno_implicit_float,
833 true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000834 CmdArgs.push_back("-no-implicit-float");
Renato Golindbb77e62013-08-24 14:44:35 +0000835
Logan Chien749763e2014-04-03 13:12:44 +0000836 // llvm does not support reserving registers in general. There is support
837 // for reserving r9 on ARM though (defined as a platform-specific register
838 // in ARM EABI).
839 if (Args.hasArg(options::OPT_ffixed_r9)) {
840 CmdArgs.push_back("-backend-option");
841 CmdArgs.push_back("-arm-reserve-r9");
842 }
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000843}
844
Tim Northover573cbee2014-05-24 12:52:07 +0000845/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
846/// targeting.
847static std::string getAArch64TargetCPU(const ArgList &Args) {
Tim Northovera2ee4332014-03-29 15:09:45 +0000848 // If we have -mcpu=, use that.
849 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
850 StringRef MCPU = A->getValue();
851 // Handle -mcpu=native.
852 if (MCPU == "native")
853 return llvm::sys::getHostCPUName();
854 else
855 return MCPU;
856 }
857
858 // At some point, we may need to check -march here, but for now we only
859 // one arm64 architecture.
860
James Molloy9b1586b2014-04-17 12:51:17 +0000861 // Make sure we pick "cyclone" if -arch is used.
862 // FIXME: Should this be picked by checking the target triple instead?
863 if (Args.getLastArg(options::OPT_arch))
864 return "cyclone";
865
866 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000867}
868
Tim Northover573cbee2014-05-24 12:52:07 +0000869void Clang::AddAArch64TargetArgs(const ArgList &Args,
870 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000871 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
872 llvm::Triple Triple(TripleStr);
873
874 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
875 Args.hasArg(options::OPT_mkernel) ||
876 Args.hasArg(options::OPT_fapple_kext))
877 CmdArgs.push_back("-disable-red-zone");
878
879 if (!Args.hasFlag(options::OPT_mimplicit_float,
880 options::OPT_mno_implicit_float, true))
881 CmdArgs.push_back("-no-implicit-float");
882
Craig Topper92fc2df2014-05-17 16:56:41 +0000883 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +0000884 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
885 ABIName = A->getValue();
886 else if (Triple.isOSDarwin())
887 ABIName = "darwinpcs";
888 else
889 ABIName = "aapcs";
890
891 CmdArgs.push_back("-target-abi");
892 CmdArgs.push_back(ABIName);
893
894 CmdArgs.push_back("-target-cpu");
Tim Northover573cbee2014-05-24 12:52:07 +0000895 CmdArgs.push_back(Args.MakeArgString(getAArch64TargetCPU(Args)));
Tim Northovera2ee4332014-03-29 15:09:45 +0000896
897 if (Args.hasArg(options::OPT_mstrict_align)) {
898 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +0000899 CmdArgs.push_back("-aarch64-strict-align");
Tim Northovera2ee4332014-03-29 15:09:45 +0000900 }
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +0000901
902 // Setting -mno-global-merge disables the codegen global merge pass. Setting
903 // -mglobal-merge has no effect as the pass is enabled by default.
904 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
905 options::OPT_mno_global_merge)) {
906 if (A->getOption().matches(options::OPT_mno_global_merge))
907 CmdArgs.push_back("-mno-global-merge");
908 }
Tim Northovera2ee4332014-03-29 15:09:45 +0000909}
910
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000911// Get CPU and ABI names. They are not independent
912// so we have to calculate them together.
913static void getMipsCPUAndABI(const ArgList &Args,
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000914 const llvm::Triple &Triple,
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000915 StringRef &CPUName,
916 StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +0000917 const char *DefMips32CPU = "mips32r2";
918 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +0000919
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000920 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
Simon Atanasyane0cc7c72013-10-09 12:12:24 +0000921 options::OPT_mcpu_EQ))
922 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000923
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000924 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000925 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +0000926 // Convert a GNU style Mips ABI name to the name
927 // accepted by LLVM Mips backend.
928 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
929 .Case("32", "o32")
930 .Case("64", "n64")
931 .Default(ABIName);
932 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000933
934 // Setup default CPU and ABI names.
935 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +0000936 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000937 default:
938 llvm_unreachable("Unexpected triple arch name");
939 case llvm::Triple::mips:
940 case llvm::Triple::mipsel:
941 CPUName = DefMips32CPU;
942 break;
943 case llvm::Triple::mips64:
944 case llvm::Triple::mips64el:
945 CPUName = DefMips64CPU;
946 break;
947 }
948 }
949
950 if (!ABIName.empty()) {
951 // Deduce CPU name from ABI name.
952 CPUName = llvm::StringSwitch<const char *>(ABIName)
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000953 .Cases("32", "o32", "eabi", DefMips32CPU)
954 .Cases("n32", "n64", "64", DefMips64CPU)
Simon Atanasyan464a7f72012-09-10 08:32:41 +0000955 .Default("");
956 }
957 else if (!CPUName.empty()) {
958 // Deduce ABI name from CPU name.
959 ABIName = llvm::StringSwitch<const char *>(CPUName)
960 .Cases("mips32", "mips32r2", "o32")
961 .Cases("mips64", "mips64r2", "n64")
962 .Default("");
963 }
964
965 // FIXME: Warn on inconsistent cpu and abi usage.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +0000966}
967
Simon Atanasyan0da400c2013-02-27 14:55:49 +0000968// Convert ABI name to the GNU tools acceptable variant.
969static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
970 return llvm::StringSwitch<llvm::StringRef>(ABI)
971 .Case("o32", "32")
972 .Case("n64", "64")
973 .Default(ABI);
974}
975
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000976// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
977// and -mfloat-abi=.
978static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000979 StringRef FloatABI;
Eric Christopher0b26a612010-03-02 02:41:08 +0000980 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000981 options::OPT_mhard_float,
982 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +0000983 if (A->getOption().matches(options::OPT_msoft_float))
984 FloatABI = "soft";
985 else if (A->getOption().matches(options::OPT_mhard_float))
986 FloatABI = "hard";
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000987 else {
Richard Smithbd55daf2012-11-01 04:30:05 +0000988 FloatABI = A->getValue();
Simon Atanasyan512dc382013-04-14 08:37:15 +0000989 if (FloatABI != "soft" && FloatABI != "hard") {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +0000990 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000991 FloatABI = "hard";
992 }
993 }
Eric Christopher0b26a612010-03-02 02:41:08 +0000994 }
995
996 // If unspecified, choose the default based on the platform.
997 if (FloatABI.empty()) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +0000998 // Assume "hard", because it's a default value used by gcc.
999 // When we start to recognize specific target MIPS processors,
1000 // we will be able to select the default more correctly.
1001 FloatABI = "hard";
Eric Christopher0b26a612010-03-02 02:41:08 +00001002 }
1003
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001004 return FloatABI;
1005}
1006
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001007static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001008 std::vector<const char *> &Features,
1009 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001010 StringRef FeatureName) {
1011 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001012 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001013 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001014 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001015 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001016 }
1017}
1018
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001019static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1020 std::vector<const char *> &Features) {
1021 StringRef FloatABI = getMipsFloatABI(D, Args);
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001022 if (FloatABI == "soft") {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001023 // FIXME: Note, this is a hack. We need to pass the selected float
1024 // mode to the MipsTargetInfoBase to define appropriate macros there.
1025 // Now it is the only method.
1026 Features.push_back("+soft-float");
1027 }
1028
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001029 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001030 StringRef Val = StringRef(A->getValue());
1031 if (Val == "2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001032 Features.push_back("+nan2008");
Matheus Almeida602bff32014-05-07 16:16:07 +00001033 else if (Val == "legacy")
1034 Features.push_back("-nan2008");
1035 else
1036 D.Diag(diag::err_drv_unsupported_option_argument)
1037 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001038 }
1039
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001040 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1041 options::OPT_mdouble_float, "single-float");
1042 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1043 "mips16");
1044 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1045 options::OPT_mno_micromips, "micromips");
1046 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1047 "dsp");
1048 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1049 "dspr2");
1050 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1051 "msa");
Daniel Sanders94694172013-10-17 14:55:58 +00001052 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1053 "fp64");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001054}
1055
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001056void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001057 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001058 const Driver &D = getToolChain().getDriver();
1059 StringRef CPUName;
1060 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001061 const llvm::Triple &Triple = getToolChain().getTriple();
1062 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001063
1064 CmdArgs.push_back("-target-abi");
1065 CmdArgs.push_back(ABIName.data());
1066
1067 StringRef FloatABI = getMipsFloatABI(D, Args);
1068
Simon Atanasyan22a6f4d2013-11-19 12:22:38 +00001069 if (FloatABI == "soft") {
Eric Christopher0b26a612010-03-02 02:41:08 +00001070 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001071 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001072 CmdArgs.push_back("-mfloat-abi");
1073 CmdArgs.push_back("soft");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001074 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001075 else {
1076 // Floating point operations and argument passing are hard.
Eric Christopher0b26a612010-03-02 02:41:08 +00001077 assert(FloatABI == "hard" && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001078 CmdArgs.push_back("-mfloat-abi");
1079 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001080 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001081
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001082 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1083 if (A->getOption().matches(options::OPT_mxgot)) {
1084 CmdArgs.push_back("-mllvm");
1085 CmdArgs.push_back("-mxgot");
1086 }
1087 }
1088
Simon Atanasyanc580b322013-05-11 06:33:44 +00001089 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1090 options::OPT_mno_ldc1_sdc1)) {
1091 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1092 CmdArgs.push_back("-mllvm");
1093 CmdArgs.push_back("-mno-ldc1-sdc1");
1094 }
1095 }
1096
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001097 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1098 options::OPT_mno_check_zero_division)) {
1099 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1100 CmdArgs.push_back("-mllvm");
1101 CmdArgs.push_back("-mno-check-zero-division");
1102 }
1103 }
1104
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001105 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001106 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001107 CmdArgs.push_back("-mllvm");
1108 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1109 A->claim();
1110 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001111}
1112
Hal Finkel8eb59282012-06-11 22:35:19 +00001113/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1114static std::string getPPCTargetCPU(const ArgList &Args) {
1115 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001116 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001117
1118 if (CPUName == "native") {
1119 std::string CPU = llvm::sys::getHostCPUName();
1120 if (!CPU.empty() && CPU != "generic")
1121 return CPU;
1122 else
1123 return "";
1124 }
1125
1126 return llvm::StringSwitch<const char *>(CPUName)
1127 .Case("common", "generic")
1128 .Case("440", "440")
1129 .Case("440fp", "440")
1130 .Case("450", "450")
1131 .Case("601", "601")
1132 .Case("602", "602")
1133 .Case("603", "603")
1134 .Case("603e", "603e")
1135 .Case("603ev", "603ev")
1136 .Case("604", "604")
1137 .Case("604e", "604e")
1138 .Case("620", "620")
Bill Schmidt38378a02013-02-01 20:23:10 +00001139 .Case("630", "pwr3")
Hal Finkel8eb59282012-06-11 22:35:19 +00001140 .Case("G3", "g3")
1141 .Case("7400", "7400")
1142 .Case("G4", "g4")
1143 .Case("7450", "7450")
1144 .Case("G4+", "g4+")
1145 .Case("750", "750")
1146 .Case("970", "970")
1147 .Case("G5", "g5")
1148 .Case("a2", "a2")
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001149 .Case("a2q", "a2q")
Hal Finkelf6d6cb02012-09-18 22:25:03 +00001150 .Case("e500mc", "e500mc")
1151 .Case("e5500", "e5500")
Bill Schmidt38378a02013-02-01 20:23:10 +00001152 .Case("power3", "pwr3")
1153 .Case("power4", "pwr4")
1154 .Case("power5", "pwr5")
1155 .Case("power5x", "pwr5x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001156 .Case("power6", "pwr6")
Bill Schmidt38378a02013-02-01 20:23:10 +00001157 .Case("power6x", "pwr6x")
Hal Finkel8eb59282012-06-11 22:35:19 +00001158 .Case("power7", "pwr7")
Bill Schmidt38378a02013-02-01 20:23:10 +00001159 .Case("pwr3", "pwr3")
1160 .Case("pwr4", "pwr4")
1161 .Case("pwr5", "pwr5")
1162 .Case("pwr5x", "pwr5x")
1163 .Case("pwr6", "pwr6")
1164 .Case("pwr6x", "pwr6x")
1165 .Case("pwr7", "pwr7")
Hal Finkel8eb59282012-06-11 22:35:19 +00001166 .Case("powerpc", "ppc")
1167 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001168 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001169 .Default("");
1170 }
1171
1172 return "";
1173}
1174
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001175static void getPPCTargetFeatures(const ArgList &Args,
1176 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001177 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1178 ie = Args.filtered_end();
1179 it != ie; ++it) {
1180 StringRef Name = (*it)->getOption().getName();
1181 (*it)->claim();
1182
1183 // Skip over "-m".
1184 assert(Name.startswith("m") && "Invalid feature name.");
1185 Name = Name.substr(1);
1186
1187 bool IsNegative = Name.startswith("no-");
1188 if (IsNegative)
1189 Name = Name.substr(3);
1190
1191 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1192 // pass the correct option to the backend while calling the frontend
1193 // option the same.
1194 // TODO: Change the LLVM backend option maybe?
1195 if (Name == "mfcrf")
1196 Name = "mfocrf";
1197
1198 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1199 }
1200
1201 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001202 AddTargetFeature(Args, Features, options::OPT_faltivec,
1203 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001204}
1205
Tom Stellard6674c702013-04-01 20:56:53 +00001206/// Get the (LLVM) name of the R600 gpu we are targeting.
1207static std::string getR600TargetGPU(const ArgList &Args) {
1208 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001209 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001210 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001211 .Cases("rv630", "rv635", "r600")
1212 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001213 .Case("rv740", "rv770")
1214 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001215 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001216 .Case("hemlock", "cypress")
1217 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001218 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001219 }
1220 return "";
1221}
1222
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001223static void getSparcTargetFeatures(const ArgList &Args,
1224 std::vector<const char *> Features) {
1225 bool SoftFloatABI = true;
1226 if (Arg *A =
1227 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1228 if (A->getOption().matches(options::OPT_mhard_float))
1229 SoftFloatABI = false;
1230 }
1231 if (SoftFloatABI)
1232 Features.push_back("+soft-float");
1233}
1234
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001235void Clang::AddSparcTargetArgs(const ArgList &Args,
1236 ArgStringList &CmdArgs) const {
1237 const Driver &D = getToolChain().getDriver();
1238
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001239 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001240 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001241 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1242 options::OPT_mhard_float)) {
1243 if (A->getOption().matches(options::OPT_msoft_float))
1244 FloatABI = "soft";
1245 else if (A->getOption().matches(options::OPT_mhard_float))
1246 FloatABI = "hard";
1247 }
1248
1249 // If unspecified, choose the default based on the platform.
1250 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001251 // Assume "soft", but warn the user we are guessing.
1252 FloatABI = "soft";
1253 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001254 }
1255
1256 if (FloatABI == "soft") {
1257 // Floating point operations and argument passing are soft.
1258 //
1259 // FIXME: This changes CPP defines, we need -target-soft-float.
1260 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001261 } else {
1262 assert(FloatABI == "hard" && "Invalid float abi!");
1263 CmdArgs.push_back("-mhard-float");
1264 }
1265}
1266
Richard Sandiford4652d892013-07-19 16:51:51 +00001267static const char *getSystemZTargetCPU(const ArgList &Args) {
1268 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1269 return A->getValue();
1270 return "z10";
1271}
1272
Chandler Carruth953fb082013-01-13 11:46:33 +00001273static const char *getX86TargetCPU(const ArgList &Args,
1274 const llvm::Triple &Triple) {
1275 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001276 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001277 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001278 return "core-avx2";
1279
Chandler Carruth953fb082013-01-13 11:46:33 +00001280 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001281 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001282
1283 // FIXME: Reject attempts to use -march=native unless the target matches
1284 // the host.
1285 //
1286 // FIXME: We should also incorporate the detected target features for use
1287 // with -native.
1288 std::string CPU = llvm::sys::getHostCPUName();
1289 if (!CPU.empty() && CPU != "generic")
1290 return Args.MakeArgString(CPU);
1291 }
1292
1293 // Select the default CPU if none was given (or detection failed).
1294
1295 if (Triple.getArch() != llvm::Triple::x86_64 &&
1296 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001297 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001298
1299 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1300
1301 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001302 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001303 if (Triple.getArchName() == "x86_64h")
1304 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001305 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001306 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001307
Alexey Bataev286d1b92014-01-31 04:07:13 +00001308 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001309 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001310 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001311
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001312 // Everything else goes to x86-64 in 64-bit mode.
1313 if (Is64Bit)
1314 return "x86-64";
1315
1316 switch (Triple.getOS()) {
1317 case llvm::Triple::FreeBSD:
1318 case llvm::Triple::NetBSD:
1319 case llvm::Triple::OpenBSD:
1320 return "i486";
1321 case llvm::Triple::Haiku:
1322 return "i586";
1323 case llvm::Triple::Bitrig:
1324 return "i686";
1325 default:
1326 // Fallback to p4.
1327 return "pentium4";
1328 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001329}
1330
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001331static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1332 switch(T.getArch()) {
1333 default:
1334 return "";
1335
Amara Emerson703da2e2013-10-31 09:32:33 +00001336 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001337 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001338 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001339 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001340 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001341
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001342 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001343 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001344 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001345 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001346 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001347
1348 case llvm::Triple::mips:
1349 case llvm::Triple::mipsel:
1350 case llvm::Triple::mips64:
1351 case llvm::Triple::mips64el: {
1352 StringRef CPUName;
1353 StringRef ABIName;
1354 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1355 return CPUName;
1356 }
1357
1358 case llvm::Triple::ppc:
1359 case llvm::Triple::ppc64:
1360 case llvm::Triple::ppc64le: {
1361 std::string TargetCPUName = getPPCTargetCPU(Args);
1362 // LLVM may default to generating code for the native CPU,
1363 // but, like gcc, we default to a more generic option for
1364 // each architecture. (except on Darwin)
1365 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1366 if (T.getArch() == llvm::Triple::ppc64)
1367 TargetCPUName = "ppc64";
1368 else if (T.getArch() == llvm::Triple::ppc64le)
1369 TargetCPUName = "ppc64le";
1370 else
1371 TargetCPUName = "ppc";
1372 }
1373 return TargetCPUName;
1374 }
1375
1376 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001377 case llvm::Triple::sparcv9:
1378 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001379 return A->getValue();
1380 return "";
1381
1382 case llvm::Triple::x86:
1383 case llvm::Triple::x86_64:
1384 return getX86TargetCPU(Args, T);
1385
1386 case llvm::Triple::hexagon:
1387 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1388
1389 case llvm::Triple::systemz:
1390 return getSystemZTargetCPU(Args);
1391
1392 case llvm::Triple::r600:
1393 return getR600TargetGPU(Args);
1394 }
1395}
1396
Alp Tokerce365ca2013-12-02 12:43:03 +00001397static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1398 ArgStringList &CmdArgs) {
1399 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1400 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1401 // forward.
1402 CmdArgs.push_back("-plugin");
1403 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1404 CmdArgs.push_back(Args.MakeArgString(Plugin));
1405
1406 // Try to pass driver level flags relevant to LTO code generation down to
1407 // the plugin.
1408
1409 // Handle flags for selecting CPU variants.
1410 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1411 if (!CPU.empty())
1412 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1413}
1414
Jim Grosbach82eee262013-11-16 00:53:35 +00001415static void getX86TargetFeatures(const llvm::Triple &Triple,
1416 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001417 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001418 if (Triple.getArchName() == "x86_64h") {
1419 // x86_64h implies quite a few of the more modern subtarget features
1420 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1421 Features.push_back("-rdrnd");
1422 Features.push_back("-aes");
1423 Features.push_back("-pclmul");
1424 Features.push_back("-rtm");
1425 Features.push_back("-hle");
1426 Features.push_back("-fsgsbase");
1427 }
1428
Alexey Bataev286d1b92014-01-31 04:07:13 +00001429 if (Triple.getEnvironment() == llvm::Triple::Android) {
1430 // Add sse3 feature to comply with gcc on Android
1431 Features.push_back("+sse3");
1432 }
1433
Jim Grosbach82eee262013-11-16 00:53:35 +00001434 // Now add any that the user explicitly requested on the command line,
1435 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001436 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1437 ie = Args.filtered_end();
1438 it != ie; ++it) {
1439 StringRef Name = (*it)->getOption().getName();
1440 (*it)->claim();
1441
1442 // Skip over "-m".
1443 assert(Name.startswith("m") && "Invalid feature name.");
1444 Name = Name.substr(1);
1445
1446 bool IsNegative = Name.startswith("no-");
1447 if (IsNegative)
1448 Name = Name.substr(3);
1449
1450 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1451 }
1452}
1453
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001454void Clang::AddX86TargetArgs(const ArgList &Args,
1455 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001456 if (!Args.hasFlag(options::OPT_mred_zone,
1457 options::OPT_mno_red_zone,
1458 true) ||
1459 Args.hasArg(options::OPT_mkernel) ||
1460 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001461 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001462
Bob Wilson2616e2e2013-02-10 16:01:41 +00001463 // Default to avoid implicit floating-point for kernel/kext code, but allow
1464 // that to be overridden with -mno-soft-float.
1465 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1466 Args.hasArg(options::OPT_fapple_kext));
1467 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1468 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001469 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001470 options::OPT_mno_implicit_float)) {
1471 const Option &O = A->getOption();
1472 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1473 O.matches(options::OPT_msoft_float));
1474 }
1475 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001476 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001477
1478 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1479 StringRef Value = A->getValue();
1480 if (Value == "intel" || Value == "att") {
1481 CmdArgs.push_back("-mllvm");
1482 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1483 } else {
1484 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1485 << A->getOption().getName() << Value;
1486 }
1487 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001488}
1489
Matthew Curtise8f80a12012-12-06 17:49:03 +00001490static inline bool HasPICArg(const ArgList &Args) {
1491 return Args.hasArg(options::OPT_fPIC)
1492 || Args.hasArg(options::OPT_fpic);
1493}
1494
1495static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1496 return Args.getLastArg(options::OPT_G,
1497 options::OPT_G_EQ,
1498 options::OPT_msmall_data_threshold_EQ);
1499}
1500
1501static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1502 std::string value;
1503 if (HasPICArg(Args))
1504 value = "0";
1505 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1506 value = A->getValue();
1507 A->claim();
1508 }
1509 return value;
1510}
1511
Tony Linthicum76329bf2011-12-12 21:14:55 +00001512void Clang::AddHexagonTargetArgs(const ArgList &Args,
1513 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001514 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001515 CmdArgs.push_back("-mqdsp6-compat");
1516 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001517
Matthew Curtise8f80a12012-12-06 17:49:03 +00001518 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1519 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001520 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001521 CmdArgs.push_back(Args.MakeArgString(
1522 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001523 }
1524
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001525 if (!Args.hasArg(options::OPT_fno_short_enums))
1526 CmdArgs.push_back("-fshort-enums");
1527 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1528 CmdArgs.push_back ("-mllvm");
1529 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1530 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001531 CmdArgs.push_back ("-mllvm");
1532 CmdArgs.push_back ("-machine-sink-split=0");
1533}
1534
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001535static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1536 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001537 // Honor -mfpu=.
1538 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001539 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001540 else
1541 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001542
1543 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1544 Features.push_back("-fp-armv8");
1545 Features.push_back("-crypto");
1546 Features.push_back("-neon");
1547 }
Bradley Smith418c5932014-05-02 15:17:51 +00001548
1549 // En/disable crc
1550 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1551 options::OPT_mnocrc)) {
1552 if (A->getOption().matches(options::OPT_mcrc))
1553 Features.push_back("+crc");
1554 else
1555 Features.push_back("-crc");
1556 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001557}
1558
1559static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001560 const ArgList &Args, ArgStringList &CmdArgs,
1561 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001562 std::vector<const char *> Features;
1563 switch (Triple.getArch()) {
1564 default:
1565 break;
1566 case llvm::Triple::mips:
1567 case llvm::Triple::mipsel:
1568 case llvm::Triple::mips64:
1569 case llvm::Triple::mips64el:
1570 getMIPSTargetFeatures(D, Args, Features);
1571 break;
1572
1573 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001574 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001575 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001576 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001577 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001578 break;
1579
1580 case llvm::Triple::ppc:
1581 case llvm::Triple::ppc64:
1582 case llvm::Triple::ppc64le:
1583 getPPCTargetFeatures(Args, Features);
1584 break;
1585 case llvm::Triple::sparc:
1586 getSparcTargetFeatures(Args, Features);
1587 break;
1588 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001589 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001590 case llvm::Triple::arm64:
1591 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001592 getAArch64TargetFeatures(D, Args, Features);
1593 break;
1594 case llvm::Triple::x86:
1595 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001596 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001597 break;
1598 }
Rafael Espindola43964802013-08-21 17:34:32 +00001599
1600 // Find the last of each feature.
1601 llvm::StringMap<unsigned> LastOpt;
1602 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1603 const char *Name = Features[I];
1604 assert(Name[0] == '-' || Name[0] == '+');
1605 LastOpt[Name + 1] = I;
1606 }
1607
1608 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1609 // If this feature was overridden, ignore it.
1610 const char *Name = Features[I];
1611 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1612 assert(LastI != LastOpt.end());
1613 unsigned Last = LastI->second;
1614 if (Last != I)
1615 continue;
1616
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001617 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001618 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001619 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001620}
1621
Eric Christopher84fbdb42011-08-19 00:30:14 +00001622static bool
John McCall5fb5df92012-06-20 06:18:46 +00001623shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001624 const llvm::Triple &Triple) {
1625 // We use the zero-cost exception tables for Objective-C if the non-fragile
1626 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1627 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001628 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001629 return true;
1630
Bob Wilson83e723a2013-12-05 19:38:42 +00001631 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001632 return false;
1633
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001634 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001635 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001636 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001637}
1638
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001639namespace {
1640 struct ExceptionSettings {
1641 bool ExceptionsEnabled;
1642 bool ShouldUseExceptionTables;
1643 ExceptionSettings() : ExceptionsEnabled(false),
1644 ShouldUseExceptionTables(false) {}
1645 };
1646} // end anonymous namespace.
1647
Nico Webere8e53112014-05-11 01:04:02 +00001648// exceptionSettings() exists to share the logic between -cc1 and linker
1649// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001650static ExceptionSettings exceptionSettings(const ArgList &Args,
1651 const llvm::Triple &Triple) {
1652 ExceptionSettings ES;
1653
1654 // Are exceptions enabled by default?
1655 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1656
1657 // This keeps track of whether exceptions were explicitly turned on or off.
1658 bool DidHaveExplicitExceptionFlag = false;
1659
1660 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1661 options::OPT_fno_exceptions)) {
1662 if (A->getOption().matches(options::OPT_fexceptions))
1663 ES.ExceptionsEnabled = true;
1664 else
1665 ES.ExceptionsEnabled = false;
1666
1667 DidHaveExplicitExceptionFlag = true;
1668 }
1669
1670 // Exception tables and cleanups can be enabled with -fexceptions even if the
1671 // language itself doesn't support exceptions.
1672 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1673 ES.ShouldUseExceptionTables = true;
1674
1675 return ES;
1676}
1677
Anders Carlssone96ab552011-02-28 02:27:16 +00001678/// addExceptionArgs - Adds exception related arguments to the driver command
1679/// arguments. There's a master flag, -fexceptions and also language specific
1680/// flags to enable/disable C++ and Objective-C exceptions.
1681/// This makes it possible to for example disable C++ exceptions but enable
1682/// Objective-C exceptions.
1683static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1684 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001685 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001686 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001687 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001688 if (KernelOrKext) {
1689 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1690 // arguments now to avoid warnings about unused arguments.
1691 Args.ClaimAllArgs(options::OPT_fexceptions);
1692 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1693 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1694 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1695 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1696 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001697 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001698 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001699
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001700 // Gather the exception settings from the command line arguments.
1701 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001702
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001703 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1704 // is not necessarily sensible, but follows GCC.
1705 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001706 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001707 options::OPT_fno_objc_exceptions,
1708 true)) {
1709 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001710
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001711 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001712 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001713 }
1714
1715 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001716 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001717
Eric Christopher84fbdb42011-08-19 00:30:14 +00001718 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1719 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001720 options::OPT_fexceptions,
1721 options::OPT_fno_exceptions)) {
1722 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1723 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001724 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001725 CXXExceptionsEnabled = false;
1726 }
1727
1728 if (CXXExceptionsEnabled) {
1729 CmdArgs.push_back("-fcxx-exceptions");
1730
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001731 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001732 }
1733 }
1734
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001735 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001736 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001737}
1738
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001739static bool ShouldDisableAutolink(const ArgList &Args,
1740 const ToolChain &TC) {
1741 bool Default = true;
1742 if (TC.getTriple().isOSDarwin()) {
1743 // The native darwin assembler doesn't support the linker_option directives,
1744 // so we disable them if we think the .s file will be passed to it.
1745 Default = TC.useIntegratedAs();
1746 }
1747 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1748 Default);
1749}
1750
Ted Kremenek62093662013-03-12 17:02:12 +00001751static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1752 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001753 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1754 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001755 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001756 return !UseDwarfDirectory;
1757}
1758
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001759/// \brief Check whether the given input tree contains any compilation actions.
1760static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001761 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001762 return true;
1763
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001764 for (const auto &Act : *A)
1765 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001766 return true;
1767
1768 return false;
1769}
1770
1771/// \brief Check if -relax-all should be passed to the internal assembler.
1772/// This is done by default when compiling non-assembler source with -O0.
1773static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1774 bool RelaxDefault = true;
1775
1776 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1777 RelaxDefault = A->getOption().matches(options::OPT_O0);
1778
1779 if (RelaxDefault) {
1780 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001781 for (const auto &Act : C.getActions()) {
1782 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001783 RelaxDefault = true;
1784 break;
1785 }
1786 }
1787 }
1788
1789 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1790 RelaxDefault);
1791}
1792
David Blaikie9260ed62013-07-25 21:19:01 +00001793static void CollectArgsForIntegratedAssembler(Compilation &C,
1794 const ArgList &Args,
1795 ArgStringList &CmdArgs,
1796 const Driver &D) {
1797 if (UseRelaxAll(C, Args))
1798 CmdArgs.push_back("-mrelax-all");
1799
David Peixottodfb66142013-11-14 22:52:58 +00001800 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001801 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001802 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1803 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1804 // arg after parsing the '-I' arg.
1805 bool TakeNextArg = false;
1806
David Blaikie9260ed62013-07-25 21:19:01 +00001807 // When using an integrated assembler, translate -Wa, and -Xassembler
1808 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001809 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001810 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1811 options::OPT_Xassembler),
1812 ie = Args.filtered_end(); it != ie; ++it) {
1813 const Arg *A = *it;
1814 A->claim();
1815
1816 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1817 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001818 if (TakeNextArg) {
1819 CmdArgs.push_back(Value.data());
1820 TakeNextArg = false;
1821 continue;
1822 }
David Blaikie9260ed62013-07-25 21:19:01 +00001823
1824 if (Value == "-force_cpusubtype_ALL") {
1825 // Do nothing, this is the default and we don't support anything else.
1826 } else if (Value == "-L") {
1827 CmdArgs.push_back("-msave-temp-labels");
1828 } else if (Value == "--fatal-warnings") {
1829 CmdArgs.push_back("-mllvm");
1830 CmdArgs.push_back("-fatal-assembler-warnings");
1831 } else if (Value == "--noexecstack") {
1832 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001833 } else if (Value == "-compress-debug-sections" ||
1834 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001835 CompressDebugSections = true;
1836 } else if (Value == "-nocompress-debug-sections" ||
1837 Value == "--nocompress-debug-sections") {
1838 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001839 } else if (Value.startswith("-I")) {
1840 CmdArgs.push_back(Value.data());
1841 // We need to consume the next argument if the current arg is a plain
1842 // -I. The next arg will be the include directory.
1843 if (Value == "-I")
1844 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00001845 } else if (Value.startswith("-gdwarf-")) {
1846 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00001847 } else {
1848 D.Diag(diag::err_drv_unsupported_option_argument)
1849 << A->getOption().getName() << Value;
1850 }
1851 }
1852 }
David Blaikie24bbfed22014-03-31 23:29:38 +00001853 if (CompressDebugSections) {
1854 if (llvm::zlib::isAvailable())
1855 CmdArgs.push_back("-compress-debug-sections");
1856 else
1857 D.Diag(diag::warn_debug_compression_unavailable);
1858 }
David Blaikie9260ed62013-07-25 21:19:01 +00001859}
1860
Renato Goline807c122014-01-31 11:47:28 +00001861// Until ARM libraries are build separately, we have them all in one library
1862static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001863 if (TC.getArch() == llvm::Triple::arm ||
1864 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00001865 return "arm";
1866 else
1867 return TC.getArchName();
1868}
1869
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001870static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1871 // The runtimes are located in the OS-specific resource directory.
1872 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001873 const llvm::Triple &Triple = TC.getTriple();
1874 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1875 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1876 "freebsd" : TC.getOS();
1877 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001878 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001879}
1880
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001881// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00001882// FIXME: Make sure we can also emit shared objects if they're requested
1883// and available, check for possible errors, etc.
1884static void addClangRTLinux(
1885 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001886 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001887 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
1888 getArchNameForCompilerRTLib(TC) +
1889 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00001890
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001891 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001892 CmdArgs.push_back("-lgcc_s");
1893 if (TC.getDriver().CCCIsCXX())
1894 CmdArgs.push_back("-lgcc_eh");
1895}
1896
Alexey Samsonov7811d192014-02-20 13:57:37 +00001897static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001898 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1899 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1900 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001901 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001902 Args.hasArg(options::OPT_fcreate_profile) ||
1903 Args.hasArg(options::OPT_coverage)))
1904 return;
1905
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001906 // -fprofile-instr-generate requires position-independent code to build with
1907 // shared objects. Link against the right archive.
1908 const char *Lib = "libclang_rt.profile-";
1909 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1910 Args.hasArg(options::OPT_shared))
1911 Lib = "libclang_rt.profile-pic-";
1912
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001913 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1914 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001915 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001916
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00001917 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00001918}
1919
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001920static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
1921 const StringRef Sanitizer,
1922 bool Shared) {
1923 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
1924 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
1925 const char *EnvSuffix =
1926 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001927 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1928 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001929 Twine("libclang_rt.") + Sanitizer + "-" +
1930 getArchNameForCompilerRTLib(TC) + EnvSuffix +
1931 (Shared ? ".so" : ".a"));
1932 return LibSanitizer;
1933}
1934
1935static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
1936 ArgStringList &CmdArgs,
1937 const StringRef Sanitizer,
1938 bool BeforeLibStdCXX,
1939 bool ExportSymbols = true,
1940 bool LinkDeps = true) {
1941 SmallString<128> LibSanitizer =
1942 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00001943
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001944 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1945 // etc.) so that the linker picks custom versions of the global 'operator
1946 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001947 // strategy of inserting it at the front of the link command. It also
1948 // needs to be forced to end up in the executable, so wrap it in
1949 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001950 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001951 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001952 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001953 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001954
1955 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1956 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1957
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001958 if (LinkDeps) {
1959 // Link sanitizer dependencies explicitly
1960 CmdArgs.push_back("-lpthread");
1961 CmdArgs.push_back("-lrt");
1962 CmdArgs.push_back("-lm");
1963 // There's no libdl on FreeBSD.
1964 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1965 CmdArgs.push_back("-ldl");
1966 }
Richard Smithf3e624c2013-03-23 00:30:08 +00001967
1968 // If possible, use a dynamic symbols file to export the symbols from the
1969 // runtime library. If we can't do so, use -export-dynamic instead to export
1970 // all symbols from the binary.
1971 if (ExportSymbols) {
1972 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1973 CmdArgs.push_back(
1974 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1975 else
1976 CmdArgs.push_back("-export-dynamic");
1977 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001978}
1979
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001980/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1981/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001982static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001983 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001984 if (Shared) {
1985 // Link dynamic runtime if necessary.
1986 SmallString<128> LibSanitizer =
1987 getSanitizerRTLibName(TC, "asan", Shared);
1988 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001989 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001990
1991 // Do not link static runtime to DSOs or if compiling for Android.
1992 if (Args.hasArg(options::OPT_shared) ||
1993 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
1994 return;
1995
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001996 if (Shared) {
1997 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
1998 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
1999 /*LinkDeps*/ false);
2000 } else {
2001 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2002 if (IsCXX)
2003 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2004 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002005}
2006
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002007/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2008/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002009static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2010 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002011 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002012 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002013}
2014
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002015/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2016/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002017static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2018 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002019 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002020 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002021}
2022
2023/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2024/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002025static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2026 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002027 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002028 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002029}
2030
Richard Smithe30752c2012-10-09 19:52:38 +00002031/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2032/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002033static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2034 ArgStringList &CmdArgs, bool IsCXX,
2035 bool HasOtherSanitizerRt) {
Richard Smith4244ea92014-06-04 23:28:46 +00002036 // Export symbols if we're not building a shared library. This allows two
2037 // models: either every DSO containing ubsan-sanitized code contains the
2038 // ubsan runtime, or the main executable does (or both).
2039 const bool ExportSymbols = !Args.hasArg(options::OPT_shared);
2040
Nick Lewycky24921692013-10-19 00:27:23 +00002041 // Need a copy of sanitizer_common. This could come from another sanitizer
2042 // runtime; if we're not including one, include our own copy.
2043 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002044 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002045
Richard Smith4244ea92014-06-04 23:28:46 +00002046 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, ExportSymbols);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002047
2048 // Only include the bits of the runtime which need a C++ ABI library if
2049 // we're linking in C++ mode.
2050 if (IsCXX)
Richard Smith4244ea92014-06-04 23:28:46 +00002051 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false,
2052 ExportSymbols);
Richard Smithe30752c2012-10-09 19:52:38 +00002053}
2054
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002055static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2056 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002057 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002058 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2059}
2060
2061// Should be called before we add C++ ABI library.
2062static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2063 ArgStringList &CmdArgs) {
2064 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2065 const Driver &D = TC.getDriver();
2066 if (Sanitize.needsUbsanRt())
2067 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2068 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2069 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2070 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002071 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002072 if (Sanitize.needsTsanRt())
2073 addTsanRT(TC, Args, CmdArgs);
2074 if (Sanitize.needsMsanRt())
2075 addMsanRT(TC, Args, CmdArgs);
2076 if (Sanitize.needsLsanRt())
2077 addLsanRT(TC, Args, CmdArgs);
2078 if (Sanitize.needsDfsanRt())
2079 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002080}
2081
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002082static bool shouldUseFramePointerForTarget(const ArgList &Args,
2083 const llvm::Triple &Triple) {
2084 switch (Triple.getArch()) {
2085 // Don't use a frame pointer on linux if optimizing for certain targets.
2086 case llvm::Triple::mips64:
2087 case llvm::Triple::mips64el:
2088 case llvm::Triple::mips:
2089 case llvm::Triple::mipsel:
2090 case llvm::Triple::systemz:
2091 case llvm::Triple::x86:
2092 case llvm::Triple::x86_64:
2093 if (Triple.isOSLinux())
2094 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2095 if (!A->getOption().matches(options::OPT_O0))
2096 return false;
2097 return true;
2098 case llvm::Triple::xcore:
2099 return false;
2100 default:
2101 return true;
2102 }
2103}
2104
Rafael Espindola224dd632011-12-14 21:02:23 +00002105static bool shouldUseFramePointer(const ArgList &Args,
2106 const llvm::Triple &Triple) {
2107 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2108 options::OPT_fomit_frame_pointer))
2109 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2110
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002111 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002112}
2113
Eric Christopherb7d97e92013-04-03 01:58:53 +00002114static bool shouldUseLeafFramePointer(const ArgList &Args,
2115 const llvm::Triple &Triple) {
2116 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2117 options::OPT_momit_leaf_frame_pointer))
2118 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2119
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002120 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002121}
2122
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002123/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002124static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002125 SmallString<128> cwd;
2126 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002127 CmdArgs.push_back("-fdebug-compilation-dir");
2128 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002129 }
2130}
2131
Eric Christopherd3804002013-02-22 20:12:52 +00002132static const char *SplitDebugName(const ArgList &Args,
2133 const InputInfoList &Inputs) {
2134 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2135 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2136 SmallString<128> T(FinalOutput->getValue());
2137 llvm::sys::path::replace_extension(T, "dwo");
2138 return Args.MakeArgString(T);
2139 } else {
2140 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002141 SmallString<128> T(
2142 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002143 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2144 llvm::sys::path::replace_extension(F, "dwo");
2145 T += F;
2146 return Args.MakeArgString(F);
2147 }
2148}
2149
2150static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2151 const Tool &T, const JobAction &JA,
2152 const ArgList &Args, const InputInfo &Output,
2153 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002154 ArgStringList ExtractArgs;
2155 ExtractArgs.push_back("--extract-dwo");
2156
2157 ArgStringList StripArgs;
2158 StripArgs.push_back("--strip-dwo");
2159
2160 // Grabbing the output of the earlier compile step.
2161 StripArgs.push_back(Output.getFilename());
2162 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002163 ExtractArgs.push_back(OutFile);
2164
2165 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002166 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002167
2168 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002169 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002170
2171 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002172 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002173}
2174
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002175/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002176/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2177static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002178 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002179 if (A->getOption().matches(options::OPT_O4) ||
2180 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002181 return true;
2182
2183 if (A->getOption().matches(options::OPT_O0))
2184 return false;
2185
2186 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2187
Rafael Espindola91780de2013-08-26 14:05:41 +00002188 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002189 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002190 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002191 return true;
2192
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002193 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002194 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002195 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002196
2197 unsigned OptLevel = 0;
2198 if (S.getAsInteger(10, OptLevel))
2199 return false;
2200
2201 return OptLevel > 1;
2202 }
2203
2204 return false;
2205}
2206
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002207/// Add -x lang to \p CmdArgs for \p Input.
2208static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2209 ArgStringList &CmdArgs) {
2210 // When using -verify-pch, we don't want to provide the type
2211 // 'precompiled-header' if it was inferred from the file extension
2212 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2213 return;
2214
2215 CmdArgs.push_back("-x");
2216 if (Args.hasArg(options::OPT_rewrite_objc))
2217 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2218 else
2219 CmdArgs.push_back(types::getTypeName(Input.getType()));
2220}
2221
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002222void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002223 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002224 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002225 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002226 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002227 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2228 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002229 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002230 ArgStringList CmdArgs;
2231
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002232 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002233 bool IsWindowsCygnus =
2234 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002235 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2236
Daniel Dunbare521a892009-03-31 20:53:55 +00002237 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2238
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002239 // Invoke ourselves in -cc1 mode.
2240 //
2241 // FIXME: Implement custom jobs for internal actions.
2242 CmdArgs.push_back("-cc1");
2243
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002244 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002245 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002246 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002247 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002248
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002249 const llvm::Triple TT(TripleStr);
2250 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2251 TT.getArch() == llvm::Triple::thumb)) {
2252 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2253 unsigned Version;
2254 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2255 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002256 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2257 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002258 }
2259
Tim Northover336f1892014-03-29 13:16:12 +00002260 // Push all default warning arguments that are specific to
2261 // the given target. These come before user provided warning options
2262 // are provided.
2263 getToolChain().addClangWarningOptions(CmdArgs);
2264
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002265 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002266 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002267
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002268 if (isa<AnalyzeJobAction>(JA)) {
2269 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2270 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002271 } else if (isa<MigrateJobAction>(JA)) {
2272 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002273 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002274 if (Output.getType() == types::TY_Dependencies)
2275 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002276 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002277 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002278 if (Args.hasArg(options::OPT_rewrite_objc) &&
2279 !Args.hasArg(options::OPT_g_Group))
2280 CmdArgs.push_back("-P");
2281 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002282 } else if (isa<AssembleJobAction>(JA)) {
2283 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002284
David Blaikie9260ed62013-07-25 21:19:01 +00002285 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002286
2287 // Also ignore explicit -force_cpusubtype_ALL option.
2288 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002289 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002290 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002291 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002292
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002293 if (JA.getType() == types::TY_Nothing)
2294 CmdArgs.push_back("-fsyntax-only");
2295 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002296 CmdArgs.push_back("-emit-pch");
2297 else
2298 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002299 } else if (isa<VerifyPCHJobAction>(JA)) {
2300 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002301 } else {
2302 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002303
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002304 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002305 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002306 } else if (JA.getType() == types::TY_LLVM_IR ||
2307 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002308 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002309 } else if (JA.getType() == types::TY_LLVM_BC ||
2310 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002311 CmdArgs.push_back("-emit-llvm-bc");
2312 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002313 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002314 } else if (JA.getType() == types::TY_AST) {
2315 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002316 } else if (JA.getType() == types::TY_ModuleFile) {
2317 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002318 } else if (JA.getType() == types::TY_RewrittenObjC) {
2319 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002320 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002321 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2322 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002323 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002324 } else {
2325 assert(JA.getType() == types::TY_PP_Asm &&
2326 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002327 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002328 }
2329
Justin Bognera88f0122014-06-20 22:59:50 +00002330 // We normally speed up the clang process a bit by skipping destructors at
2331 // exit, but when we're generating diagnostics we can rely on some of the
2332 // cleanup.
2333 if (!C.isForDiagnostics())
2334 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002335
John McCallbb79b5f2010-02-13 03:50:24 +00002336 // Disable the verification pass in -asserts builds.
2337#ifdef NDEBUG
2338 CmdArgs.push_back("-disable-llvm-verifier");
2339#endif
2340
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002341 // Set the main file name, so that debug info works even with
2342 // -save-temps.
2343 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002344 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002345
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002346 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002347 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002348 if (Args.hasArg(options::OPT_static))
2349 CmdArgs.push_back("-static-define");
2350
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002351 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002352 // Enable region store model by default.
2353 CmdArgs.push_back("-analyzer-store=region");
2354
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002355 // Treat blocks as analysis entry points.
2356 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2357
Ted Kremenek49c79792011-03-24 00:28:47 +00002358 CmdArgs.push_back("-analyzer-eagerly-assume");
2359
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002360 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002361 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002362 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002363
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002364 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002365 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002366
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002367 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002368 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002369
2370 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002371
Jordan Rose10ad0812013-04-05 17:55:07 +00002372 if (types::isCXX(Inputs[0].getType()))
2373 CmdArgs.push_back("-analyzer-checker=cplusplus");
2374
Nico Webere8e53112014-05-11 01:04:02 +00002375 // Enable the following experimental checkers for testing.
2376 CmdArgs.push_back(
2377 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002378 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2379 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2380 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2381 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2382 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002383 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002384
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002385 // Set the output format. The default is plist, for (lame) historical
2386 // reasons.
2387 CmdArgs.push_back("-analyzer-output");
2388 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002389 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002390 else
2391 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002392
Ted Kremenekfe449a22010-03-22 22:32:05 +00002393 // Disable the presentation of standard compiler warnings when
2394 // using --analyze. We only want to show static analyzer diagnostics
2395 // or frontend errors.
2396 CmdArgs.push_back("-w");
2397
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002398 // Add -Xanalyzer arguments when running as analyzer.
2399 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002400 }
2401
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002402 CheckCodeGenerationOptions(D, Args);
2403
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002404 bool PIE = getToolChain().isPIEDefault();
2405 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002406 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002407
Alexey Bataev40e75222014-01-28 06:30:35 +00002408 // Android-specific defaults for PIC/PIE
2409 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2410 switch (getToolChain().getTriple().getArch()) {
2411 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002412 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002413 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002414 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002415 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002416 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002417 case llvm::Triple::mips:
2418 case llvm::Triple::mipsel:
2419 case llvm::Triple::mips64:
2420 case llvm::Triple::mips64el:
2421 PIC = true; // "-fpic"
2422 break;
2423
2424 case llvm::Triple::x86:
2425 case llvm::Triple::x86_64:
2426 PIC = true; // "-fPIC"
2427 IsPICLevelTwo = true;
2428 break;
2429
2430 default:
2431 break;
2432 }
2433 }
2434
Alexey Samsonov090301e2013-04-09 12:28:19 +00002435 // For the PIC and PIE flag options, this logic is different from the
2436 // legacy logic in very old versions of GCC, as that logic was just
2437 // a bug no one had ever fixed. This logic is both more rational and
2438 // consistent with GCC's new logic now that the bugs are fixed. The last
2439 // argument relating to either PIC or PIE wins, and no other argument is
2440 // used. If the last argument is any flavor of the '-fno-...' arguments,
2441 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2442 // at the same level.
2443 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2444 options::OPT_fpic, options::OPT_fno_pic,
2445 options::OPT_fPIE, options::OPT_fno_PIE,
2446 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002447 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2448 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002449 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002450 if (LastPICArg) {
2451 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002452 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2453 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2454 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2455 PIC = PIE || O.matches(options::OPT_fPIC) ||
2456 O.matches(options::OPT_fpic);
2457 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2458 O.matches(options::OPT_fPIC);
2459 } else {
2460 PIE = PIC = false;
2461 }
2462 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002463 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002464
Nick Lewycky609dd662013-10-11 03:33:53 +00002465 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002466 // specified while enabling PIC enabled level 1 PIC, just force it back to
2467 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2468 // informal testing).
2469 if (PIC && getToolChain().getTriple().isOSDarwin())
2470 IsPICLevelTwo |= getToolChain().isPICDefault();
2471
Chandler Carruthc0c04552012-04-08 16:40:35 +00002472 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2473 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002474 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002475 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002476 Triple.getArch() == llvm::Triple::arm64 ||
2477 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002478 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002479 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002480 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002481
Chandler Carruth76a943b2012-11-19 03:52:03 +00002482 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2483 // This is a very special mode. It trumps the other modes, almost no one
2484 // uses it, and it isn't even valid on any OS but Darwin.
2485 if (!getToolChain().getTriple().isOSDarwin())
2486 D.Diag(diag::err_drv_unsupported_opt_for_target)
2487 << A->getSpelling() << getToolChain().getTriple().str();
2488
2489 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2490
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002491 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002492 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002493
Chandler Carruth76a943b2012-11-19 03:52:03 +00002494 // Only a forced PIC mode can cause the actual compile to have PIC defines
2495 // etc., no flags are sufficient. This behavior was selected to closely
2496 // match that of llvm-gcc and Apple GCC before that.
2497 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2498 CmdArgs.push_back("-pic-level");
2499 CmdArgs.push_back("2");
2500 }
2501 } else {
2502 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2503 // handled in Clang's IRGen by the -pie-level flag.
2504 CmdArgs.push_back("-mrelocation-model");
2505 CmdArgs.push_back(PIC ? "pic" : "static");
2506
2507 if (PIC) {
2508 CmdArgs.push_back("-pic-level");
2509 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2510 if (PIE) {
2511 CmdArgs.push_back("-pie-level");
2512 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2513 }
2514 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002515 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002516
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002517 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2518 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002519 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002520
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002521 // LLVM Code Generator Options.
2522
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002523 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2524 StringRef v = A->getValue();
2525 CmdArgs.push_back("-mllvm");
2526 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2527 A->claim();
2528 }
2529
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002530 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2531 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002532 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002533 }
2534
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002535 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2536 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002537 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002538 D.Diag(diag::err_drv_unsupported_opt_for_target)
2539 << A->getSpelling() << getToolChain().getTriple().str();
2540 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2541 CmdArgs.push_back("-fpcc-struct-return");
2542 } else {
2543 assert(A->getOption().matches(options::OPT_freg_struct_return));
2544 CmdArgs.push_back("-freg-struct-return");
2545 }
2546 }
2547
Roman Divacky65b88cd2011-03-01 17:40:53 +00002548 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2549 CmdArgs.push_back("-mrtd");
2550
Rafael Espindola224dd632011-12-14 21:02:23 +00002551 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002552 CmdArgs.push_back("-mdisable-fp-elim");
2553 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2554 options::OPT_fno_zero_initialized_in_bss))
2555 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002556
2557 bool OFastEnabled = isOptimizationLevelFast(Args);
2558 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2559 // enabled. This alias option is being used to simplify the hasFlag logic.
2560 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2561 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002562 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2563 // doesn't do any TBAA.
2564 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002565 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002566 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002567 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002568 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2569 options::OPT_fno_struct_path_tbaa))
2570 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002571 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2572 false))
2573 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002574 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2575 options::OPT_fno_optimize_sibling_calls))
2576 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002577
Eric Christopher006208c2013-04-04 06:29:47 +00002578 // Handle segmented stacks.
2579 if (Args.hasArg(options::OPT_fsplit_stack))
2580 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002581
2582 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2583 // This alias option is being used to simplify the getLastArg logic.
2584 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2585 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002586
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002587 // Handle various floating point optimization flags, mapping them to the
2588 // appropriate LLVM code generation flags. The pattern for all of these is to
2589 // default off the codegen optimizations, and if any flag enables them and no
2590 // flag disables them after the flag enabling them, enable the codegen
2591 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002592 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002593 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002594 options::OPT_ffinite_math_only,
2595 options::OPT_fno_finite_math_only,
2596 options::OPT_fhonor_infinities,
2597 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002598 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2599 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002600 A->getOption().getID() != options::OPT_fhonor_infinities)
2601 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002602 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002603 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002604 options::OPT_ffinite_math_only,
2605 options::OPT_fno_finite_math_only,
2606 options::OPT_fhonor_nans,
2607 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002608 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2609 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002610 A->getOption().getID() != options::OPT_fhonor_nans)
2611 CmdArgs.push_back("-menable-no-nans");
2612
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002613 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2614 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002615 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002616 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002617 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002618 options::OPT_fno_math_errno)) {
2619 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2620 // However, turning *off* -ffast_math merely restores the toolchain default
2621 // (which may be false).
2622 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2623 A->getOption().getID() == options::OPT_ffast_math ||
2624 A->getOption().getID() == options::OPT_Ofast)
2625 MathErrno = false;
2626 else if (A->getOption().getID() == options::OPT_fmath_errno)
2627 MathErrno = true;
2628 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002629 if (MathErrno)
2630 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002631
2632 // There are several flags which require disabling very specific
2633 // optimizations. Any of these being disabled forces us to turn off the
2634 // entire set of LLVM optimizations, so collect them through all the flag
2635 // madness.
2636 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002637 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002638 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002639 options::OPT_funsafe_math_optimizations,
2640 options::OPT_fno_unsafe_math_optimizations,
2641 options::OPT_fassociative_math,
2642 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002643 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2644 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002645 A->getOption().getID() != options::OPT_fno_associative_math)
2646 AssociativeMath = true;
2647 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002648 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002649 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002650 options::OPT_funsafe_math_optimizations,
2651 options::OPT_fno_unsafe_math_optimizations,
2652 options::OPT_freciprocal_math,
2653 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002654 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2655 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002656 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2657 ReciprocalMath = true;
2658 bool SignedZeros = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002659 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002660 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002661 options::OPT_funsafe_math_optimizations,
2662 options::OPT_fno_unsafe_math_optimizations,
2663 options::OPT_fsigned_zeros,
2664 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002665 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2666 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002667 A->getOption().getID() != options::OPT_fsigned_zeros)
2668 SignedZeros = false;
2669 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002670 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002671 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002672 options::OPT_funsafe_math_optimizations,
2673 options::OPT_fno_unsafe_math_optimizations,
2674 options::OPT_ftrapping_math,
2675 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002676 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2677 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002678 A->getOption().getID() != options::OPT_ftrapping_math)
2679 TrappingMath = false;
2680 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2681 !TrappingMath)
2682 CmdArgs.push_back("-menable-unsafe-fp-math");
2683
Lang Hamesaa53b932012-07-06 00:59:19 +00002684
2685 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002686 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002687 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002688 options::OPT_ffp_contract)) {
2689 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002690 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002691 if (Val == "fast" || Val == "on" || Val == "off") {
2692 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2693 } else {
2694 D.Diag(diag::err_drv_unsupported_option_argument)
2695 << A->getOption().getName() << Val;
2696 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002697 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2698 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002699 // If fast-math is set then set the fp-contract mode to fast.
2700 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2701 }
2702 }
2703
Bob Wilson6a039162012-07-19 03:52:53 +00002704 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2705 // and if we find them, tell the frontend to provide the appropriate
2706 // preprocessor macros. This is distinct from enabling any optimizations as
2707 // these options induce language changes which must survive serialization
2708 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002709 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2710 options::OPT_fno_fast_math))
2711 if (!A->getOption().matches(options::OPT_fno_fast_math))
2712 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002713 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2714 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002715 if (A->getOption().matches(options::OPT_ffinite_math_only))
2716 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002717
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002718 // Decide whether to use verbose asm. Verbose assembly is the default on
2719 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002720 bool IsIntegratedAssemblerDefault =
2721 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002722 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002723 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002724 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002725 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002726
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002727 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002728 IsIntegratedAssemblerDefault))
2729 CmdArgs.push_back("-no-integrated-as");
2730
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002731 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2732 CmdArgs.push_back("-mdebug-pass");
2733 CmdArgs.push_back("Structure");
2734 }
2735 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2736 CmdArgs.push_back("-mdebug-pass");
2737 CmdArgs.push_back("Arguments");
2738 }
2739
John McCall8517abc2010-02-19 02:45:38 +00002740 // Enable -mconstructor-aliases except on darwin, where we have to
2741 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002742 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002743 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002744
John McCall7ef5cb32011-03-18 02:56:14 +00002745 // Darwin's kernel doesn't support guard variables; just die if we
2746 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002747 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002748 CmdArgs.push_back("-fforbid-guard-variables");
2749
Douglas Gregordbe39272011-02-01 15:15:22 +00002750 if (Args.hasArg(options::OPT_mms_bitfields)) {
2751 CmdArgs.push_back("-mms-bitfields");
2752 }
John McCall8517abc2010-02-19 02:45:38 +00002753
Daniel Dunbar306945d2009-09-16 06:17:29 +00002754 // This is a coarse approximation of what llvm-gcc actually does, both
2755 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2756 // complicated ways.
2757 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002758 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2759 options::OPT_fno_asynchronous_unwind_tables,
2760 (getToolChain().IsUnwindTablesDefault() ||
2761 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2762 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002763 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2764 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002765 CmdArgs.push_back("-munwind-tables");
2766
Chandler Carruth05fb5852012-11-21 23:40:23 +00002767 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002768
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002769 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2770 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002771 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002772 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002773
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002774 // FIXME: Handle -mtune=.
2775 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002776
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002777 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002778 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002779 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002780 }
2781
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002782 // Add the target cpu
2783 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2784 llvm::Triple ETriple(ETripleStr);
2785 std::string CPU = getCPUName(Args, ETriple);
2786 if (!CPU.empty()) {
2787 CmdArgs.push_back("-target-cpu");
2788 CmdArgs.push_back(Args.MakeArgString(CPU));
2789 }
2790
Rafael Espindolaeb265472013-08-21 21:59:03 +00002791 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2792 CmdArgs.push_back("-mfpmath");
2793 CmdArgs.push_back(A->getValue());
2794 }
2795
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002796 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002797 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002798
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002799 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002800 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002801 default:
2802 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002803
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002804 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002805 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002806 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002807 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002808 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002809 break;
2810
Tim Northover573cbee2014-05-24 12:52:07 +00002811 case llvm::Triple::aarch64:
2812 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002813 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002814 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002815 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002816 break;
2817
Eric Christopher0b26a612010-03-02 02:41:08 +00002818 case llvm::Triple::mips:
2819 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002820 case llvm::Triple::mips64:
2821 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002822 AddMIPSTargetArgs(Args, CmdArgs);
2823 break;
2824
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002825 case llvm::Triple::sparc:
2826 AddSparcTargetArgs(Args, CmdArgs);
2827 break;
2828
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002829 case llvm::Triple::x86:
2830 case llvm::Triple::x86_64:
2831 AddX86TargetArgs(Args, CmdArgs);
2832 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002833
2834 case llvm::Triple::hexagon:
2835 AddHexagonTargetArgs(Args, CmdArgs);
2836 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002837 }
2838
Hans Wennborg75958c42013-08-08 00:17:41 +00002839 // Add clang-cl arguments.
2840 if (getToolChain().getDriver().IsCLMode())
2841 AddClangCLArgs(Args, CmdArgs);
2842
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002843 // Pass the linker version in use.
2844 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2845 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002846 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002847 }
2848
Eric Christopherb7d97e92013-04-03 01:58:53 +00002849 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002850 CmdArgs.push_back("-momit-leaf-frame-pointer");
2851
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002852 // Explicitly error on some things we know we don't support and can't just
2853 // ignore.
2854 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002855 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2856 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002857 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002858 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002859 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002860 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2861 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002862 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002863 << Unsupported->getOption().getName();
2864 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002865 }
2866
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002867 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002868 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002869 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002870 CmdArgs.push_back("-header-include-file");
2871 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2872 D.CCPrintHeadersFilename : "-");
2873 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002874 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002875 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002876
Chad Rosierbe10f982011-08-02 17:58:04 +00002877 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002878 CmdArgs.push_back("-diagnostic-log-file");
2879 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2880 D.CCLogDiagnosticsFilename : "-");
2881 }
2882
Manman Ren17bdb0f2013-11-20 20:22:14 +00002883 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2884 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002885 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002886 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002887 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002888 // FIXME: we should support specifying dwarf version with
2889 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002890 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00002891 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2892 const llvm::Triple &Triple = getToolChain().getTriple();
2893 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2894 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002895 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002896 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002897 CmdArgs.push_back("-gdwarf-2");
2898 else if (A->getOption().matches(options::OPT_gdwarf_3))
2899 CmdArgs.push_back("-gdwarf-3");
2900 else if (A->getOption().matches(options::OPT_gdwarf_4))
2901 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002902 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002903 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00002904 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2905 const llvm::Triple &Triple = getToolChain().getTriple();
2906 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2907 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002908 CmdArgs.push_back("-gdwarf-2");
2909 else
2910 CmdArgs.push_back("-g");
2911 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002912 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002913
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002914 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2915 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002916 if (Args.hasArg(options::OPT_gcolumn_info))
2917 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002918
Eric Christopher138c32b2013-09-13 22:37:55 +00002919 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002920 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2921 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002922 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002923 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002924 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002925 CmdArgs.push_back("-g");
2926 CmdArgs.push_back("-backend-option");
2927 CmdArgs.push_back("-split-dwarf=Enable");
2928 }
2929
Eric Christopher138c32b2013-09-13 22:37:55 +00002930 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2931 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2932 CmdArgs.push_back("-backend-option");
2933 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2934 }
Eric Christophereec89c22013-06-18 00:03:50 +00002935
Eric Christopher0d403d22014-02-14 01:27:03 +00002936 // -gdwarf-aranges turns on the emission of the aranges section in the
2937 // backend.
2938 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2939 CmdArgs.push_back("-backend-option");
2940 CmdArgs.push_back("-generate-arange-section");
2941 }
2942
David Blaikief36d9ba2014-01-27 18:52:43 +00002943 if (Args.hasFlag(options::OPT_fdebug_types_section,
2944 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002945 CmdArgs.push_back("-backend-option");
2946 CmdArgs.push_back("-generate-type-units");
2947 }
Eric Christophereec89c22013-06-18 00:03:50 +00002948
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002949 if (Args.hasFlag(options::OPT_ffunction_sections,
2950 options::OPT_fno_function_sections, false)) {
2951 CmdArgs.push_back("-ffunction-sections");
2952 }
2953
2954 if (Args.hasFlag(options::OPT_fdata_sections,
2955 options::OPT_fno_data_sections, false)) {
2956 CmdArgs.push_back("-fdata-sections");
2957 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002958
Chris Lattner3c77a352010-06-22 00:03:40 +00002959 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2960
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002961 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2962 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2963 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2964 D.Diag(diag::err_drv_argument_not_allowed_with)
2965 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2966
2967 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2968
2969 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2970 A->render(Args, CmdArgs);
2971 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2972 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
2973
Nick Lewycky207bce32011-04-21 23:44:07 +00002974 if (Args.hasArg(options::OPT_ftest_coverage) ||
2975 Args.hasArg(options::OPT_coverage))
2976 CmdArgs.push_back("-femit-coverage-notes");
2977 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2978 Args.hasArg(options::OPT_coverage))
2979 CmdArgs.push_back("-femit-coverage-data");
2980
Nick Lewycky480cb992011-05-04 20:46:58 +00002981 if (C.getArgs().hasArg(options::OPT_c) ||
2982 C.getArgs().hasArg(options::OPT_S)) {
2983 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00002984 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00002985 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00002986 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002987 SmallString<128> Pwd;
2988 if (!llvm::sys::fs::current_path(Pwd)) {
2989 llvm::sys::path::append(Pwd, CoverageFilename.str());
2990 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00002991 }
2992 }
Eric Christophere30f61c2013-02-22 00:24:40 +00002993 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00002994 }
2995 }
2996
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00002997 // Pass options for controlling the default header search paths.
2998 if (Args.hasArg(options::OPT_nostdinc)) {
2999 CmdArgs.push_back("-nostdsysteminc");
3000 CmdArgs.push_back("-nobuiltininc");
3001 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003002 if (Args.hasArg(options::OPT_nostdlibinc))
3003 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003004 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3005 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3006 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003007
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003008 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003009 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003010 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003011
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003012 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3013
Ted Kremenekf7639e12012-03-06 20:06:33 +00003014 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003015 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003016 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003017 options::OPT_ccc_arcmt_modify,
3018 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003019 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003020 switch (A->getOption().getID()) {
3021 default:
3022 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003023 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003024 CmdArgs.push_back("-arcmt-check");
3025 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003026 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003027 CmdArgs.push_back("-arcmt-modify");
3028 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003029 case options::OPT_ccc_arcmt_migrate:
3030 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003031 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003032 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003033
3034 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3035 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003036 break;
John McCalld70fb982011-06-15 23:25:17 +00003037 }
3038 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003039 } else {
3040 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3041 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3042 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003043 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003044
Ted Kremenekf7639e12012-03-06 20:06:33 +00003045 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3046 if (ARCMTEnabled) {
3047 D.Diag(diag::err_drv_argument_not_allowed_with)
3048 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3049 }
3050 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003051 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003052
3053 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003054 options::OPT_objcmt_migrate_subscripting,
3055 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003056 // None specified, means enable them all.
3057 CmdArgs.push_back("-objcmt-migrate-literals");
3058 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003059 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003060 } else {
3061 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3062 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003063 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003064 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003065 } else {
3066 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3067 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3068 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3069 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3070 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3071 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3072 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3073 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3074 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3075 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3076 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3077 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3078 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003079 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003080 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003081 }
3082
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003083 // Add preprocessing options like -I, -D, etc. if we are using the
3084 // preprocessor.
3085 //
3086 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003087 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003088 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003089
Rafael Espindolaa7431922011-07-21 23:40:37 +00003090 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3091 // that "The compiler can only warn and ignore the option if not recognized".
3092 // When building with ccache, it will pass -D options to clang even on
3093 // preprocessed inputs and configure concludes that -fPIC is not supported.
3094 Args.ClaimAllArgs(options::OPT_D);
3095
Alp Toker7874bdc2013-11-15 20:40:58 +00003096 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003097 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3098 if (A->getOption().matches(options::OPT_O4)) {
3099 CmdArgs.push_back("-O3");
3100 D.Diag(diag::warn_O4_is_O3);
3101 } else {
3102 A->render(Args, CmdArgs);
3103 }
3104 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003105
Chad Rosier86b82082012-12-12 20:06:31 +00003106 // Don't warn about unused -flto. This can happen when we're preprocessing or
3107 // precompiling.
3108 Args.ClaimAllArgs(options::OPT_flto);
3109
Daniel Dunbar945577c2009-10-29 02:24:45 +00003110 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003111 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3112 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003113 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003114 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003115
3116 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003117 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003118 //
3119 // If a std is supplied, only add -trigraphs if it follows the
3120 // option.
3121 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3122 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003123 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003124 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003125 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003126 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003127 else
3128 Std->render(Args, CmdArgs);
3129
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003130 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3131 options::OPT_trigraphs))
3132 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003133 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003134 } else {
3135 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003136 //
3137 // FIXME: Clang doesn't correctly handle -std= when the input language
3138 // doesn't match. For the time being just ignore this for C++ inputs;
3139 // eventually we want to do all the standard defaulting here instead of
3140 // splitting it between the driver and clang -cc1.
3141 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003142 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3143 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003144 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003145 CmdArgs.push_back("-std=c++11");
3146
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003147 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003148 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003149
Richard Smith282b4492013-09-04 22:50:31 +00003150 // GCC's behavior for -Wwrite-strings is a bit strange:
3151 // * In C, this "warning flag" changes the types of string literals from
3152 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3153 // for the discarded qualifier.
3154 // * In C++, this is just a normal warning flag.
3155 //
3156 // Implementing this warning correctly in C is hard, so we follow GCC's
3157 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3158 // a non-const char* in C, rather than using this crude hack.
3159 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003160 // FIXME: This should behave just like a warning flag, and thus should also
3161 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3162 Arg *WriteStrings =
3163 Args.getLastArg(options::OPT_Wwrite_strings,
3164 options::OPT_Wno_write_strings, options::OPT_w);
3165 if (WriteStrings &&
3166 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003167 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003168 }
3169
Chandler Carruth61fbf622011-04-23 09:27:53 +00003170 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003171 // during C++ compilation, which it is by default. GCC keeps this define even
3172 // in the presence of '-w', match this behavior bug-for-bug.
3173 if (types::isCXX(InputType) &&
3174 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3175 true)) {
3176 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003177 }
3178
Chandler Carruthe0391482010-05-22 02:21:53 +00003179 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3180 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3181 if (Asm->getOption().matches(options::OPT_fasm))
3182 CmdArgs.push_back("-fgnu-keywords");
3183 else
3184 CmdArgs.push_back("-fno-gnu-keywords");
3185 }
3186
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003187 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3188 CmdArgs.push_back("-fno-dwarf-directory-asm");
3189
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003190 if (ShouldDisableAutolink(Args, getToolChain()))
3191 CmdArgs.push_back("-fno-autolink");
3192
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003193 // Add in -fdebug-compilation-dir if necessary.
3194 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003195
Richard Smith9a568822011-11-21 19:36:32 +00003196 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3197 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003198 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003199 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003200 }
3201
Richard Smith79c927b2013-11-06 19:31:51 +00003202 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3203 CmdArgs.push_back("-foperator-arrow-depth");
3204 CmdArgs.push_back(A->getValue());
3205 }
3206
Richard Smith9a568822011-11-21 19:36:32 +00003207 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3208 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003209 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003210 }
3211
Richard Smitha3d3bd22013-05-08 02:12:03 +00003212 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3213 CmdArgs.push_back("-fconstexpr-steps");
3214 CmdArgs.push_back(A->getValue());
3215 }
3216
Richard Smithb3a14522013-02-22 01:59:51 +00003217 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3218 CmdArgs.push_back("-fbracket-depth");
3219 CmdArgs.push_back(A->getValue());
3220 }
3221
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003222 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3223 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003224 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003225 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003226 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3227 } else
3228 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003229 }
3230
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003231
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003232 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003233 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003234
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003235 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3236 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003237 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003238 }
David Chisnall5778fce2009-08-31 16:41:57 +00003239
Chris Lattnere23003d2010-01-09 21:54:33 +00003240 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3241 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003242 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003243 }
3244
Chris Lattnerb35583d2010-04-07 20:49:23 +00003245 CmdArgs.push_back("-ferror-limit");
3246 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003247 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003248 else
3249 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003250
Chandler Carrutha77a7272010-05-06 04:55:18 +00003251 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3252 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003253 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003254 }
3255
3256 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3257 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003258 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003259 }
3260
Richard Smithf6f003a2011-12-16 19:06:07 +00003261 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3262 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003263 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003264 }
3265
Daniel Dunbar2c978472009-11-04 06:24:47 +00003266 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003267 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003268 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003269 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003270 } else {
3271 // If -fmessage-length=N was not specified, determine whether this is a
3272 // terminal and, if so, implicitly define -fmessage-length appropriately.
3273 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003274 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003275 }
3276
John McCallb4a99d32013-02-19 01:57:35 +00003277 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3278 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3279 options::OPT_fvisibility_ms_compat)) {
3280 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3281 CmdArgs.push_back("-fvisibility");
3282 CmdArgs.push_back(A->getValue());
3283 } else {
3284 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3285 CmdArgs.push_back("-fvisibility");
3286 CmdArgs.push_back("hidden");
3287 CmdArgs.push_back("-ftype-visibility");
3288 CmdArgs.push_back("default");
3289 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003290 }
3291
Douglas Gregor08329632010-06-15 17:05:35 +00003292 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003293
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003294 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3295
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003296 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003297 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3298 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003299 CmdArgs.push_back("-ffreestanding");
3300
Daniel Dunbare357d562009-12-03 18:42:11 +00003301 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003302 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003303 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003304 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3305 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003306 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003307 // AltiVec language extensions aren't relevant for assembling.
3308 if (!isa<PreprocessJobAction>(JA) ||
3309 Output.getType() != types::TY_PP_Asm)
3310 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003311 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3312 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003313
Peter Collingbourne32701642013-11-01 18:16:25 +00003314 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3315 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003316
Will Dietz3676d562012-12-30 20:53:28 +00003317 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3318 options::OPT_fno_sanitize_recover,
3319 true))
3320 CmdArgs.push_back("-fno-sanitize-recover");
3321
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003322 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003323 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3324 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3325
Eric Christopher459d2712013-02-19 06:16:53 +00003326 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003327 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003328 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003329 getToolChain().getArch() == llvm::Triple::ppc64 ||
3330 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003331 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003332 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003333
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003334 if (getToolChain().SupportsProfiling())
3335 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003336
3337 // -flax-vector-conversions is default.
3338 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3339 options::OPT_fno_lax_vector_conversions))
3340 CmdArgs.push_back("-fno-lax-vector-conversions");
3341
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003342 if (Args.getLastArg(options::OPT_fapple_kext))
3343 CmdArgs.push_back("-fapple-kext");
3344
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003345 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003346 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003347 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003348 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3349 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003350
3351 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3352 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003353 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003354 }
3355
Bob Wilson14adb362012-02-03 06:27:22 +00003356 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003357
Chandler Carruth6e501032011-03-27 00:04:55 +00003358 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3359 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3360 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3361 options::OPT_fno_wrapv)) {
3362 if (A->getOption().matches(options::OPT_fwrapv))
3363 CmdArgs.push_back("-fwrapv");
3364 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3365 options::OPT_fno_strict_overflow)) {
3366 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3367 CmdArgs.push_back("-fwrapv");
3368 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003369
3370 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3371 options::OPT_fno_reroll_loops))
3372 if (A->getOption().matches(options::OPT_freroll_loops))
3373 CmdArgs.push_back("-freroll-loops");
3374
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003375 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003376 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3377 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003378
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003379 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3380
Mahesha S6a682be42012-10-27 07:47:56 +00003381
Daniel Dunbar4930e332009-11-17 08:07:36 +00003382 // -stack-protector=0 is default.
3383 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003384 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3385 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003386 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003387 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003388 if (A->getOption().matches(options::OPT_fstack_protector)) {
3389 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3390 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3391 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003392 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003393 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003394 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003395 } else {
3396 StackProtectorLevel =
3397 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3398 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003399 if (StackProtectorLevel) {
3400 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003401 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003402 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003403
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003404 // --param ssp-buffer-size=
3405 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3406 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003407 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003408 if (Str.startswith("ssp-buffer-size=")) {
3409 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003410 CmdArgs.push_back("-stack-protector-buffer-size");
3411 // FIXME: Verify the argument is a valid integer.
3412 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003413 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003414 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003415 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003416 }
3417
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003418 // Translate -mstackrealign
3419 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3420 false)) {
3421 CmdArgs.push_back("-backend-option");
3422 CmdArgs.push_back("-force-align-stack");
3423 }
3424 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3425 false)) {
3426 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3427 }
3428
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003429 if (Args.hasArg(options::OPT_mstack_alignment)) {
3430 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3431 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003432 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003433 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003434 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003435 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3436 options::OPT_munaligned_access)) {
3437 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3438 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003439 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3440 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3441 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003442 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003443 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003444 else
3445 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003446 } else {
3447 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003448 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3449 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3450 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003451 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003452 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003453 else
3454 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003455 }
Renato Golina146a482013-08-24 14:44:41 +00003456 }
Chad Rosier60027022012-11-09 17:29:19 +00003457 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003458
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003459 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3460 options::OPT_mno_restrict_it)) {
3461 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3462 CmdArgs.push_back("-backend-option");
3463 CmdArgs.push_back("-arm-restrict-it");
3464 } else {
3465 CmdArgs.push_back("-backend-option");
3466 CmdArgs.push_back("-arm-no-restrict-it");
3467 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003468 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3469 TT.getArch() == llvm::Triple::thumb)) {
3470 // Windows on ARM expects restricted IT blocks
3471 CmdArgs.push_back("-backend-option");
3472 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003473 }
3474
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003475 if (TT.getArch() == llvm::Triple::arm ||
3476 TT.getArch() == llvm::Triple::thumb) {
3477 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3478 options::OPT_mno_long_calls)) {
3479 if (A->getOption().matches(options::OPT_mlong_calls)) {
3480 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003481 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003482 }
3483 }
3484 }
3485
Daniel Dunbard18049a2009-04-07 21:16:11 +00003486 // Forward -f options with positive and negative forms; we translate
3487 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003488 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3489 StringRef fname = A->getValue();
3490 if (!llvm::sys::fs::exists(fname))
3491 D.Diag(diag::err_drv_no_such_file) << fname;
3492 else
3493 A->render(Args, CmdArgs);
3494 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003495
Diego Novillo829b1702014-04-16 16:54:24 +00003496 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3497 A->render(Args, CmdArgs);
3498
Diego Novillod23ec942014-05-29 19:55:06 +00003499 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3500 A->render(Args, CmdArgs);
3501
3502 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3503 A->render(Args, CmdArgs);
3504
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003505 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003506 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003507 CmdArgs.push_back("-fapple-kext");
3508 if (!Args.hasArg(options::OPT_fbuiltin))
3509 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003510 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003511 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003512 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003513 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003514 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003515
Nuno Lopes13c88c72009-12-16 16:59:22 +00003516 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3517 options::OPT_fno_assume_sane_operator_new))
3518 CmdArgs.push_back("-fno-assume-sane-operator-new");
3519
Daniel Dunbar4930e332009-11-17 08:07:36 +00003520 // -fblocks=0 is default.
3521 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003522 getToolChain().IsBlocksDefault()) ||
3523 (Args.hasArg(options::OPT_fgnu_runtime) &&
3524 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3525 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003526 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003527
3528 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3529 !getToolChain().hasBlocksRuntime())
3530 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003531 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003532
Douglas Gregor226173a2012-01-18 15:19:58 +00003533 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3534 // users must also pass -fcxx-modules. The latter flag will disappear once the
3535 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003536 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003537 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3538 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3539 options::OPT_fno_cxx_modules,
3540 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003541 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003542 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003543 HaveModules = true;
3544 }
3545 }
3546
Daniel Jasper07e6c402013-08-05 20:26:17 +00003547 // -fmodule-maps enables module map processing (off by default) for header
3548 // checking. It is implied by -fmodules.
3549 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3550 false)) {
3551 CmdArgs.push_back("-fmodule-maps");
3552 }
3553
Daniel Jasperac42b752013-10-21 06:34:34 +00003554 // -fmodules-decluse checks that modules used are declared so (off by
3555 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003556 if (Args.hasFlag(options::OPT_fmodules_decluse,
3557 options::OPT_fno_modules_decluse,
3558 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003559 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003560 }
3561
Daniel Jasper962b38e2014-04-11 11:47:45 +00003562 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3563 // all #included headers are part of modules.
3564 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3565 options::OPT_fno_modules_strict_decluse,
3566 false)) {
3567 CmdArgs.push_back("-fmodules-strict-decluse");
3568 }
3569
Daniel Jasperac42b752013-10-21 06:34:34 +00003570 // -fmodule-name specifies the module that is currently being built (or
3571 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003572 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003573 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003574
3575 // -fmodule-map-file can be used to specify a file containing module
3576 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003577 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003578 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003579
Justin Bognera88f0122014-06-20 22:59:50 +00003580 // -fmodule-cache-path specifies where our module files should be written.
3581 SmallString<128> ModuleCachePath;
3582 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3583 ModuleCachePath = A->getValue();
3584 if (HaveModules) {
3585 if (C.isForDiagnostics()) {
3586 // When generating crash reports, we want to emit the modules along with
3587 // the reproduction sources, so we ignore any provided module path.
3588 ModuleCachePath = Output.getFilename();
3589 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3590 llvm::sys::path::append(ModuleCachePath, "modules");
3591 } else if (ModuleCachePath.empty()) {
3592 // No module path was provided: use the default.
3593 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3594 ModuleCachePath);
3595 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3596 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3597 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003598 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003599 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3600 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3601 }
3602
3603 // When building modules and generating crashdumps, we need to dump a module
3604 // dependency VFS alongside the output.
3605 if (HaveModules && C.isForDiagnostics()) {
3606 SmallString<128> VFSDir(Output.getFilename());
3607 llvm::sys::path::replace_extension(VFSDir, ".cache");
3608 llvm::sys::path::append(VFSDir, "vfs");
3609 CmdArgs.push_back("-module-dependency-dir");
3610 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003611 }
3612
Justin Bogner5443ad52014-06-20 21:12:53 +00003613 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3614 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003615 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003616
Douglas Gregor35b04d62013-02-07 19:01:24 +00003617 // Pass through all -fmodules-ignore-macro arguments.
3618 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003619 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3620 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003621
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003622 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3623
3624 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3625 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3626 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3627
3628 Args.AddLastArg(CmdArgs,
3629 options::OPT_fmodules_validate_once_per_build_session);
3630 }
3631
Ben Langmuirdcf73862014-03-12 00:06:17 +00003632 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3633
John McCalldfea9982010-04-09 19:12:06 +00003634 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003635 if (Args.hasFlag(options::OPT_fno_access_control,
3636 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003637 false))
John McCall3155f572010-04-09 19:03:51 +00003638 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003639
Anders Carlssond470fef2010-11-21 00:09:52 +00003640 // -felide-constructors is the default.
3641 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3642 options::OPT_felide_constructors,
3643 false))
3644 CmdArgs.push_back("-fno-elide-constructors");
3645
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003646 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003647 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003648 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003649 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003650
Richard Smith52be6192012-11-05 22:04:41 +00003651 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003652 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003653 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003654 Args.getLastArg(options::OPT_mkernel,
3655 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003656 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003657 D.Diag(diag::err_drv_argument_not_allowed_with)
3658 << "-fsanitize=vptr" << NoRttiArg;
3659 }
3660 }
3661
Tony Linthicum76329bf2011-12-12 21:14:55 +00003662 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003663 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003664 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003665 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003666 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003667 CmdArgs.push_back("-fshort-enums");
3668
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003669 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003670 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003671 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003672 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003673
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003674 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003675 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003676 options::OPT_fno_threadsafe_statics))
3677 CmdArgs.push_back("-fno-threadsafe-statics");
3678
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003679 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003680 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3681 options::OPT_fno_use_cxa_atexit,
3682 !IsWindowsCygnus && !IsWindowsGNU &&
3683 getToolChain().getArch() != llvm::Triple::hexagon &&
3684 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003685 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003686 CmdArgs.push_back("-fno-use-cxa-atexit");
3687
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003688 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003689 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003690 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003691 CmdArgs.push_back("-fms-extensions");
3692
Francois Pichet1b4f1632011-09-17 04:32:15 +00003693 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003694 if (Args.hasFlag(options::OPT_fms_compatibility,
3695 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003696 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3697 options::OPT_fno_ms_extensions,
3698 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003699 CmdArgs.push_back("-fms-compatibility");
3700
Reid Klecknerc106fda2013-09-18 00:33:59 +00003701 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003702 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003703 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003704 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003705 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003706 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003707 else
3708 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3709 }
3710
3711
Eric Christopher5ecce122013-02-18 00:38:31 +00003712 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003713 if (Args.hasFlag(options::OPT_fborland_extensions,
3714 options::OPT_fno_borland_extensions, false))
3715 CmdArgs.push_back("-fborland-extensions");
3716
Francois Pichet02744872011-09-01 16:38:08 +00003717 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3718 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003719 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003720 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003721 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003722
Chandler Carruthe03aa552010-04-17 20:17:31 +00003723 // -fgnu-keywords default varies depending on language; only pass if
3724 // specified.
3725 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003726 options::OPT_fno_gnu_keywords))
3727 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003728
Rafael Espindola922a6242011-06-02 17:30:53 +00003729 if (Args.hasFlag(options::OPT_fgnu89_inline,
3730 options::OPT_fno_gnu89_inline,
3731 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003732 CmdArgs.push_back("-fgnu89-inline");
3733
Chad Rosier9c76d242012-03-15 22:31:42 +00003734 if (Args.hasArg(options::OPT_fno_inline))
3735 CmdArgs.push_back("-fno-inline");
3736
Chad Rosier64d6be92012-03-06 21:17:19 +00003737 if (Args.hasArg(options::OPT_fno_inline_functions))
3738 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003739
John McCall5fb5df92012-06-20 06:18:46 +00003740 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003741
John McCall5fb5df92012-06-20 06:18:46 +00003742 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003743 // legacy is the default. Except for deployment taget of 10.5,
3744 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3745 // gets ignored silently.
3746 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003747 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3748 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003749 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003750 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003751 if (getToolChain().UseObjCMixedDispatch())
3752 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3753 else
3754 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3755 }
3756 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003757
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003758 // When ObjectiveC legacy runtime is in effect on MacOSX,
3759 // turn on the option to do Array/Dictionary subscripting
3760 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003761 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3762 getToolChain().getTriple().isMacOSX() &&
3763 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3764 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003765 objcRuntime.isNeXTFamily())
3766 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3767
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003768 // -fencode-extended-block-signature=1 is default.
3769 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3770 CmdArgs.push_back("-fencode-extended-block-signature");
3771 }
3772
John McCall24fc0de2011-07-06 00:26:06 +00003773 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3774 // NOTE: This logic is duplicated in ToolChains.cpp.
3775 bool ARC = isObjCAutoRefCount(Args);
3776 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003777 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003778
John McCall24fc0de2011-07-06 00:26:06 +00003779 CmdArgs.push_back("-fobjc-arc");
3780
Chandler Carruth491db322011-11-04 07:34:47 +00003781 // FIXME: It seems like this entire block, and several around it should be
3782 // wrapped in isObjC, but for now we just use it here as this is where it
3783 // was being used previously.
3784 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3785 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3786 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3787 else
3788 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3789 }
3790
John McCall24fc0de2011-07-06 00:26:06 +00003791 // Allow the user to enable full exceptions code emission.
3792 // We define off for Objective-CC, on for Objective-C++.
3793 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3794 options::OPT_fno_objc_arc_exceptions,
3795 /*default*/ types::isCXX(InputType)))
3796 CmdArgs.push_back("-fobjc-arc-exceptions");
3797 }
3798
3799 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3800 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003801 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003802 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003803
John McCall24fc0de2011-07-06 00:26:06 +00003804 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3805 // takes precedence.
3806 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3807 if (!GCArg)
3808 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3809 if (GCArg) {
3810 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003811 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003812 << GCArg->getAsString(Args);
3813 } else if (getToolChain().SupportsObjCGC()) {
3814 GCArg->render(Args, CmdArgs);
3815 } else {
3816 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003817 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003818 << GCArg->getAsString(Args);
3819 }
3820 }
3821
John McCallb5f652e2011-06-22 00:53:57 +00003822 // Add exception args.
3823 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
John McCall5fb5df92012-06-20 06:18:46 +00003824 KernelOrKext, objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003825
3826 if (getToolChain().UseSjLjExceptions())
3827 CmdArgs.push_back("-fsjlj-exceptions");
3828
3829 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003830 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3831 options::OPT_fno_assume_sane_operator_new))
3832 CmdArgs.push_back("-fno-assume-sane-operator-new");
3833
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003834 // -fconstant-cfstrings is default, and may be subject to argument translation
3835 // on Darwin.
3836 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3837 options::OPT_fno_constant_cfstrings) ||
3838 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3839 options::OPT_mno_constant_cfstrings))
3840 CmdArgs.push_back("-fno-constant-cfstrings");
3841
John Thompsoned4e2952009-11-05 20:14:16 +00003842 // -fshort-wchar default varies depending on platform; only
3843 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003844 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3845 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003846 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003847
Hans Wennborg28c96312013-07-31 23:39:13 +00003848 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003849 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003850 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003851 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003852 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003853
Daniel Dunbar096ed292011-10-05 21:04:55 +00003854 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3855 // -fno-pack-struct doesn't apply to -fpack-struct=.
3856 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003857 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003858 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003859 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003860 } else if (Args.hasFlag(options::OPT_fpack_struct,
3861 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003862 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003863 }
3864
Robert Lytton0e076492013-08-13 09:43:10 +00003865 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003866 if (!Args.hasArg(options::OPT_fcommon))
3867 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003868 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003869 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003870
Daniel Dunbard18049a2009-04-07 21:16:11 +00003871 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003872 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003873 CmdArgs.push_back("-fno-common");
3874
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003875 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003876 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003877 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003878 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003879 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003880 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3881
Daniel Dunbar6358d682010-10-15 22:30:42 +00003882 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3883 if (!Args.hasFlag(options::OPT_ffor_scope,
3884 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003885 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003886 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3887
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003888 // -fcaret-diagnostics is default.
3889 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3890 options::OPT_fno_caret_diagnostics, true))
3891 CmdArgs.push_back("-fno-caret-diagnostics");
3892
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003893 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003894 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003895 options::OPT_fno_diagnostics_fixit_info))
3896 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003897
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003898 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003899 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003900 options::OPT_fno_diagnostics_show_option))
3901 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003902
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003903 if (const Arg *A =
3904 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3905 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003906 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003907 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003908
Douglas Gregor643c9222011-05-21 17:07:29 +00003909 if (const Arg *A =
3910 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3911 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003912 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003913 }
3914
Chandler Carruthb6766f02011-03-27 01:50:55 +00003915 if (Arg *A = Args.getLastArg(
3916 options::OPT_fdiagnostics_show_note_include_stack,
3917 options::OPT_fno_diagnostics_show_note_include_stack)) {
3918 if (A->getOption().matches(
3919 options::OPT_fdiagnostics_show_note_include_stack))
3920 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3921 else
3922 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3923 }
3924
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003925 // Color diagnostics are the default, unless the terminal doesn't support
3926 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003927 // Support both clang's -f[no-]color-diagnostics and gcc's
3928 // -f[no-]diagnostics-colors[=never|always|auto].
3929 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003930 for (const auto &Arg : Args) {
3931 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00003932 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3933 !O.matches(options::OPT_fdiagnostics_color) &&
3934 !O.matches(options::OPT_fno_color_diagnostics) &&
3935 !O.matches(options::OPT_fno_diagnostics_color) &&
3936 !O.matches(options::OPT_fdiagnostics_color_EQ))
3937 continue;
3938
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003939 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00003940 if (O.matches(options::OPT_fcolor_diagnostics) ||
3941 O.matches(options::OPT_fdiagnostics_color)) {
3942 ShowColors = Colors_On;
3943 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3944 O.matches(options::OPT_fno_diagnostics_color)) {
3945 ShowColors = Colors_Off;
3946 } else {
3947 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003948 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00003949 if (value == "always")
3950 ShowColors = Colors_On;
3951 else if (value == "never")
3952 ShowColors = Colors_Off;
3953 else if (value == "auto")
3954 ShowColors = Colors_Auto;
3955 else
3956 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3957 << ("-fdiagnostics-color=" + value).str();
3958 }
3959 }
3960 if (ShowColors == Colors_On ||
3961 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003962 CmdArgs.push_back("-fcolor-diagnostics");
3963
Nico Rieck7857d462013-09-11 00:38:02 +00003964 if (Args.hasArg(options::OPT_fansi_escape_codes))
3965 CmdArgs.push_back("-fansi-escape-codes");
3966
Daniel Dunbardb097022009-06-08 21:13:54 +00003967 if (!Args.hasFlag(options::OPT_fshow_source_location,
3968 options::OPT_fno_show_source_location))
3969 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003970
Douglas Gregor643c9222011-05-21 17:07:29 +00003971 if (!Args.hasFlag(options::OPT_fshow_column,
3972 options::OPT_fno_show_column,
3973 true))
3974 CmdArgs.push_back("-fno-show-column");
3975
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00003976 if (!Args.hasFlag(options::OPT_fspell_checking,
3977 options::OPT_fno_spell_checking))
3978 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003979
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003980
Chad Rosierc8e56e82012-12-05 21:08:21 +00003981 // -fno-asm-blocks is default.
3982 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3983 false))
3984 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00003985
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003986 // Enable vectorization per default according to the optimization level
3987 // selected. For optimization levels that want vectorization we use the alias
3988 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003989 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003990 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00003991 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00003992 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00003993 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003994 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00003995
Chad Rosier136d67d2014-04-28 19:30:57 +00003996 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003997 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
3998 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00003999 options::OPT_fslp_vectorize;
4000 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004001 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004002 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004003
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004004 // -fno-slp-vectorize-aggressive is default.
4005 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004006 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004007 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004008
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004009 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4010 A->render(Args, CmdArgs);
4011
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004012 // -fdollars-in-identifiers default varies depending on platform and
4013 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004014 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004015 options::OPT_fno_dollars_in_identifiers)) {
4016 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004017 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004018 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004019 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004020 }
4021
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004022 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4023 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004024 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004025 options::OPT_fno_unit_at_a_time)) {
4026 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004027 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004028 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004029
Eli Friedman055c9702011-11-02 01:53:16 +00004030 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4031 options::OPT_fno_apple_pragma_pack, false))
4032 CmdArgs.push_back("-fapple-pragma-pack");
4033
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004034 // le32-specific flags:
4035 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4036 // by default.
4037 if (getToolChain().getArch() == llvm::Triple::le32) {
4038 CmdArgs.push_back("-fno-math-builtin");
4039 }
4040
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004041 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004042 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004043 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004044#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004045 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004046 (getToolChain().getArch() == llvm::Triple::arm ||
4047 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004048 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4049 CmdArgs.push_back("-fno-builtin-strcat");
4050 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4051 CmdArgs.push_back("-fno-builtin-strcpy");
4052 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004053#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004054
Justin Bognera88f0122014-06-20 22:59:50 +00004055 // Enable rewrite includes if the user's asked for it or if we're generating
4056 // diagnostics.
4057 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4058 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004059 if (Args.hasFlag(options::OPT_frewrite_includes,
4060 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004061 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004062 CmdArgs.push_back("-frewrite-includes");
4063
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004064 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004065 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004066 options::OPT_traditional_cpp)) {
4067 if (isa<PreprocessJobAction>(JA))
4068 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004069 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004070 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004071 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004072
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004073 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004074 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004075
4076 // Handle serialized diagnostics.
4077 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4078 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004079 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004080 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004081
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004082 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4083 CmdArgs.push_back("-fretain-comments-from-system-headers");
4084
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004085 // Forward -fcomment-block-commands to -cc1.
4086 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004087 // Forward -fparse-all-comments to -cc1.
4088 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004089
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004090 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4091 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004092 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004093 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4094 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004095 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004096
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004097 // We translate this by hand to the -cc1 argument, since nightly test uses
4098 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004099 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004100 CmdArgs.push_back("-disable-llvm-optzns");
4101 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004102 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004103 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004104
Daniel Dunbard67a3222009-03-30 06:36:42 +00004105 if (Output.getType() == types::TY_Dependencies) {
4106 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004107 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004108 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004109 CmdArgs.push_back(Output.getFilename());
4110 } else {
4111 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004112 }
4113
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004114 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004115 addDashXForInput(Args, II, CmdArgs);
4116
Daniel Dunbarb440f562010-08-02 02:38:21 +00004117 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004118 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004119 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004120 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004121 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004122
Chris Lattnere9d7d782009-11-03 19:50:27 +00004123 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4124
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004125 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004126
4127 // Optionally embed the -cc1 level arguments into the debug info, for build
4128 // analysis.
4129 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004130 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004131 for (const auto &Arg : Args)
4132 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004133
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004134 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004135 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004136 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004137 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004138 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004139 }
4140 CmdArgs.push_back("-dwarf-debug-flags");
4141 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4142 }
4143
Eric Christopherd3804002013-02-22 20:12:52 +00004144 // Add the split debug info name to the command lines here so we
4145 // can propagate it to the backend.
4146 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004147 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004148 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004149 const char *SplitDwarfOut;
4150 if (SplitDwarf) {
4151 CmdArgs.push_back("-split-dwarf-file");
4152 SplitDwarfOut = SplitDebugName(Args, Inputs);
4153 CmdArgs.push_back(SplitDwarfOut);
4154 }
4155
4156 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004157 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004158 Output.getType() == types::TY_Object &&
4159 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg87cfa712013-09-19 20:32:16 +00004160 tools::visualstudio::Compile CL(getToolChain());
4161 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
4162 LinkingOutput);
Reid Kleckner47c2f842014-05-14 16:03:05 +00004163 // RTTI support in clang-cl is a work in progress. Fall back to MSVC early
4164 // if we are using 'clang-cl /fallback /GR'.
4165 // FIXME: Remove this when RTTI is finished.
4166 if (Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti, false)) {
4167 D.Diag(diag::warn_drv_rtti_fallback) << CLCommand->getExecutable();
4168 C.addCommand(CLCommand);
4169 } else {
4170 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
4171 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00004172 } else {
4173 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4174 }
4175
Daniel Dunbar17731772009-03-23 19:03:36 +00004176
Eric Christopherf1545832013-02-22 23:50:16 +00004177 // Handle the debug info splitting at object creation time if we're
4178 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004179 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004180 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004181 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004182
Roman Divacky178e01602011-02-10 16:52:03 +00004183 if (Arg *A = Args.getLastArg(options::OPT_pg))
4184 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004185 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004186 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004187
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004188 // Claim some arguments which clang supports automatically.
4189
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004190 // -fpch-preprocess is used with gcc to add a special marker in the output to
4191 // include the PCH file. Clang's PTH solution is completely transparent, so we
4192 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004193 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004194
Daniel Dunbar17731772009-03-23 19:03:36 +00004195 // Claim some arguments which clang doesn't support, but we don't
4196 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004197 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4198 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004199
Rafael Espindolab0092d72013-09-04 19:37:35 +00004200 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004201 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004202}
4203
John McCall5fb5df92012-06-20 06:18:46 +00004204/// Add options related to the Objective-C runtime/ABI.
4205///
4206/// Returns true if the runtime is non-fragile.
4207ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4208 ArgStringList &cmdArgs,
4209 RewriteKind rewriteKind) const {
4210 // Look for the controlling runtime option.
4211 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4212 options::OPT_fgnu_runtime,
4213 options::OPT_fobjc_runtime_EQ);
4214
4215 // Just forward -fobjc-runtime= to the frontend. This supercedes
4216 // options about fragility.
4217 if (runtimeArg &&
4218 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4219 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004220 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004221 if (runtime.tryParse(value)) {
4222 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4223 << value;
4224 }
4225
4226 runtimeArg->render(args, cmdArgs);
4227 return runtime;
4228 }
4229
4230 // Otherwise, we'll need the ABI "version". Version numbers are
4231 // slightly confusing for historical reasons:
4232 // 1 - Traditional "fragile" ABI
4233 // 2 - Non-fragile ABI, version 1
4234 // 3 - Non-fragile ABI, version 2
4235 unsigned objcABIVersion = 1;
4236 // If -fobjc-abi-version= is present, use that to set the version.
4237 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004238 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004239 if (value == "1")
4240 objcABIVersion = 1;
4241 else if (value == "2")
4242 objcABIVersion = 2;
4243 else if (value == "3")
4244 objcABIVersion = 3;
4245 else
4246 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4247 << value;
4248 } else {
4249 // Otherwise, determine if we are using the non-fragile ABI.
4250 bool nonFragileABIIsDefault =
4251 (rewriteKind == RK_NonFragile ||
4252 (rewriteKind == RK_None &&
4253 getToolChain().IsObjCNonFragileABIDefault()));
4254 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4255 options::OPT_fno_objc_nonfragile_abi,
4256 nonFragileABIIsDefault)) {
4257 // Determine the non-fragile ABI version to use.
4258#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4259 unsigned nonFragileABIVersion = 1;
4260#else
4261 unsigned nonFragileABIVersion = 2;
4262#endif
4263
4264 if (Arg *abiArg = args.getLastArg(
4265 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004266 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004267 if (value == "1")
4268 nonFragileABIVersion = 1;
4269 else if (value == "2")
4270 nonFragileABIVersion = 2;
4271 else
4272 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4273 << value;
4274 }
4275
4276 objcABIVersion = 1 + nonFragileABIVersion;
4277 } else {
4278 objcABIVersion = 1;
4279 }
4280 }
4281
4282 // We don't actually care about the ABI version other than whether
4283 // it's non-fragile.
4284 bool isNonFragile = objcABIVersion != 1;
4285
4286 // If we have no runtime argument, ask the toolchain for its default runtime.
4287 // However, the rewriter only really supports the Mac runtime, so assume that.
4288 ObjCRuntime runtime;
4289 if (!runtimeArg) {
4290 switch (rewriteKind) {
4291 case RK_None:
4292 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4293 break;
4294 case RK_Fragile:
4295 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4296 break;
4297 case RK_NonFragile:
4298 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4299 break;
4300 }
4301
4302 // -fnext-runtime
4303 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4304 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004305 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004306 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4307
4308 // Otherwise, build for a generic macosx port.
4309 } else {
4310 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4311 }
4312
4313 // -fgnu-runtime
4314 } else {
4315 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004316 // Legacy behaviour is to target the gnustep runtime if we are i
4317 // non-fragile mode or the GCC runtime in fragile mode.
4318 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004319 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004320 else
4321 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004322 }
4323
4324 cmdArgs.push_back(args.MakeArgString(
4325 "-fobjc-runtime=" + runtime.getAsString()));
4326 return runtime;
4327}
4328
Hans Wennborg75958c42013-08-08 00:17:41 +00004329void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4330 unsigned RTOptionID = options::OPT__SLASH_MT;
4331
Hans Wennborgf1a74252013-09-10 20:18:04 +00004332 if (Args.hasArg(options::OPT__SLASH_LDd))
4333 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4334 // but defining _DEBUG is sticky.
4335 RTOptionID = options::OPT__SLASH_MTd;
4336
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004337 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004338 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004339
Hans Wennborg75958c42013-08-08 00:17:41 +00004340 switch(RTOptionID) {
4341 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004342 if (Args.hasArg(options::OPT__SLASH_LDd))
4343 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004344 CmdArgs.push_back("-D_MT");
4345 CmdArgs.push_back("-D_DLL");
4346 CmdArgs.push_back("--dependent-lib=msvcrt");
4347 break;
4348 case options::OPT__SLASH_MDd:
4349 CmdArgs.push_back("-D_DEBUG");
4350 CmdArgs.push_back("-D_MT");
4351 CmdArgs.push_back("-D_DLL");
4352 CmdArgs.push_back("--dependent-lib=msvcrtd");
4353 break;
4354 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004355 if (Args.hasArg(options::OPT__SLASH_LDd))
4356 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004357 CmdArgs.push_back("-D_MT");
4358 CmdArgs.push_back("--dependent-lib=libcmt");
4359 break;
4360 case options::OPT__SLASH_MTd:
4361 CmdArgs.push_back("-D_DEBUG");
4362 CmdArgs.push_back("-D_MT");
4363 CmdArgs.push_back("--dependent-lib=libcmtd");
4364 break;
4365 default:
4366 llvm_unreachable("Unexpected option ID.");
4367 }
4368
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004369 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4370 // users want. The /Za flag to cl.exe turns this off, but it's not
4371 // implemented in clang.
4372 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004373
Hans Wennborg0fd62072013-08-09 00:32:23 +00004374 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4375 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004376
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004377 // RTTI is currently not supported, so disable it by default.
4378 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4379 CmdArgs.push_back("-fno-rtti");
4380
Hans Wennborge50cec32014-06-13 20:59:54 +00004381 // /EP should expand to -E -P.
4382 if (Args.hasArg(options::OPT__SLASH_EP)) {
4383 CmdArgs.push_back("-E");
4384 CmdArgs.push_back("-P");
4385 }
4386
David Majnemer86c318f2014-02-11 21:05:00 +00004387 const Driver &D = getToolChain().getDriver();
4388 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4389 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4390 if (MostGeneralArg && BestCaseArg)
4391 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4392 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4393
4394 if (MostGeneralArg) {
4395 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4396 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4397 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4398
4399 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4400 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4401 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4402 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4403 << FirstConflict->getAsString(Args)
4404 << SecondConflict->getAsString(Args);
4405
4406 if (SingleArg)
4407 CmdArgs.push_back("-fms-memptr-rep=single");
4408 else if (MultipleArg)
4409 CmdArgs.push_back("-fms-memptr-rep=multiple");
4410 else
4411 CmdArgs.push_back("-fms-memptr-rep=virtual");
4412 }
4413
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004414 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4415 A->render(Args, CmdArgs);
4416
Hans Wennborg81f74482013-09-10 01:07:07 +00004417 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4418 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004419 if (Args.hasArg(options::OPT__SLASH_fallback))
4420 CmdArgs.push_back("msvc-fallback");
4421 else
4422 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004423 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004424}
4425
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004426void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004427 const InputInfo &Output,
4428 const InputInfoList &Inputs,
4429 const ArgList &Args,
4430 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004431 ArgStringList CmdArgs;
4432
4433 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4434 const InputInfo &Input = Inputs[0];
4435
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004436 // Don't warn about "clang -w -c foo.s"
4437 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004438 // and "clang -emit-llvm -c foo.s"
4439 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004440
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004441 // Invoke ourselves in -cc1as mode.
4442 //
4443 // FIXME: Implement custom jobs for internal actions.
4444 CmdArgs.push_back("-cc1as");
4445
4446 // Add the "effective" target triple.
4447 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004448 std::string TripleStr =
4449 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004450 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4451
4452 // Set the output mode, we currently only expect to be used as a real
4453 // assembler.
4454 CmdArgs.push_back("-filetype");
4455 CmdArgs.push_back("obj");
4456
Eric Christopher45f2e712012-12-18 00:31:10 +00004457 // Set the main file name, so that debug info works even with
4458 // -save-temps or preprocessed assembly.
4459 CmdArgs.push_back("-main-file-name");
4460 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4461
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004462 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004463 const llvm::Triple &Triple = getToolChain().getTriple();
4464 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004465 if (!CPU.empty()) {
4466 CmdArgs.push_back("-target-cpu");
4467 CmdArgs.push_back(Args.MakeArgString(CPU));
4468 }
4469
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004470 // Add the target features
4471 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004472 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004473
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004474 // Ignore explicit -force_cpusubtype_ALL option.
4475 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004476
Eric Christopherfc3ee562012-01-10 00:38:01 +00004477 // Determine the original source input.
4478 const Action *SourceAction = &JA;
4479 while (SourceAction->getKind() != Action::InputClass) {
4480 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4481 SourceAction = SourceAction->getInputs()[0];
4482 }
4483
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004484 // Forward -g and handle debug info related flags, assuming we are dealing
4485 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004486 if (SourceAction->getType() == types::TY_Asm ||
4487 SourceAction->getType() == types::TY_PP_Asm) {
4488 Args.ClaimAllArgs(options::OPT_g_Group);
4489 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4490 if (!A->getOption().matches(options::OPT_g0))
4491 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004492
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004493 if (Args.hasArg(options::OPT_gdwarf_2))
4494 CmdArgs.push_back("-gdwarf-2");
4495 if (Args.hasArg(options::OPT_gdwarf_3))
4496 CmdArgs.push_back("-gdwarf-3");
4497 if (Args.hasArg(options::OPT_gdwarf_4))
4498 CmdArgs.push_back("-gdwarf-4");
4499
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004500 // Add the -fdebug-compilation-dir flag if needed.
4501 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004502
4503 // Set the AT_producer to the clang version when using the integrated
4504 // assembler on assembly source files.
4505 CmdArgs.push_back("-dwarf-debug-producer");
4506 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004507 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004508
4509 // Optionally embed the -cc1as level arguments into the debug info, for build
4510 // analysis.
4511 if (getToolChain().UseDwarfDebugFlags()) {
4512 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004513 for (const auto &Arg : Args)
4514 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004515
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004516 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004517 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4518 Flags += Exec;
4519 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4520 Flags += " ";
4521 Flags += OriginalArgs[i];
4522 }
4523 CmdArgs.push_back("-dwarf-debug-flags");
4524 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4525 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004526
4527 // FIXME: Add -static support, once we have it.
4528
David Blaikie372d9502014-01-17 03:17:40 +00004529 // Consume all the warning flags. Usually this would be handled more
4530 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4531 // doesn't handle that so rather than warning about unused flags that are
4532 // actually used, we'll lie by omission instead.
4533 // FIXME: Stop lying and consume only the appropriate driver flags
4534 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4535 ie = Args.filtered_end();
4536 it != ie; ++it)
4537 (*it)->claim();
4538
David Blaikie9260ed62013-07-25 21:19:01 +00004539 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4540 getToolChain().getDriver());
4541
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004542 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004543
4544 assert(Output.isFilename() && "Unexpected lipo output.");
4545 CmdArgs.push_back("-o");
4546 CmdArgs.push_back(Output.getFilename());
4547
Daniel Dunbarb440f562010-08-02 02:38:21 +00004548 assert(Input.isFilename() && "Invalid input.");
4549 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004550
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004551 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004552 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004553
4554 // Handle the debug info splitting at object creation time if we're
4555 // creating an object.
4556 // TODO: Currently only works on linux with newer objcopy.
4557 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004558 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004559 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4560 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004561}
4562
Daniel Dunbara3246a02009-03-18 08:07:30 +00004563void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004564 const InputInfo &Output,
4565 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004566 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004567 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004568 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004569 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004570
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004571 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004572 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004573 // Don't forward any -g arguments to assembly steps.
4574 if (isa<AssembleJobAction>(JA) &&
4575 A->getOption().matches(options::OPT_g_Group))
4576 continue;
4577
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004578 // Don't forward any -W arguments to assembly and link steps.
4579 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4580 A->getOption().matches(options::OPT_W_Group))
4581 continue;
4582
Daniel Dunbar2da02722009-03-19 07:55:12 +00004583 // It is unfortunate that we have to claim here, as this means
4584 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004585 // platforms using a generic gcc, even if we are just using gcc
4586 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004587 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004588 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004589 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004590 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004591
Daniel Dunbar4e295052010-01-25 22:35:08 +00004592 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004593
4594 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004595 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004596 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004597 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004598
4599 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004600 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004601 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004602 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004603 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004604 else if (Arch == llvm::Triple::ppc64le)
4605 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004606 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004607 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004608 }
4609
Daniel Dunbar5716d872009-05-02 21:41:52 +00004610 // Try to force gcc to match the tool chain we want, if we recognize
4611 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004612 //
4613 // FIXME: The triple class should directly provide the information we want
4614 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004615 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004616 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004617 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4618 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004619 CmdArgs.push_back("-m64");
4620
Daniel Dunbarb440f562010-08-02 02:38:21 +00004621 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004622 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004623 CmdArgs.push_back(Output.getFilename());
4624 } else {
4625 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004626 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004627 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004628
Tony Linthicum76329bf2011-12-12 21:14:55 +00004629 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4630 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004631
4632 // Only pass -x if gcc will understand it; otherwise hope gcc
4633 // understands the suffix correctly. The main use case this would go
4634 // wrong in is for linker inputs if they happened to have an odd
4635 // suffix; really the only way to get this to happen is a command
4636 // like '-x foobar a.c' which will treat a.c like a linker input.
4637 //
4638 // FIXME: For the linker case specifically, can we safely convert
4639 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004640 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004641 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004642 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4643 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004644 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004645 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004646 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004647 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004648 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004649 else if (II.getType() == types::TY_ModuleFile)
4650 D.Diag(diag::err_drv_no_module_support)
4651 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004652
Daniel Dunbara3246a02009-03-18 08:07:30 +00004653 if (types::canTypeBeUserSpecified(II.getType())) {
4654 CmdArgs.push_back("-x");
4655 CmdArgs.push_back(types::getTypeName(II.getType()));
4656 }
4657
Daniel Dunbarb440f562010-08-02 02:38:21 +00004658 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004659 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004660 else {
4661 const Arg &A = II.getInputArg();
4662
4663 // Reverse translate some rewritten options.
4664 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4665 CmdArgs.push_back("-lstdc++");
4666 continue;
4667 }
4668
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004669 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004670 A.render(Args, CmdArgs);
4671 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004672 }
4673
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004674 const std::string customGCCName = D.getCCCGenericGCCName();
4675 const char *GCCName;
4676 if (!customGCCName.empty())
4677 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004678 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004679 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004680 } else
4681 GCCName = "gcc";
4682
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004683 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004684 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004685 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004686}
4687
Daniel Dunbar4e295052010-01-25 22:35:08 +00004688void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4689 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004690 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004691}
4692
Daniel Dunbar4e295052010-01-25 22:35:08 +00004693void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4694 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004695 const Driver &D = getToolChain().getDriver();
4696
Daniel Dunbar4e295052010-01-25 22:35:08 +00004697 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004698 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4699 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004700 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004701 else {
4702 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004703 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004704 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004705
Daniel Dunbar4e295052010-01-25 22:35:08 +00004706 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004707 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004708}
4709
Daniel Dunbar4e295052010-01-25 22:35:08 +00004710void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4711 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004712 // The types are (hopefully) good enough.
4713}
4714
Tony Linthicum76329bf2011-12-12 21:14:55 +00004715// Hexagon tools start.
4716void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4717 ArgStringList &CmdArgs) const {
4718
4719}
4720void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4721 const InputInfo &Output,
4722 const InputInfoList &Inputs,
4723 const ArgList &Args,
4724 const char *LinkingOutput) const {
4725
4726 const Driver &D = getToolChain().getDriver();
4727 ArgStringList CmdArgs;
4728
4729 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004730 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004731 CmdArgs.push_back(Args.MakeArgString(MarchString));
4732
4733 RenderExtraToolArgs(JA, CmdArgs);
4734
4735 if (Output.isFilename()) {
4736 CmdArgs.push_back("-o");
4737 CmdArgs.push_back(Output.getFilename());
4738 } else {
4739 assert(Output.isNothing() && "Unexpected output");
4740 CmdArgs.push_back("-fsyntax-only");
4741 }
4742
Matthew Curtise8f80a12012-12-06 17:49:03 +00004743 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4744 if (!SmallDataThreshold.empty())
4745 CmdArgs.push_back(
4746 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004747
Matthew Curtise5df3812012-12-07 17:23:04 +00004748 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4749 options::OPT_Xassembler);
4750
Tony Linthicum76329bf2011-12-12 21:14:55 +00004751 // Only pass -x if gcc will understand it; otherwise hope gcc
4752 // understands the suffix correctly. The main use case this would go
4753 // wrong in is for linker inputs if they happened to have an odd
4754 // suffix; really the only way to get this to happen is a command
4755 // like '-x foobar a.c' which will treat a.c like a linker input.
4756 //
4757 // FIXME: For the linker case specifically, can we safely convert
4758 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004759 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004760 // Don't try to pass LLVM or AST inputs to a generic gcc.
4761 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4762 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4763 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4764 << getToolChain().getTripleString();
4765 else if (II.getType() == types::TY_AST)
4766 D.Diag(clang::diag::err_drv_no_ast_support)
4767 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004768 else if (II.getType() == types::TY_ModuleFile)
4769 D.Diag(diag::err_drv_no_module_support)
4770 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004771
4772 if (II.isFilename())
4773 CmdArgs.push_back(II.getFilename());
4774 else
4775 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4776 II.getInputArg().render(Args, CmdArgs);
4777 }
4778
4779 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004780 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004781 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004782}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004783
Tony Linthicum76329bf2011-12-12 21:14:55 +00004784void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4785 ArgStringList &CmdArgs) const {
4786 // The types are (hopefully) good enough.
4787}
4788
4789void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4790 const InputInfo &Output,
4791 const InputInfoList &Inputs,
4792 const ArgList &Args,
4793 const char *LinkingOutput) const {
4794
Matthew Curtise689b052012-12-06 15:46:07 +00004795 const toolchains::Hexagon_TC& ToolChain =
4796 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4797 const Driver &D = ToolChain.getDriver();
4798
Tony Linthicum76329bf2011-12-12 21:14:55 +00004799 ArgStringList CmdArgs;
4800
Matthew Curtise689b052012-12-06 15:46:07 +00004801 //----------------------------------------------------------------------------
4802 //
4803 //----------------------------------------------------------------------------
4804 bool hasStaticArg = Args.hasArg(options::OPT_static);
4805 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004806 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004807 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4808 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4809 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4810 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004811
Matthew Curtise689b052012-12-06 15:46:07 +00004812 //----------------------------------------------------------------------------
4813 // Silence warnings for various options
4814 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004815
Matthew Curtise689b052012-12-06 15:46:07 +00004816 Args.ClaimAllArgs(options::OPT_g_Group);
4817 Args.ClaimAllArgs(options::OPT_emit_llvm);
4818 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4819 // handled somewhere else.
4820 Args.ClaimAllArgs(options::OPT_static_libgcc);
4821
4822 //----------------------------------------------------------------------------
4823 //
4824 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004825 for (const auto &Opt : ToolChain.ExtraOpts)
4826 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004827
Matthew Curtisf10a5952012-12-06 14:16:43 +00004828 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4829 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004830
Matthew Curtise689b052012-12-06 15:46:07 +00004831 if (buildingLib) {
4832 CmdArgs.push_back("-shared");
4833 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4834 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004835 }
4836
Matthew Curtise689b052012-12-06 15:46:07 +00004837 if (hasStaticArg)
4838 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004839
Matthew Curtise8f80a12012-12-06 17:49:03 +00004840 if (buildPIE && !buildingLib)
4841 CmdArgs.push_back("-pie");
4842
4843 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4844 if (!SmallDataThreshold.empty()) {
4845 CmdArgs.push_back(
4846 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4847 }
4848
Matthew Curtise689b052012-12-06 15:46:07 +00004849 //----------------------------------------------------------------------------
4850 //
4851 //----------------------------------------------------------------------------
4852 CmdArgs.push_back("-o");
4853 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004854
Matthew Curtise689b052012-12-06 15:46:07 +00004855 const std::string MarchSuffix = "/" + MarchString;
4856 const std::string G0Suffix = "/G0";
4857 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4858 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4859 + "/";
4860 const std::string StartFilesDir = RootDir
4861 + "hexagon/lib"
4862 + (buildingLib
4863 ? MarchG0Suffix : MarchSuffix);
4864
4865 //----------------------------------------------------------------------------
4866 // moslib
4867 //----------------------------------------------------------------------------
4868 std::vector<std::string> oslibs;
4869 bool hasStandalone= false;
4870
4871 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4872 ie = Args.filtered_end(); it != ie; ++it) {
4873 (*it)->claim();
4874 oslibs.push_back((*it)->getValue());
4875 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004876 }
Matthew Curtise689b052012-12-06 15:46:07 +00004877 if (oslibs.empty()) {
4878 oslibs.push_back("standalone");
4879 hasStandalone = true;
4880 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004881
Matthew Curtise689b052012-12-06 15:46:07 +00004882 //----------------------------------------------------------------------------
4883 // Start Files
4884 //----------------------------------------------------------------------------
4885 if (incStdLib && incStartFiles) {
4886
4887 if (!buildingLib) {
4888 if (hasStandalone) {
4889 CmdArgs.push_back(
4890 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4891 }
4892 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4893 }
4894 std::string initObj = useShared ? "/initS.o" : "/init.o";
4895 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4896 }
4897
4898 //----------------------------------------------------------------------------
4899 // Library Search Paths
4900 //----------------------------------------------------------------------------
4901 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004902 for (const auto &LibPath : LibPaths)
4903 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00004904
4905 //----------------------------------------------------------------------------
4906 //
4907 //----------------------------------------------------------------------------
4908 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4909 Args.AddAllArgs(CmdArgs, options::OPT_e);
4910 Args.AddAllArgs(CmdArgs, options::OPT_s);
4911 Args.AddAllArgs(CmdArgs, options::OPT_t);
4912 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4913
4914 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4915
4916 //----------------------------------------------------------------------------
4917 // Libraries
4918 //----------------------------------------------------------------------------
4919 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004920 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00004921 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4922 CmdArgs.push_back("-lm");
4923 }
4924
4925 CmdArgs.push_back("--start-group");
4926
4927 if (!buildingLib) {
4928 for(std::vector<std::string>::iterator i = oslibs.begin(),
4929 e = oslibs.end(); i != e; ++i)
4930 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4931 CmdArgs.push_back("-lc");
4932 }
4933 CmdArgs.push_back("-lgcc");
4934
4935 CmdArgs.push_back("--end-group");
4936 }
4937
4938 //----------------------------------------------------------------------------
4939 // End files
4940 //----------------------------------------------------------------------------
4941 if (incStdLib && incStartFiles) {
4942 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4943 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4944 }
4945
4946 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00004947 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004948}
4949// Hexagon tools end.
4950
Bernard Ogden31561762013-12-12 13:27:11 +00004951/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
4952//
4953// FIXME: tblgen this.
4954const char *arm::getARMCPUForMArch(const ArgList &Args,
4955 const llvm::Triple &Triple) {
4956 StringRef MArch;
4957 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
4958 // Otherwise, if we have -march= choose the base CPU for that arch.
4959 MArch = A->getValue();
4960 } else {
4961 // Otherwise, use the Arch from the triple.
4962 MArch = Triple.getArchName();
4963 }
4964
4965 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00004966 if (MArch == "native") {
4967 std::string CPU = llvm::sys::getHostCPUName();
4968 if (CPU != "generic") {
4969 // Translate the native cpu into the architecture. The switch below will
4970 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00004971 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00004972 }
4973 }
4974
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004975 switch (Triple.getOS()) {
4976 case llvm::Triple::NetBSD:
Bernard Ogden31561762013-12-12 13:27:11 +00004977 if (MArch == "armv6")
4978 return "arm1176jzf-s";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004979 break;
4980 case llvm::Triple::Win32:
4981 // FIXME: this is invalid for WindowsCE
4982 return "cortex-a9";
4983 default:
4984 break;
Bernard Ogden31561762013-12-12 13:27:11 +00004985 }
4986
Christian Pirker918d1092014-05-05 08:48:18 +00004987 const char *result = nullptr;
4988 size_t offset = StringRef::npos;
4989 if (MArch.startswith("arm"))
4990 offset = 3;
4991 if (MArch.startswith("thumb"))
4992 offset = 5;
4993 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
4994 offset += 2;
4995 if (offset != StringRef::npos)
4996 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
4997 .Cases("v2", "v2a", "arm2")
4998 .Case("v3", "arm6")
4999 .Case("v3m", "arm7m")
5000 .Case("v4", "strongarm")
5001 .Case("v4t", "arm7tdmi")
5002 .Cases("v5", "v5t", "arm10tdmi")
5003 .Cases("v5e", "v5te", "arm1022e")
5004 .Case("v5tej", "arm926ej-s")
5005 .Cases("v6", "v6k", "arm1136jf-s")
5006 .Case("v6j", "arm1136j-s")
5007 .Cases("v6z", "v6zk", "arm1176jzf-s")
5008 .Case("v6t2", "arm1156t2-s")
5009 .Cases("v6m", "v6-m", "cortex-m0")
5010 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
5011 .Cases("v7s", "v7-s", "swift")
5012 .Cases("v7r", "v7-r", "cortex-r4")
5013 .Cases("v7m", "v7-m", "cortex-m3")
5014 .Cases("v7em", "v7e-m", "cortex-m4")
5015 .Cases("v8", "v8a", "v8-a", "cortex-a53")
5016 .Default(nullptr);
5017 else
5018 result = llvm::StringSwitch<const char *>(MArch)
5019 .Case("ep9312", "ep9312")
5020 .Case("iwmmxt", "iwmmxt")
5021 .Case("xscale", "xscale")
5022 .Default(nullptr);
Bernard Ogden31561762013-12-12 13:27:11 +00005023
5024 if (result)
5025 return result;
5026
Christian Pirker918d1092014-05-05 08:48:18 +00005027 // If all else failed, return the most base CPU with thumb interworking
5028 // supported by LLVM.
5029 // FIXME: Should warn once that we're falling back.
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00005030 switch (Triple.getOS()) {
5031 case llvm::Triple::NetBSD:
5032 switch (Triple.getEnvironment()) {
5033 case llvm::Triple::GNUEABIHF:
5034 case llvm::Triple::GNUEABI:
5035 case llvm::Triple::EABIHF:
5036 case llvm::Triple::EABI:
5037 return "arm926ej-s";
5038 default:
5039 return "strongarm";
5040 }
5041 default:
5042 switch (Triple.getEnvironment()) {
5043 case llvm::Triple::EABIHF:
5044 case llvm::Triple::GNUEABIHF:
5045 return "arm1176jzf-s";
5046 default:
5047 return "arm7tdmi";
5048 }
5049 }
Bernard Ogden31561762013-12-12 13:27:11 +00005050}
5051
5052/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005053StringRef arm::getARMTargetCPU(const ArgList &Args,
5054 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005055 // FIXME: Warn on inconsistent use of -mcpu and -march.
5056 // If we have -mcpu=, use that.
5057 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5058 StringRef MCPU = A->getValue();
5059 // Handle -mcpu=native.
5060 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005061 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005062 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005063 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005064 }
5065
5066 return getARMCPUForMArch(Args, Triple);
5067}
5068
5069/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5070/// CPU.
5071//
5072// FIXME: This is redundant with -mcpu, why does LLVM use this.
5073// FIXME: tblgen this, or kill it!
5074const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5075 return llvm::StringSwitch<const char *>(CPU)
5076 .Case("strongarm", "v4")
5077 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5078 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5079 .Cases("arm920", "arm920t", "arm922t", "v4t")
5080 .Cases("arm940t", "ep9312","v4t")
5081 .Cases("arm10tdmi", "arm1020t", "v5")
5082 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5083 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5084 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5085 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5086 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5087 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005088 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005089 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5090 .Cases("cortex-r4", "cortex-r5", "v7r")
5091 .Case("cortex-m0", "v6m")
5092 .Case("cortex-m3", "v7m")
5093 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005094 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005095 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005096 .Cases("cortex-a53", "cortex-a57", "v8")
5097 .Default("");
5098}
5099
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005100bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5101 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5102 return A && (A->getValue() == StringRef(Value));
5103}
5104
Tim Northover157d9112014-01-16 08:48:16 +00005105llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005106 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5107 // archs which Darwin doesn't use.
5108
5109 // The matching this routine does is fairly pointless, since it is neither the
5110 // complete architecture list, nor a reasonable subset. The problem is that
5111 // historically the driver driver accepts this and also ties its -march=
5112 // handling to the architecture name, so we need to be careful before removing
5113 // support for it.
5114
5115 // This code must be kept in sync with Clang's Darwin specific argument
5116 // translation.
5117
5118 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5119 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5120 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5121 .Case("ppc64", llvm::Triple::ppc64)
5122 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5123 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5124 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005125 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005126 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005127 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005128 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005129 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005130 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005131 .Case("r600", llvm::Triple::r600)
5132 .Case("nvptx", llvm::Triple::nvptx)
5133 .Case("nvptx64", llvm::Triple::nvptx64)
5134 .Case("amdil", llvm::Triple::amdil)
5135 .Case("spir", llvm::Triple::spir)
5136 .Default(llvm::Triple::UnknownArch);
5137}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005138
Tim Northover157d9112014-01-16 08:48:16 +00005139void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5140 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5141 T.setArch(Arch);
5142
5143 if (Str == "x86_64h")
5144 T.setArchName(Str);
5145 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5146 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005147 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005148 }
5149}
5150
Bob Wilsondecc03e2012-11-23 06:14:39 +00005151const char *Clang::getBaseInputName(const ArgList &Args,
5152 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005153 return Args.MakeArgString(
5154 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005155}
5156
Bob Wilsondecc03e2012-11-23 06:14:39 +00005157const char *Clang::getBaseInputStem(const ArgList &Args,
5158 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005159 const char *Str = getBaseInputName(Args, Inputs);
5160
Chris Lattner906bb902011-01-16 08:14:11 +00005161 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005162 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005163
5164 return Str;
5165}
5166
Bob Wilsondecc03e2012-11-23 06:14:39 +00005167const char *Clang::getDependencyFileName(const ArgList &Args,
5168 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005169 // FIXME: Think about this more.
5170 std::string Res;
5171
5172 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005173 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005174 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005175 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005176 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005177 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005178 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005179}
5180
Daniel Dunbarbe220842009-03-20 16:06:39 +00005181void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005182 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005183 const InputInfoList &Inputs,
5184 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005185 const char *LinkingOutput) const {
5186 ArgStringList CmdArgs;
5187
5188 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5189 const InputInfo &Input = Inputs[0];
5190
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005191 // Determine the original source input.
5192 const Action *SourceAction = &JA;
5193 while (SourceAction->getKind() != Action::InputClass) {
5194 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5195 SourceAction = SourceAction->getInputs()[0];
5196 }
5197
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005198 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005199 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005200 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5201 // FIXME: at run-time detect assembler capabilities or rely on version
5202 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005203 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005204 const llvm::Triple &T(getToolChain().getTriple());
5205 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005206 CmdArgs.push_back("-Q");
5207 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005208
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005209 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005210 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005211 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005212 if (Args.hasArg(options::OPT_gstabs))
5213 CmdArgs.push_back("--gstabs");
5214 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005215 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005216 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005217
Daniel Dunbarbe220842009-03-20 16:06:39 +00005218 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005219 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005220
Daniel Dunbar6d484762010-07-22 01:47:22 +00005221 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005222 if (getToolChain().getArch() == llvm::Triple::x86 ||
5223 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005224 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5225 CmdArgs.push_back("-force_cpusubtype_ALL");
5226
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005227 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005228 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005229 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005230 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005231 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005232 CmdArgs.push_back("-static");
5233
Daniel Dunbarbe220842009-03-20 16:06:39 +00005234 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5235 options::OPT_Xassembler);
5236
5237 assert(Output.isFilename() && "Unexpected lipo output.");
5238 CmdArgs.push_back("-o");
5239 CmdArgs.push_back(Output.getFilename());
5240
Daniel Dunbarb440f562010-08-02 02:38:21 +00005241 assert(Input.isFilename() && "Invalid input.");
5242 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005243
5244 // asm_final spec is empty.
5245
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005246 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005247 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005248 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005249}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005250
Tim Northover157d9112014-01-16 08:48:16 +00005251void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005252
Tim Northover157d9112014-01-16 08:48:16 +00005253void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5254 ArgStringList &CmdArgs) const {
5255 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005256
Daniel Dunbarc1964212009-03-26 16:23:12 +00005257 // Derived from darwin_arch spec.
5258 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005259 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005260
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005261 // FIXME: Is this needed anymore?
5262 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005263 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005264}
5265
Bill Wendling3b2000f2012-10-02 18:02:50 +00005266bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5267 // We only need to generate a temp path for LTO if we aren't compiling object
5268 // files. When compiling source files, we run 'dsymutil' after linking. We
5269 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005270 for (const auto &Input : Inputs)
5271 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005272 return true;
5273
5274 return false;
5275}
5276
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005277void darwin::Link::AddLinkArgs(Compilation &C,
5278 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005279 ArgStringList &CmdArgs,
5280 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005281 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005282 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005283
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005284 unsigned Version[3] = { 0, 0, 0 };
5285 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5286 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005287 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005288 Version[1], Version[2], HadExtra) ||
5289 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005290 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005291 << A->getAsString(Args);
5292 }
5293
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005294 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005295 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005296 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5297 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005298
Bob Wilson3d27dad2013-08-02 22:25:34 +00005299 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5300 CmdArgs.push_back("-export_dynamic");
5301
Bill Wendling313b6bf2012-11-16 23:03:00 +00005302 // If we are using LTO, then automatically create a temporary file path for
5303 // the linker to use, so that it's lifetime will extend past a possible
5304 // dsymutil step.
5305 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5306 const char *TmpPath = C.getArgs().MakeArgString(
5307 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5308 C.addTempFile(TmpPath);
5309 CmdArgs.push_back("-object_path_lto");
5310 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005311 }
5312
Daniel Dunbarc1964212009-03-26 16:23:12 +00005313 // Derived from the "link" spec.
5314 Args.AddAllArgs(CmdArgs, options::OPT_static);
5315 if (!Args.hasArg(options::OPT_static))
5316 CmdArgs.push_back("-dynamic");
5317 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5318 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5319 // here. How do we wish to handle such things?
5320 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005321
Daniel Dunbarc1964212009-03-26 16:23:12 +00005322 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005323 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005324 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005325 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005326
5327 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5328 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5329 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5330
5331 Arg *A;
5332 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5333 (A = Args.getLastArg(options::OPT_current__version)) ||
5334 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005335 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005336 << A->getAsString(Args) << "-dynamiclib";
5337
5338 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5339 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5340 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5341 } else {
5342 CmdArgs.push_back("-dylib");
5343
5344 Arg *A;
5345 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5346 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5347 (A = Args.getLastArg(options::OPT_client__name)) ||
5348 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5349 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5350 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005351 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005352 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005353
Daniel Dunbarc1964212009-03-26 16:23:12 +00005354 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5355 "-dylib_compatibility_version");
5356 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5357 "-dylib_current_version");
5358
Tim Northover157d9112014-01-16 08:48:16 +00005359 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005360
5361 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5362 "-dylib_install_name");
5363 }
5364
5365 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5366 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5367 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005368 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005369 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005370 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5371 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5372 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5373 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5374 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5375 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005376 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005377 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5378 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5379 Args.AddAllArgs(CmdArgs, options::OPT_init);
5380
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005381 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005382 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005383
Daniel Dunbarc1964212009-03-26 16:23:12 +00005384 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5385 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5386 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5387 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5388 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005389
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005390 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5391 options::OPT_fno_pie,
5392 options::OPT_fno_PIE)) {
5393 if (A->getOption().matches(options::OPT_fpie) ||
5394 A->getOption().matches(options::OPT_fPIE))
5395 CmdArgs.push_back("-pie");
5396 else
5397 CmdArgs.push_back("-no_pie");
5398 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005399
5400 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5401 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5402 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5403 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5404 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5405 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5406 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5407 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5408 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5409 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5410 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5411 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5412 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5413 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5414 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5415 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005416
Daniel Dunbar84384642011-05-02 21:03:47 +00005417 // Give --sysroot= preference, over the Apple specific behavior to also use
5418 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005419 StringRef sysroot = C.getSysRoot();
5420 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005421 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005422 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005423 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5424 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005425 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005426 }
5427
Daniel Dunbarc1964212009-03-26 16:23:12 +00005428 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5429 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5430 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5431 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5432 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005433 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005434 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5435 Args.AddAllArgs(CmdArgs, options::OPT_y);
5436 Args.AddLastArg(CmdArgs, options::OPT_w);
5437 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5438 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5439 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5440 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5441 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5442 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5443 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5444 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5445 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5446 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5447 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5448 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5449}
5450
Alexey Bataev186b28a2014-03-06 05:43:53 +00005451enum LibOpenMP {
5452 LibUnknown,
5453 LibGOMP,
5454 LibIOMP5
5455};
5456
Daniel Dunbarc1964212009-03-26 16:23:12 +00005457void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005458 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005459 const InputInfoList &Inputs,
5460 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005461 const char *LinkingOutput) const {
5462 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005463
Daniel Dunbarc1964212009-03-26 16:23:12 +00005464 // The logic here is derived from gcc's behavior; most of which
5465 // comes from specs (starting with link_command). Consult gcc for
5466 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005467 ArgStringList CmdArgs;
5468
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005469 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5470 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5471 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005472 for (const auto &Arg : Args)
5473 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005474 const char *Exec =
5475 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5476 CmdArgs.push_back(Output.getFilename());
5477 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5478 return;
5479 }
5480
Daniel Dunbarc1964212009-03-26 16:23:12 +00005481 // I'm not sure why this particular decomposition exists in gcc, but
5482 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005483 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005484
Daniel Dunbarc1964212009-03-26 16:23:12 +00005485 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5486 Args.AddAllArgs(CmdArgs, options::OPT_s);
5487 Args.AddAllArgs(CmdArgs, options::OPT_t);
5488 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5489 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005490 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005491 Args.AddAllArgs(CmdArgs, options::OPT_r);
5492
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005493 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5494 // members of static archive libraries which implement Objective-C classes or
5495 // categories.
5496 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5497 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005498
Daniel Dunbarc1964212009-03-26 16:23:12 +00005499 CmdArgs.push_back("-o");
5500 CmdArgs.push_back(Output.getFilename());
5501
Chad Rosier06fd3c62012-05-16 23:45:12 +00005502 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005503 !Args.hasArg(options::OPT_nostartfiles))
5504 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005505
5506 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005507
Alexey Bataev186b28a2014-03-06 05:43:53 +00005508 LibOpenMP UsedOpenMPLib = LibUnknown;
5509 if (Args.hasArg(options::OPT_fopenmp)) {
5510 UsedOpenMPLib = LibGOMP;
5511 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5512 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5513 .Case("libgomp", LibGOMP)
5514 .Case("libiomp5", LibIOMP5)
5515 .Default(LibUnknown);
5516 if (UsedOpenMPLib == LibUnknown)
5517 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5518 << A->getOption().getName() << A->getValue();
5519 }
5520 switch (UsedOpenMPLib) {
5521 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005522 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005523 break;
5524 case LibIOMP5:
5525 CmdArgs.push_back("-liomp5");
5526 break;
5527 case LibUnknown:
5528 break;
5529 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005530
Douglas Gregor9295df02012-05-15 21:00:27 +00005531 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5532
Bob Wilson16d93952012-05-15 18:57:39 +00005533 if (isObjCRuntimeLinked(Args) &&
5534 !Args.hasArg(options::OPT_nostdlib) &&
5535 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005536 // We use arclite library for both ARC and subscripting support.
5537 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5538
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005539 CmdArgs.push_back("-framework");
5540 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005541 // Link libobj.
5542 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005543 }
John McCall31168b02011-06-15 23:02:42 +00005544
Daniel Dunbarc1964212009-03-26 16:23:12 +00005545 if (LinkingOutput) {
5546 CmdArgs.push_back("-arch_multiple");
5547 CmdArgs.push_back("-final_output");
5548 CmdArgs.push_back(LinkingOutput);
5549 }
5550
Daniel Dunbarc1964212009-03-26 16:23:12 +00005551 if (Args.hasArg(options::OPT_fnested_functions))
5552 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005553
Daniel Dunbarc1964212009-03-26 16:23:12 +00005554 if (!Args.hasArg(options::OPT_nostdlib) &&
5555 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005556 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005557 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005558
Daniel Dunbarc1964212009-03-26 16:23:12 +00005559 // link_ssp spec is empty.
5560
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005561 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005562 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005563 }
5564
Chad Rosier06fd3c62012-05-16 23:45:12 +00005565 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005566 !Args.hasArg(options::OPT_nostartfiles)) {
5567 // endfile_spec is empty.
5568 }
5569
5570 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5571 Args.AddAllArgs(CmdArgs, options::OPT_F);
5572
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005573 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005574 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005575 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005576}
5577
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005578void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005579 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005580 const InputInfoList &Inputs,
5581 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005582 const char *LinkingOutput) const {
5583 ArgStringList CmdArgs;
5584
5585 CmdArgs.push_back("-create");
5586 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005587
5588 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005589 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005590
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005591 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005592 assert(II.isFilename() && "Unexpected lipo input.");
5593 CmdArgs.push_back(II.getFilename());
5594 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005595
5596 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005597 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005598}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005599
Daniel Dunbar88299622010-06-04 18:28:36 +00005600void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005601 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005602 const InputInfoList &Inputs,
5603 const ArgList &Args,
5604 const char *LinkingOutput) const {
5605 ArgStringList CmdArgs;
5606
Daniel Dunbareb86b042011-05-09 17:23:16 +00005607 CmdArgs.push_back("-o");
5608 CmdArgs.push_back(Output.getFilename());
5609
Daniel Dunbar88299622010-06-04 18:28:36 +00005610 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5611 const InputInfo &Input = Inputs[0];
5612 assert(Input.isFilename() && "Unexpected dsymutil input.");
5613 CmdArgs.push_back(Input.getFilename());
5614
Daniel Dunbar88299622010-06-04 18:28:36 +00005615 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005616 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005617 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005618}
5619
Eric Christopher551ef452011-08-23 17:56:55 +00005620void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005621 const InputInfo &Output,
5622 const InputInfoList &Inputs,
5623 const ArgList &Args,
5624 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005625 ArgStringList CmdArgs;
5626 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005627 CmdArgs.push_back("--debug-info");
5628 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005629 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005630
5631 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5632 const InputInfo &Input = Inputs[0];
5633 assert(Input.isFilename() && "Unexpected verify input");
5634
5635 // Grabbing the output of the earlier dsymutil run.
5636 CmdArgs.push_back(Input.getFilename());
5637
5638 const char *Exec =
5639 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5640 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5641}
5642
David Chisnallf571cde2012-02-15 13:39:01 +00005643void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5644 const InputInfo &Output,
5645 const InputInfoList &Inputs,
5646 const ArgList &Args,
5647 const char *LinkingOutput) const {
5648 ArgStringList CmdArgs;
5649
5650 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5651 options::OPT_Xassembler);
5652
5653 CmdArgs.push_back("-o");
5654 CmdArgs.push_back(Output.getFilename());
5655
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005656 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005657 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005658
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005659 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Chisnallf571cde2012-02-15 13:39:01 +00005660 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5661}
5662
David Chisnallf571cde2012-02-15 13:39:01 +00005663void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5664 const InputInfo &Output,
5665 const InputInfoList &Inputs,
5666 const ArgList &Args,
5667 const char *LinkingOutput) const {
5668 // FIXME: Find a real GCC, don't hard-code versions here
5669 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5670 const llvm::Triple &T = getToolChain().getTriple();
5671 std::string LibPath = "/usr/lib/";
5672 llvm::Triple::ArchType Arch = T.getArch();
5673 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005674 case llvm::Triple::x86:
5675 GCCLibPath +=
5676 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5677 break;
5678 case llvm::Triple::x86_64:
5679 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5680 GCCLibPath += "/4.5.2/amd64/";
5681 LibPath += "amd64/";
5682 break;
5683 default:
5684 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005685 }
5686
5687 ArgStringList CmdArgs;
5688
David Chisnall272a0712012-02-29 15:06:12 +00005689 // Demangle C++ names in errors
5690 CmdArgs.push_back("-C");
5691
David Chisnallf571cde2012-02-15 13:39:01 +00005692 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5693 (!Args.hasArg(options::OPT_shared))) {
5694 CmdArgs.push_back("-e");
5695 CmdArgs.push_back("_start");
5696 }
5697
5698 if (Args.hasArg(options::OPT_static)) {
5699 CmdArgs.push_back("-Bstatic");
5700 CmdArgs.push_back("-dn");
5701 } else {
5702 CmdArgs.push_back("-Bdynamic");
5703 if (Args.hasArg(options::OPT_shared)) {
5704 CmdArgs.push_back("-shared");
5705 } else {
5706 CmdArgs.push_back("--dynamic-linker");
5707 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5708 }
5709 }
5710
5711 if (Output.isFilename()) {
5712 CmdArgs.push_back("-o");
5713 CmdArgs.push_back(Output.getFilename());
5714 } else {
5715 assert(Output.isNothing() && "Invalid output.");
5716 }
5717
5718 if (!Args.hasArg(options::OPT_nostdlib) &&
5719 !Args.hasArg(options::OPT_nostartfiles)) {
5720 if (!Args.hasArg(options::OPT_shared)) {
5721 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5722 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005723 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005724 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5725 } else {
5726 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005727 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5728 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005729 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005730 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005731 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005732 }
5733
5734 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5735
5736 Args.AddAllArgs(CmdArgs, options::OPT_L);
5737 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5738 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005739 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005740
5741 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5742
5743 if (!Args.hasArg(options::OPT_nostdlib) &&
5744 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005745 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005746 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005747 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005748 if (!Args.hasArg(options::OPT_shared)) {
5749 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005750 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005751 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005752 }
David Chisnallf571cde2012-02-15 13:39:01 +00005753 }
5754
5755 if (!Args.hasArg(options::OPT_nostdlib) &&
5756 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005757 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005758 }
David Chisnall96de9932012-02-16 16:00:47 +00005759 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005760
Alexey Samsonov7811d192014-02-20 13:57:37 +00005761 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005762
5763 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005764 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
David Chisnallf571cde2012-02-15 13:39:01 +00005765 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5766}
5767
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005768void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005769 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005770 const InputInfoList &Inputs,
5771 const ArgList &Args,
5772 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005773 ArgStringList CmdArgs;
5774
5775 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5776 options::OPT_Xassembler);
5777
5778 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005779 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005780
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005781 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00005782 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005783
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005784 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005785 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005786}
5787
5788void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005789 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005790 const InputInfoList &Inputs,
5791 const ArgList &Args,
5792 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005793 ArgStringList CmdArgs;
5794
5795 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005796 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005797 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005798 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005799 }
5800
5801 if (Args.hasArg(options::OPT_static)) {
5802 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005803 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005804 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005805// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005806 CmdArgs.push_back("-Bdynamic");
5807 if (Args.hasArg(options::OPT_shared)) {
5808 CmdArgs.push_back("-shared");
5809 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005810 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005811 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5812 }
5813 }
5814
Daniel Dunbarb440f562010-08-02 02:38:21 +00005815 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005816 CmdArgs.push_back("-o");
5817 CmdArgs.push_back(Output.getFilename());
5818 } else {
5819 assert(Output.isNothing() && "Invalid output.");
5820 }
5821
5822 if (!Args.hasArg(options::OPT_nostdlib) &&
5823 !Args.hasArg(options::OPT_nostartfiles)) {
5824 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005825 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005826 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005827 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005828 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005829 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005830 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005831 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005832 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005833 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005834 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005835 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005836 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005837 }
5838
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005839 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5840 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005841 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005842
5843 Args.AddAllArgs(CmdArgs, options::OPT_L);
5844 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5845 Args.AddAllArgs(CmdArgs, options::OPT_e);
5846
Daniel Dunbar54423b22010-09-17 00:24:54 +00005847 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005848
5849 if (!Args.hasArg(options::OPT_nostdlib) &&
5850 !Args.hasArg(options::OPT_nodefaultlibs)) {
5851 // FIXME: For some reason GCC passes -lgcc before adding
5852 // the default system libraries. Just mimic this for now.
5853 CmdArgs.push_back("-lgcc");
5854
5855 if (Args.hasArg(options::OPT_pthread))
5856 CmdArgs.push_back("-pthread");
5857 if (!Args.hasArg(options::OPT_shared))
5858 CmdArgs.push_back("-lc");
5859 CmdArgs.push_back("-lgcc");
5860 }
5861
5862 if (!Args.hasArg(options::OPT_nostdlib) &&
5863 !Args.hasArg(options::OPT_nostartfiles)) {
5864 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005865 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005866 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005867 }
5868
Alexey Samsonov7811d192014-02-20 13:57:37 +00005869 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005870
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005871 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00005872 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005873 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005874}
5875
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005876void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005877 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005878 const InputInfoList &Inputs,
5879 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005880 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005881 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005882 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005883
Rafael Espindolacc126272014-02-28 01:55:21 +00005884 switch (getToolChain().getArch()) {
5885 case llvm::Triple::x86:
5886 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5887 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005888 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005889 break;
5890
5891 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005892 CmdArgs.push_back("-mppc");
5893 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005894 break;
5895
5896 case llvm::Triple::sparc:
5897 CmdArgs.push_back("-32");
5898 NeedsKPIC = true;
5899 break;
5900
5901 case llvm::Triple::sparcv9:
5902 CmdArgs.push_back("-64");
5903 CmdArgs.push_back("-Av9a");
5904 NeedsKPIC = true;
5905 break;
5906
5907 case llvm::Triple::mips64:
5908 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005909 StringRef CPUName;
5910 StringRef ABIName;
5911 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5912
5913 CmdArgs.push_back("-mabi");
5914 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5915
5916 if (getToolChain().getArch() == llvm::Triple::mips64)
5917 CmdArgs.push_back("-EB");
5918 else
5919 CmdArgs.push_back("-EL");
5920
Rafael Espindolacc126272014-02-28 01:55:21 +00005921 NeedsKPIC = true;
5922 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005923 }
5924
Rafael Espindolacc126272014-02-28 01:55:21 +00005925 default:
5926 break;
5927 }
5928
5929 if (NeedsKPIC)
5930 addAssemblerKPIC(Args, CmdArgs);
5931
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005932 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5933 options::OPT_Xassembler);
5934
5935 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005936 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005937
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005938 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00005939 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005940
5941 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005942 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005943 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005944}
5945
5946void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005947 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005948 const InputInfoList &Inputs,
5949 const ArgList &Args,
5950 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005951 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005952 ArgStringList CmdArgs;
5953
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00005954 // Silence warning for "clang -g foo.o -o foo"
5955 Args.ClaimAllArgs(options::OPT_g_Group);
5956 // and "clang -emit-llvm foo.o -o foo"
5957 Args.ClaimAllArgs(options::OPT_emit_llvm);
5958 // and for "clang -w foo.o -o foo". Other warning options are already
5959 // handled somewhere else.
5960 Args.ClaimAllArgs(options::OPT_w);
5961
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005962 if (getToolChain().getArch() == llvm::Triple::mips64)
5963 CmdArgs.push_back("-EB");
5964 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5965 CmdArgs.push_back("-EL");
5966
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005967 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005968 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005969 CmdArgs.push_back("-e");
5970 CmdArgs.push_back("__start");
5971 }
5972
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005973 if (Args.hasArg(options::OPT_static)) {
5974 CmdArgs.push_back("-Bstatic");
5975 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00005976 if (Args.hasArg(options::OPT_rdynamic))
5977 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005978 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005979 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005980 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00005981 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005982 } else {
5983 CmdArgs.push_back("-dynamic-linker");
5984 CmdArgs.push_back("/usr/libexec/ld.so");
5985 }
5986 }
5987
Rafael Espindola044f7832013-06-05 04:28:55 +00005988 if (Args.hasArg(options::OPT_nopie))
5989 CmdArgs.push_back("-nopie");
5990
Daniel Dunbarb440f562010-08-02 02:38:21 +00005991 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005992 CmdArgs.push_back("-o");
5993 CmdArgs.push_back(Output.getFilename());
5994 } else {
5995 assert(Output.isNothing() && "Invalid output.");
5996 }
5997
5998 if (!Args.hasArg(options::OPT_nostdlib) &&
5999 !Args.hasArg(options::OPT_nostartfiles)) {
6000 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006001 if (Args.hasArg(options::OPT_pg))
6002 CmdArgs.push_back(Args.MakeArgString(
6003 getToolChain().GetFilePath("gcrt0.o")));
6004 else
6005 CmdArgs.push_back(Args.MakeArgString(
6006 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006007 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006008 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006009 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006010 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006011 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006012 }
6013 }
6014
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006015 std::string Triple = getToolChain().getTripleString();
6016 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006017 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006018 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006019 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006020
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006021 Args.AddAllArgs(CmdArgs, options::OPT_L);
6022 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6023 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006024 Args.AddAllArgs(CmdArgs, options::OPT_s);
6025 Args.AddAllArgs(CmdArgs, options::OPT_t);
6026 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6027 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006028
Daniel Dunbar54423b22010-09-17 00:24:54 +00006029 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006030
6031 if (!Args.hasArg(options::OPT_nostdlib) &&
6032 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006033 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006034 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006035 if (Args.hasArg(options::OPT_pg))
6036 CmdArgs.push_back("-lm_p");
6037 else
6038 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006039 }
6040
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006041 // FIXME: For some reason GCC passes -lgcc before adding
6042 // the default system libraries. Just mimic this for now.
6043 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006044
Eric Christopher17674ec2012-09-13 06:32:34 +00006045 if (Args.hasArg(options::OPT_pthread)) {
6046 if (!Args.hasArg(options::OPT_shared) &&
6047 Args.hasArg(options::OPT_pg))
6048 CmdArgs.push_back("-lpthread_p");
6049 else
6050 CmdArgs.push_back("-lpthread");
6051 }
6052
Chandler Carruth45661652011-12-17 22:32:42 +00006053 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006054 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006055 CmdArgs.push_back("-lc_p");
6056 else
6057 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006058 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006059
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006060 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006061 }
6062
6063 if (!Args.hasArg(options::OPT_nostdlib) &&
6064 !Args.hasArg(options::OPT_nostartfiles)) {
6065 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006066 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006067 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006068 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006069 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006070 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006071 }
6072
6073 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006074 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006075 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006076}
Ed Schoutene33194b2009-04-02 19:13:12 +00006077
Eli Friedman9fa28852012-08-08 23:57:20 +00006078void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6079 const InputInfo &Output,
6080 const InputInfoList &Inputs,
6081 const ArgList &Args,
6082 const char *LinkingOutput) const {
6083 ArgStringList CmdArgs;
6084
6085 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6086 options::OPT_Xassembler);
6087
6088 CmdArgs.push_back("-o");
6089 CmdArgs.push_back(Output.getFilename());
6090
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006091 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006092 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006093
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006094 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Eli Friedman9fa28852012-08-08 23:57:20 +00006095 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6096}
6097
6098void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6099 const InputInfo &Output,
6100 const InputInfoList &Inputs,
6101 const ArgList &Args,
6102 const char *LinkingOutput) const {
6103 const Driver &D = getToolChain().getDriver();
6104 ArgStringList CmdArgs;
6105
6106 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6107 (!Args.hasArg(options::OPT_shared))) {
6108 CmdArgs.push_back("-e");
6109 CmdArgs.push_back("__start");
6110 }
6111
6112 if (Args.hasArg(options::OPT_static)) {
6113 CmdArgs.push_back("-Bstatic");
6114 } else {
6115 if (Args.hasArg(options::OPT_rdynamic))
6116 CmdArgs.push_back("-export-dynamic");
6117 CmdArgs.push_back("--eh-frame-hdr");
6118 CmdArgs.push_back("-Bdynamic");
6119 if (Args.hasArg(options::OPT_shared)) {
6120 CmdArgs.push_back("-shared");
6121 } else {
6122 CmdArgs.push_back("-dynamic-linker");
6123 CmdArgs.push_back("/usr/libexec/ld.so");
6124 }
6125 }
6126
6127 if (Output.isFilename()) {
6128 CmdArgs.push_back("-o");
6129 CmdArgs.push_back(Output.getFilename());
6130 } else {
6131 assert(Output.isNothing() && "Invalid output.");
6132 }
6133
6134 if (!Args.hasArg(options::OPT_nostdlib) &&
6135 !Args.hasArg(options::OPT_nostartfiles)) {
6136 if (!Args.hasArg(options::OPT_shared)) {
6137 if (Args.hasArg(options::OPT_pg))
6138 CmdArgs.push_back(Args.MakeArgString(
6139 getToolChain().GetFilePath("gcrt0.o")));
6140 else
6141 CmdArgs.push_back(Args.MakeArgString(
6142 getToolChain().GetFilePath("crt0.o")));
6143 CmdArgs.push_back(Args.MakeArgString(
6144 getToolChain().GetFilePath("crtbegin.o")));
6145 } else {
6146 CmdArgs.push_back(Args.MakeArgString(
6147 getToolChain().GetFilePath("crtbeginS.o")));
6148 }
6149 }
6150
6151 Args.AddAllArgs(CmdArgs, options::OPT_L);
6152 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6153 Args.AddAllArgs(CmdArgs, options::OPT_e);
6154
6155 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6156
6157 if (!Args.hasArg(options::OPT_nostdlib) &&
6158 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006159 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006160 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6161 if (Args.hasArg(options::OPT_pg))
6162 CmdArgs.push_back("-lm_p");
6163 else
6164 CmdArgs.push_back("-lm");
6165 }
6166
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006167 if (Args.hasArg(options::OPT_pthread)) {
6168 if (!Args.hasArg(options::OPT_shared) &&
6169 Args.hasArg(options::OPT_pg))
6170 CmdArgs.push_back("-lpthread_p");
6171 else
6172 CmdArgs.push_back("-lpthread");
6173 }
6174
Eli Friedman9fa28852012-08-08 23:57:20 +00006175 if (!Args.hasArg(options::OPT_shared)) {
6176 if (Args.hasArg(options::OPT_pg))
6177 CmdArgs.push_back("-lc_p");
6178 else
6179 CmdArgs.push_back("-lc");
6180 }
6181
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006182 StringRef MyArch;
6183 switch (getToolChain().getTriple().getArch()) {
6184 case llvm::Triple::arm:
6185 MyArch = "arm";
6186 break;
6187 case llvm::Triple::x86:
6188 MyArch = "i386";
6189 break;
6190 case llvm::Triple::x86_64:
6191 MyArch = "amd64";
6192 break;
6193 default:
6194 llvm_unreachable("Unsupported architecture");
6195 }
6196 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006197 }
6198
6199 if (!Args.hasArg(options::OPT_nostdlib) &&
6200 !Args.hasArg(options::OPT_nostartfiles)) {
6201 if (!Args.hasArg(options::OPT_shared))
6202 CmdArgs.push_back(Args.MakeArgString(
6203 getToolChain().GetFilePath("crtend.o")));
6204 else
6205 CmdArgs.push_back(Args.MakeArgString(
6206 getToolChain().GetFilePath("crtendS.o")));
6207 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006208
6209 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006210 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006211 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006212}
6213
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006214void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006215 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006216 const InputInfoList &Inputs,
6217 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006218 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006219 ArgStringList CmdArgs;
6220
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006221 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6222 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006223 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006224 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006225 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006226 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006227 else if (getToolChain().getArch() == llvm::Triple::mips ||
6228 getToolChain().getArch() == llvm::Triple::mipsel ||
6229 getToolChain().getArch() == llvm::Triple::mips64 ||
6230 getToolChain().getArch() == llvm::Triple::mips64el) {
6231 StringRef CPUName;
6232 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006233 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006234
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006235 CmdArgs.push_back("-march");
6236 CmdArgs.push_back(CPUName.data());
6237
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006238 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006239 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006240
6241 if (getToolChain().getArch() == llvm::Triple::mips ||
6242 getToolChain().getArch() == llvm::Triple::mips64)
6243 CmdArgs.push_back("-EB");
6244 else
6245 CmdArgs.push_back("-EL");
6246
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006247 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006248 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006249 getToolChain().getArch() == llvm::Triple::armeb ||
6250 getToolChain().getArch() == llvm::Triple::thumb ||
6251 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006252 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006253 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006254 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6255
6256 if (FloatABI == "hard") {
6257 CmdArgs.push_back("-mfpu=vfp");
6258 } else {
6259 CmdArgs.push_back("-mfpu=softvfp");
6260 }
6261
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006262 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006263 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006264 case llvm::Triple::GNUEABI:
6265 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006266 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006267 break;
6268
6269 default:
6270 CmdArgs.push_back("-matpcs");
6271 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006272 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006273 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006274 if (getToolChain().getArch() == llvm::Triple::sparc)
6275 CmdArgs.push_back("-Av8plusa");
6276 else
6277 CmdArgs.push_back("-Av9a");
6278
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006279 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006280 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006281
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006282 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6283 options::OPT_Xassembler);
6284
6285 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006286 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006287
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006288 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006289 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006290
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006291 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006292 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006293}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006294
6295void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006296 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006297 const InputInfoList &Inputs,
6298 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006299 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006300 const toolchains::FreeBSD& ToolChain =
6301 static_cast<const toolchains::FreeBSD&>(getToolChain());
6302 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006303 const bool IsPIE =
6304 !Args.hasArg(options::OPT_shared) &&
6305 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006306 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006307
6308 // Silence warning for "clang -g foo.o -o foo"
6309 Args.ClaimAllArgs(options::OPT_g_Group);
6310 // and "clang -emit-llvm foo.o -o foo"
6311 Args.ClaimAllArgs(options::OPT_emit_llvm);
6312 // and for "clang -w foo.o -o foo". Other warning options are already
6313 // handled somewhere else.
6314 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006315
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006316 if (!D.SysRoot.empty())
6317 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6318
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006319 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006320 CmdArgs.push_back("-pie");
6321
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006322 if (Args.hasArg(options::OPT_static)) {
6323 CmdArgs.push_back("-Bstatic");
6324 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006325 if (Args.hasArg(options::OPT_rdynamic))
6326 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006327 CmdArgs.push_back("--eh-frame-hdr");
6328 if (Args.hasArg(options::OPT_shared)) {
6329 CmdArgs.push_back("-Bshareable");
6330 } else {
6331 CmdArgs.push_back("-dynamic-linker");
6332 CmdArgs.push_back("/libexec/ld-elf.so.1");
6333 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006334 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6335 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006336 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6337 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6338 CmdArgs.push_back("--hash-style=both");
6339 }
6340 }
6341 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006342 }
6343
6344 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6345 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006346 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006347 CmdArgs.push_back("-m");
6348 CmdArgs.push_back("elf_i386_fbsd");
6349 }
6350
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006351 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006352 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006353 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006354 }
6355
Daniel Dunbarb440f562010-08-02 02:38:21 +00006356 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006357 CmdArgs.push_back("-o");
6358 CmdArgs.push_back(Output.getFilename());
6359 } else {
6360 assert(Output.isNothing() && "Invalid output.");
6361 }
6362
6363 if (!Args.hasArg(options::OPT_nostdlib) &&
6364 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006365 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006366 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006367 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006368 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006369 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006370 crt1 = "Scrt1.o";
6371 else
6372 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006373 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006374 if (crt1)
6375 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6376
6377 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6378
Craig Topper92fc2df2014-05-17 16:56:41 +00006379 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006380 if (Args.hasArg(options::OPT_static))
6381 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006382 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006383 crtbegin = "crtbeginS.o";
6384 else
6385 crtbegin = "crtbegin.o";
6386
6387 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006388 }
6389
6390 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006391 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006392 for (const auto &Path : Paths)
6393 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006394 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6395 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006396 Args.AddAllArgs(CmdArgs, options::OPT_s);
6397 Args.AddAllArgs(CmdArgs, options::OPT_t);
6398 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6399 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006400
Alp Tokerce365ca2013-12-02 12:43:03 +00006401 if (D.IsUsingLTO(Args))
6402 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006403
Roman Divackyafe2f232012-08-28 15:09:03 +00006404 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006405
6406 if (!Args.hasArg(options::OPT_nostdlib) &&
6407 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006408 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006409 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006410 if (Args.hasArg(options::OPT_pg))
6411 CmdArgs.push_back("-lm_p");
6412 else
6413 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006414 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006415 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6416 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006417 if (Args.hasArg(options::OPT_pg))
6418 CmdArgs.push_back("-lgcc_p");
6419 else
6420 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006421 if (Args.hasArg(options::OPT_static)) {
6422 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006423 } else if (Args.hasArg(options::OPT_pg)) {
6424 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006425 } else {
6426 CmdArgs.push_back("--as-needed");
6427 CmdArgs.push_back("-lgcc_s");
6428 CmdArgs.push_back("--no-as-needed");
6429 }
6430
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006431 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006432 if (Args.hasArg(options::OPT_pg))
6433 CmdArgs.push_back("-lpthread_p");
6434 else
6435 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006436 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006437
Roman Divacky66f22762011-02-10 16:59:40 +00006438 if (Args.hasArg(options::OPT_pg)) {
6439 if (Args.hasArg(options::OPT_shared))
6440 CmdArgs.push_back("-lc");
6441 else
6442 CmdArgs.push_back("-lc_p");
6443 CmdArgs.push_back("-lgcc_p");
6444 } else {
6445 CmdArgs.push_back("-lc");
6446 CmdArgs.push_back("-lgcc");
6447 }
6448
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006449 if (Args.hasArg(options::OPT_static)) {
6450 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006451 } else if (Args.hasArg(options::OPT_pg)) {
6452 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006453 } else {
6454 CmdArgs.push_back("--as-needed");
6455 CmdArgs.push_back("-lgcc_s");
6456 CmdArgs.push_back("--no-as-needed");
6457 }
6458 }
6459
6460 if (!Args.hasArg(options::OPT_nostdlib) &&
6461 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006462 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006463 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006464 else
6465 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006466 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006467 }
6468
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006469 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6470
Alexey Samsonov7811d192014-02-20 13:57:37 +00006471 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006472
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006473 const char *Exec =
Rafael Espindola236db462013-11-09 20:07:19 +00006474 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006475 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006476}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006477
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006478void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6479 const InputInfo &Output,
6480 const InputInfoList &Inputs,
6481 const ArgList &Args,
6482 const char *LinkingOutput) const {
6483 ArgStringList CmdArgs;
6484
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006485 // GNU as needs different flags for creating the correct output format
6486 // on architectures with different ABIs or optional feature sets.
6487 switch (getToolChain().getArch()) {
6488 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006489 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006490 break;
6491 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006492 case llvm::Triple::armeb:
6493 case llvm::Triple::thumb:
6494 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006495 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006496 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006497 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006498 }
6499
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006500 case llvm::Triple::mips:
6501 case llvm::Triple::mipsel:
6502 case llvm::Triple::mips64:
6503 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006504 StringRef CPUName;
6505 StringRef ABIName;
6506 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6507
6508 CmdArgs.push_back("-march");
6509 CmdArgs.push_back(CPUName.data());
6510
6511 CmdArgs.push_back("-mabi");
6512 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6513
6514 if (getToolChain().getArch() == llvm::Triple::mips ||
6515 getToolChain().getArch() == llvm::Triple::mips64)
6516 CmdArgs.push_back("-EB");
6517 else
6518 CmdArgs.push_back("-EL");
6519
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006520 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006521 break;
6522 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006523
6524 case llvm::Triple::sparc:
6525 CmdArgs.push_back("-32");
6526 addAssemblerKPIC(Args, CmdArgs);
6527 break;
6528
6529 case llvm::Triple::sparcv9:
6530 CmdArgs.push_back("-64");
6531 CmdArgs.push_back("-Av9");
6532 addAssemblerKPIC(Args, CmdArgs);
6533 break;
6534
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006535 default:
6536 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006537 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006538
6539 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6540 options::OPT_Xassembler);
6541
6542 CmdArgs.push_back("-o");
6543 CmdArgs.push_back(Output.getFilename());
6544
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006545 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006546 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006547
David Chisnallddbd68f2011-09-27 22:03:18 +00006548 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006549 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6550}
6551
6552void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6553 const InputInfo &Output,
6554 const InputInfoList &Inputs,
6555 const ArgList &Args,
6556 const char *LinkingOutput) const {
6557 const Driver &D = getToolChain().getDriver();
6558 ArgStringList CmdArgs;
6559
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006560 if (!D.SysRoot.empty())
6561 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6562
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006563 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006564 if (Args.hasArg(options::OPT_static)) {
6565 CmdArgs.push_back("-Bstatic");
6566 } else {
6567 if (Args.hasArg(options::OPT_rdynamic))
6568 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006569 if (Args.hasArg(options::OPT_shared)) {
6570 CmdArgs.push_back("-Bshareable");
6571 } else {
6572 CmdArgs.push_back("-dynamic-linker");
6573 CmdArgs.push_back("/libexec/ld.elf_so");
6574 }
6575 }
6576
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006577 // Many NetBSD architectures support more than one ABI.
6578 // Determine the correct emulation for ld.
6579 switch (getToolChain().getArch()) {
6580 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006581 CmdArgs.push_back("-m");
6582 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006583 break;
6584 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006585 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006586 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006587 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006588 CmdArgs.push_back("-m");
6589 switch (getToolChain().getTriple().getEnvironment()) {
6590 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006591 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006592 CmdArgs.push_back("armelf_nbsd_eabi");
6593 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006594 case llvm::Triple::EABIHF:
6595 case llvm::Triple::GNUEABIHF:
6596 CmdArgs.push_back("armelf_nbsd_eabihf");
6597 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006598 default:
6599 CmdArgs.push_back("armelf_nbsd");
6600 break;
6601 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006602 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006603 case llvm::Triple::mips64:
6604 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006605 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006606 CmdArgs.push_back("-m");
6607 if (getToolChain().getArch() == llvm::Triple::mips64)
6608 CmdArgs.push_back("elf32btsmip");
6609 else
6610 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006611 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006612 CmdArgs.push_back("-m");
6613 if (getToolChain().getArch() == llvm::Triple::mips64)
6614 CmdArgs.push_back("elf64btsmip");
6615 else
6616 CmdArgs.push_back("elf64ltsmip");
6617 }
6618 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006619
6620 case llvm::Triple::sparc:
6621 CmdArgs.push_back("-m");
6622 CmdArgs.push_back("elf32_sparc");
6623 break;
6624
6625 case llvm::Triple::sparcv9:
6626 CmdArgs.push_back("-m");
6627 CmdArgs.push_back("elf64_sparc");
6628 break;
6629
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006630 default:
6631 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006632 }
6633
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006634 if (Output.isFilename()) {
6635 CmdArgs.push_back("-o");
6636 CmdArgs.push_back(Output.getFilename());
6637 } else {
6638 assert(Output.isNothing() && "Invalid output.");
6639 }
6640
6641 if (!Args.hasArg(options::OPT_nostdlib) &&
6642 !Args.hasArg(options::OPT_nostartfiles)) {
6643 if (!Args.hasArg(options::OPT_shared)) {
6644 CmdArgs.push_back(Args.MakeArgString(
6645 getToolChain().GetFilePath("crt0.o")));
6646 CmdArgs.push_back(Args.MakeArgString(
6647 getToolChain().GetFilePath("crti.o")));
6648 CmdArgs.push_back(Args.MakeArgString(
6649 getToolChain().GetFilePath("crtbegin.o")));
6650 } else {
6651 CmdArgs.push_back(Args.MakeArgString(
6652 getToolChain().GetFilePath("crti.o")));
6653 CmdArgs.push_back(Args.MakeArgString(
6654 getToolChain().GetFilePath("crtbeginS.o")));
6655 }
6656 }
6657
6658 Args.AddAllArgs(CmdArgs, options::OPT_L);
6659 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6660 Args.AddAllArgs(CmdArgs, options::OPT_e);
6661 Args.AddAllArgs(CmdArgs, options::OPT_s);
6662 Args.AddAllArgs(CmdArgs, options::OPT_t);
6663 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6664 Args.AddAllArgs(CmdArgs, options::OPT_r);
6665
6666 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6667
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006668 unsigned Major, Minor, Micro;
6669 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6670 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006671 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006672 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006673 case llvm::Triple::arm:
6674 case llvm::Triple::armeb:
6675 case llvm::Triple::thumb:
6676 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006677 case llvm::Triple::x86:
6678 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006679 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006680 break;
6681 default:
6682 break;
6683 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006684 }
6685
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006686 if (!Args.hasArg(options::OPT_nostdlib) &&
6687 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006688 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006689 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6690 CmdArgs.push_back("-lm");
6691 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006692 if (Args.hasArg(options::OPT_pthread))
6693 CmdArgs.push_back("-lpthread");
6694 CmdArgs.push_back("-lc");
6695
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006696 if (useLibgcc) {
6697 if (Args.hasArg(options::OPT_static)) {
6698 // libgcc_eh depends on libc, so resolve as much as possible,
6699 // pull in any new requirements from libc and then get the rest
6700 // of libgcc.
6701 CmdArgs.push_back("-lgcc_eh");
6702 CmdArgs.push_back("-lc");
6703 CmdArgs.push_back("-lgcc");
6704 } else {
6705 CmdArgs.push_back("-lgcc");
6706 CmdArgs.push_back("--as-needed");
6707 CmdArgs.push_back("-lgcc_s");
6708 CmdArgs.push_back("--no-as-needed");
6709 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006710 }
6711 }
6712
6713 if (!Args.hasArg(options::OPT_nostdlib) &&
6714 !Args.hasArg(options::OPT_nostartfiles)) {
6715 if (!Args.hasArg(options::OPT_shared))
6716 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6717 "crtend.o")));
6718 else
6719 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6720 "crtendS.o")));
6721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6722 "crtn.o")));
6723 }
6724
Alexey Samsonov7811d192014-02-20 13:57:37 +00006725 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006726
Rafael Espindola236db462013-11-09 20:07:19 +00006727 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006728 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6729}
6730
Thomas Schwinge4e555262013-03-28 19:04:25 +00006731void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6732 const InputInfo &Output,
6733 const InputInfoList &Inputs,
6734 const ArgList &Args,
6735 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006736 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006737 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006738
6739 // Add --32/--64 to make sure we get the format we want.
6740 // This is incomplete
6741 if (getToolChain().getArch() == llvm::Triple::x86) {
6742 CmdArgs.push_back("--32");
6743 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6744 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006745 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6746 CmdArgs.push_back("-a32");
6747 CmdArgs.push_back("-mppc");
6748 CmdArgs.push_back("-many");
6749 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6750 CmdArgs.push_back("-a64");
6751 CmdArgs.push_back("-mppc64");
6752 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006753 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6754 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006755 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006756 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006757 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006758 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6759 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006760 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006761 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006762 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6763 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006764 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006765 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006766 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6767 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006768 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006769 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6770 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006771 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6772 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006773 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006774
Tim Northover9c7e0352013-12-12 11:55:52 +00006775 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6776 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006777 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006778
6779 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006780
6781 // FIXME: remove krait check when GNU tools support krait cpu
6782 // for now replace it with -march=armv7-a to avoid a lower
6783 // march from being picked in the absence of a cpu flag.
6784 Arg *A;
6785 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6786 StringRef(A->getValue()) == "krait")
6787 CmdArgs.push_back("-march=armv7-a");
6788 else
6789 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006790 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006791 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6792 getToolChain().getArch() == llvm::Triple::mipsel ||
6793 getToolChain().getArch() == llvm::Triple::mips64 ||
6794 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006795 StringRef CPUName;
6796 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006797 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006798
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006799 CmdArgs.push_back("-march");
6800 CmdArgs.push_back(CPUName.data());
6801
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006802 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006803 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006804
6805 if (getToolChain().getArch() == llvm::Triple::mips ||
6806 getToolChain().getArch() == llvm::Triple::mips64)
6807 CmdArgs.push_back("-EB");
6808 else
6809 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006810
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006811 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6812 if (StringRef(A->getValue()) == "2008")
6813 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6814 }
6815
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006816 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006817 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6818 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6819 options::OPT_mno_micromips);
6820 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6821 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6822
Simon Atanasyanbd986632013-11-26 11:58:04 +00006823 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6824 // Do not use AddLastArg because not all versions of MIPS assembler
6825 // support -mmsa / -mno-msa options.
6826 if (A->getOption().matches(options::OPT_mmsa))
6827 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6828 }
6829
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006830 NeedsKPIC = true;
6831 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6832 // Always pass an -march option, since our default of z10 is later
6833 // than the GNU assembler's default.
6834 StringRef CPUName = getSystemZTargetCPU(Args);
6835 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6836 }
6837
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006838 if (NeedsKPIC)
6839 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006840
6841 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6842 options::OPT_Xassembler);
6843
6844 CmdArgs.push_back("-o");
6845 CmdArgs.push_back(Output.getFilename());
6846
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006847 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00006848 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00006849
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006850 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Rafael Espindola92b00932010-08-10 00:25:48 +00006851 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006852
6853 // Handle the debug info splitting at object creation time if we're
6854 // creating an object.
6855 // TODO: Currently only works on linux with newer objcopy.
6856 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006857 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006858 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6859 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006860}
6861
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006862static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006863 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006864 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006865 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6866 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006867 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006868 CmdArgs.push_back("-lgcc");
6869
Logan Chien3d3373c2012-11-19 12:04:11 +00006870 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006871 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006872 CmdArgs.push_back("-lgcc");
6873 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006874 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006875 CmdArgs.push_back("--as-needed");
6876 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006877 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006878 CmdArgs.push_back("--no-as-needed");
6879 }
6880
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006881 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006882 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006883 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006884 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006885
6886 // According to Android ABI, we have to link with libdl if we are
6887 // linking with non-static libgcc.
6888 //
6889 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6890 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6891 if (isAndroid && !StaticLibgcc)
6892 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006893}
6894
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006895static StringRef getLinuxDynamicLinker(const ArgList &Args,
6896 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006897 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6898 if (ToolChain.getTriple().isArch64Bit())
6899 return "/system/bin/linker64";
6900 else
6901 return "/system/bin/linker";
6902 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6903 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006904 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00006905 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
6906 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006907 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00006908 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
6909 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00006910 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006911 else if (ToolChain.getArch() == llvm::Triple::arm ||
6912 ToolChain.getArch() == llvm::Triple::thumb) {
6913 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6914 return "/lib/ld-linux-armhf.so.3";
6915 else
6916 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006917 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
6918 ToolChain.getArch() == llvm::Triple::thumbeb) {
6919 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6920 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
6921 else
6922 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006923 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6924 ToolChain.getArch() == llvm::Triple::mipsel)
6925 return "/lib/ld.so.1";
6926 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6927 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006928 if (mips::hasMipsAbiArg(Args, "n32"))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006929 return "/lib32/ld.so.1";
6930 else
6931 return "/lib64/ld.so.1";
6932 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6933 return "/lib/ld.so.1";
6934 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6935 ToolChain.getArch() == llvm::Triple::systemz)
6936 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00006937 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
6938 return "/lib64/ld64.so.2";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00006939 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6940 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006941 else
6942 return "/lib64/ld-linux-x86-64.so.2";
6943}
6944
Renato Golinc4b49242014-02-13 10:01:16 +00006945static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
6946 ArgStringList &CmdArgs, const ArgList &Args) {
6947 // Make use of compiler-rt if --rtlib option is used
6948 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
6949
6950 switch(RLT) {
6951 case ToolChain::RLT_CompilerRT:
6952 addClangRTLinux(TC, Args, CmdArgs);
6953 break;
6954 case ToolChain::RLT_Libgcc:
6955 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
6956 break;
Renato Golinc4b49242014-02-13 10:01:16 +00006957 }
6958}
6959
Thomas Schwinge4e555262013-03-28 19:04:25 +00006960void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6961 const InputInfo &Output,
6962 const InputInfoList &Inputs,
6963 const ArgList &Args,
6964 const char *LinkingOutput) const {
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006965 const toolchains::Linux& ToolChain =
6966 static_cast<const toolchains::Linux&>(getToolChain());
6967 const Driver &D = ToolChain.getDriver();
Rafael Espindola7df35012012-11-02 20:41:30 +00006968 const bool isAndroid =
6969 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006970 const bool IsPIE =
6971 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00006972 !Args.hasArg(options::OPT_static) &&
6973 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
6974 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00006975 // Cannot use isPIEDefault here since otherwise
6976 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00006977 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006978
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006979 ArgStringList CmdArgs;
6980
Rafael Espindolad1002f62010-11-15 18:28:16 +00006981 // Silence warning for "clang -g foo.o -o foo"
6982 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006983 // and "clang -emit-llvm foo.o -o foo"
6984 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00006985 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00006986 // handled somewhere else.
6987 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00006988
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006989 if (!D.SysRoot.empty())
6990 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00006991
Peter Collingbourne54d770c2013-04-09 04:35:11 +00006992 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00006993 CmdArgs.push_back("-pie");
6994
Rafael Espindola1c76c592010-11-07 22:57:16 +00006995 if (Args.hasArg(options::OPT_rdynamic))
6996 CmdArgs.push_back("-export-dynamic");
6997
Rafael Espindola34d77dc2010-11-11 19:34:42 +00006998 if (Args.hasArg(options::OPT_s))
6999 CmdArgs.push_back("-s");
7000
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007001 for (const auto &Opt : ToolChain.ExtraOpts)
7002 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007003
7004 if (!Args.hasArg(options::OPT_static)) {
7005 CmdArgs.push_back("--eh-frame-hdr");
7006 }
7007
7008 CmdArgs.push_back("-m");
7009 if (ToolChain.getArch() == llvm::Triple::x86)
7010 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007011 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7012 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007013 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007014 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7015 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007016 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007017 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007018 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007019 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007020 else if (ToolChain.getArch() == llvm::Triple::armeb
7021 || ToolChain.getArch() == llvm::Triple::thumbeb)
7022 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007023 else if (ToolChain.getArch() == llvm::Triple::ppc)
7024 CmdArgs.push_back("elf32ppclinux");
7025 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7026 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007027 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7028 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007029 else if (ToolChain.getArch() == llvm::Triple::sparc)
7030 CmdArgs.push_back("elf32_sparc");
7031 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7032 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007033 else if (ToolChain.getArch() == llvm::Triple::mips)
7034 CmdArgs.push_back("elf32btsmip");
7035 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7036 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007037 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007038 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007039 CmdArgs.push_back("elf32btsmipn32");
7040 else
7041 CmdArgs.push_back("elf64btsmip");
7042 }
7043 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007044 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007045 CmdArgs.push_back("elf32ltsmipn32");
7046 else
7047 CmdArgs.push_back("elf64ltsmip");
7048 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007049 else if (ToolChain.getArch() == llvm::Triple::systemz)
7050 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007051 else
7052 CmdArgs.push_back("elf_x86_64");
7053
7054 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007055 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007056 ToolChain.getArch() == llvm::Triple::armeb ||
7057 ToolChain.getArch() == llvm::Triple::thumb ||
7058 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007059 CmdArgs.push_back("-Bstatic");
7060 else
7061 CmdArgs.push_back("-static");
7062 } else if (Args.hasArg(options::OPT_shared)) {
7063 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00007064 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007065 CmdArgs.push_back("-Bsymbolic");
7066 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007067 }
7068
7069 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007070 ToolChain.getArch() == llvm::Triple::armeb ||
Douglas Gregord9bb1522011-03-06 19:11:49 +00007071 ToolChain.getArch() == llvm::Triple::thumb ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007072 ToolChain.getArch() == llvm::Triple::thumbeb ||
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007073 (!Args.hasArg(options::OPT_static) &&
7074 !Args.hasArg(options::OPT_shared))) {
7075 CmdArgs.push_back("-dynamic-linker");
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007076 CmdArgs.push_back(Args.MakeArgString(
7077 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007078 }
7079
7080 CmdArgs.push_back("-o");
7081 CmdArgs.push_back(Output.getFilename());
7082
Rafael Espindola81937ec2010-12-01 01:52:43 +00007083 if (!Args.hasArg(options::OPT_nostdlib) &&
7084 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007085 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007086 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007087 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007088 if (Args.hasArg(options::OPT_pg))
7089 crt1 = "gcrt1.o";
7090 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007091 crt1 = "Scrt1.o";
7092 else
7093 crt1 = "crt1.o";
7094 }
7095 if (crt1)
7096 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007097
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007098 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7099 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007100
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007101 const char *crtbegin;
7102 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007103 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007104 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007105 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007106 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007107 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007108 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007109 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007110 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007111
7112 // Add crtfastmath.o if available and fast math is enabled.
7113 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007114 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007115
7116 Args.AddAllArgs(CmdArgs, options::OPT_L);
7117
7118 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7119
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007120 for (const auto &Path : Paths)
7121 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007122
Alp Tokerce365ca2013-12-02 12:43:03 +00007123 if (D.IsUsingLTO(Args))
7124 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007125
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007126 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7127 CmdArgs.push_back("--no-demangle");
7128
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007129 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7130
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007131 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007132 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007133 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007134
Hans Wennborg70850d82013-07-18 20:29:38 +00007135 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007136 !Args.hasArg(options::OPT_nostdlib) &&
7137 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007138 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7139 !Args.hasArg(options::OPT_static);
7140 if (OnlyLibstdcxxStatic)
7141 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007142 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007143 if (OnlyLibstdcxxStatic)
7144 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007145 CmdArgs.push_back("-lm");
7146 }
7147
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007148 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007149 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7150 if (Args.hasArg(options::OPT_static))
7151 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007152
Alexey Bataev186b28a2014-03-06 05:43:53 +00007153 LibOpenMP UsedOpenMPLib = LibUnknown;
7154 if (Args.hasArg(options::OPT_fopenmp)) {
7155 UsedOpenMPLib = LibGOMP;
7156 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7157 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7158 .Case("libgomp", LibGOMP)
7159 .Case("libiomp5", LibIOMP5)
7160 .Default(LibUnknown);
7161 if (UsedOpenMPLib == LibUnknown)
7162 D.Diag(diag::err_drv_unsupported_option_argument)
7163 << A->getOption().getName() << A->getValue();
7164 }
7165 switch (UsedOpenMPLib) {
7166 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007167 CmdArgs.push_back("-lgomp");
7168
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007169 // FIXME: Exclude this for platforms with libgomp that don't require
7170 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007171 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007172 break;
7173 case LibIOMP5:
7174 CmdArgs.push_back("-liomp5");
7175 break;
7176 case LibUnknown:
7177 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007178 }
Renato Golinc4b49242014-02-13 10:01:16 +00007179 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007180
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007181 if ((Args.hasArg(options::OPT_pthread) ||
7182 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7183 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007184 CmdArgs.push_back("-lpthread");
7185
7186 CmdArgs.push_back("-lc");
7187
7188 if (Args.hasArg(options::OPT_static))
7189 CmdArgs.push_back("--end-group");
7190 else
Renato Golinc4b49242014-02-13 10:01:16 +00007191 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007192 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007193
Rafael Espindola81937ec2010-12-01 01:52:43 +00007194 if (!Args.hasArg(options::OPT_nostartfiles)) {
7195 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007196 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007197 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007198 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007199 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007200 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007201 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007202
Rafael Espindola81937ec2010-12-01 01:52:43 +00007203 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007204 if (!isAndroid)
7205 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007206 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007207 }
7208
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007209 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
7210}
Rafael Espindola92b00932010-08-10 00:25:48 +00007211
Chris Lattner3e2ee142010-07-07 16:01:42 +00007212void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007213 const InputInfo &Output,
7214 const InputInfoList &Inputs,
7215 const ArgList &Args,
7216 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007217 ArgStringList CmdArgs;
7218
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007219 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007220
7221 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007222 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007223
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007224 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007225 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007226
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007227 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007228 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007229}
7230
7231void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007232 const InputInfo &Output,
7233 const InputInfoList &Inputs,
7234 const ArgList &Args,
7235 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007236 const Driver &D = getToolChain().getDriver();
7237 ArgStringList CmdArgs;
7238
Daniel Dunbarb440f562010-08-02 02:38:21 +00007239 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007240 CmdArgs.push_back("-o");
7241 CmdArgs.push_back(Output.getFilename());
7242 } else {
7243 assert(Output.isNothing() && "Invalid output.");
7244 }
7245
7246 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007247 !Args.hasArg(options::OPT_nostartfiles)) {
7248 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7249 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7250 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7251 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7252 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007253
7254 Args.AddAllArgs(CmdArgs, options::OPT_L);
7255 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7256 Args.AddAllArgs(CmdArgs, options::OPT_e);
7257
Daniel Dunbar54423b22010-09-17 00:24:54 +00007258 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007259
Alexey Samsonov7811d192014-02-20 13:57:37 +00007260 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007261
Chris Lattner3e2ee142010-07-07 16:01:42 +00007262 if (!Args.hasArg(options::OPT_nostdlib) &&
7263 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007264 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007265 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007266 CmdArgs.push_back("-lm");
7267 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007268 }
7269
7270 if (!Args.hasArg(options::OPT_nostdlib) &&
7271 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007272 if (Args.hasArg(options::OPT_pthread))
7273 CmdArgs.push_back("-lpthread");
7274 CmdArgs.push_back("-lc");
7275 CmdArgs.push_back("-lCompilerRT-Generic");
7276 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7277 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007278 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007279 }
7280
Rafael Espindola236db462013-11-09 20:07:19 +00007281 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007282 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007283}
7284
Daniel Dunbarcc912342009-05-02 18:28:39 +00007285/// DragonFly Tools
7286
7287// For now, DragonFly Assemble does just about the same as for
7288// FreeBSD, but this may change soon.
7289void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007290 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007291 const InputInfoList &Inputs,
7292 const ArgList &Args,
7293 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007294 ArgStringList CmdArgs;
7295
7296 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7297 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007298 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007299 CmdArgs.push_back("--32");
7300
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007301 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007302
7303 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007304 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007305
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007306 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007307 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007308
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007309 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007310 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007311}
7312
7313void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007314 const InputInfo &Output,
7315 const InputInfoList &Inputs,
7316 const ArgList &Args,
7317 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007318 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007319 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007320 ArgStringList CmdArgs;
7321
John McCall65b8da02013-04-11 22:55:55 +00007322 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7323 UseGCC47 = false;
7324
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007325 if (!D.SysRoot.empty())
7326 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7327
John McCall65b8da02013-04-11 22:55:55 +00007328 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007329 if (Args.hasArg(options::OPT_static)) {
7330 CmdArgs.push_back("-Bstatic");
7331 } else {
John McCall65b8da02013-04-11 22:55:55 +00007332 if (Args.hasArg(options::OPT_rdynamic))
7333 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007334 if (Args.hasArg(options::OPT_shared))
7335 CmdArgs.push_back("-Bshareable");
7336 else {
7337 CmdArgs.push_back("-dynamic-linker");
7338 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7339 }
John McCall65b8da02013-04-11 22:55:55 +00007340 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007341 }
7342
7343 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7344 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007345 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007346 CmdArgs.push_back("-m");
7347 CmdArgs.push_back("elf_i386");
7348 }
7349
Daniel Dunbarb440f562010-08-02 02:38:21 +00007350 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007351 CmdArgs.push_back("-o");
7352 CmdArgs.push_back(Output.getFilename());
7353 } else {
7354 assert(Output.isNothing() && "Invalid output.");
7355 }
7356
7357 if (!Args.hasArg(options::OPT_nostdlib) &&
7358 !Args.hasArg(options::OPT_nostartfiles)) {
7359 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007360 if (Args.hasArg(options::OPT_pg))
7361 CmdArgs.push_back(Args.MakeArgString(
7362 getToolChain().GetFilePath("gcrt1.o")));
7363 else {
7364 if (Args.hasArg(options::OPT_pie))
7365 CmdArgs.push_back(Args.MakeArgString(
7366 getToolChain().GetFilePath("Scrt1.o")));
7367 else
7368 CmdArgs.push_back(Args.MakeArgString(
7369 getToolChain().GetFilePath("crt1.o")));
7370 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007371 }
John McCall65b8da02013-04-11 22:55:55 +00007372 CmdArgs.push_back(Args.MakeArgString(
7373 getToolChain().GetFilePath("crti.o")));
7374 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7375 CmdArgs.push_back(Args.MakeArgString(
7376 getToolChain().GetFilePath("crtbeginS.o")));
7377 else
7378 CmdArgs.push_back(Args.MakeArgString(
7379 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007380 }
7381
7382 Args.AddAllArgs(CmdArgs, options::OPT_L);
7383 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7384 Args.AddAllArgs(CmdArgs, options::OPT_e);
7385
Daniel Dunbar54423b22010-09-17 00:24:54 +00007386 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007387
7388 if (!Args.hasArg(options::OPT_nostdlib) &&
7389 !Args.hasArg(options::OPT_nodefaultlibs)) {
7390 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7391 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007392 if (UseGCC47)
7393 CmdArgs.push_back("-L/usr/lib/gcc47");
7394 else
7395 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007396
7397 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007398 if (UseGCC47) {
7399 CmdArgs.push_back("-rpath");
7400 CmdArgs.push_back("/usr/lib/gcc47");
7401 } else {
7402 CmdArgs.push_back("-rpath");
7403 CmdArgs.push_back("/usr/lib/gcc44");
7404 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007405 }
7406
Hans Wennborg70850d82013-07-18 20:29:38 +00007407 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007408 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007409 CmdArgs.push_back("-lm");
7410 }
7411
Daniel Dunbarcc912342009-05-02 18:28:39 +00007412 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007413 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007414
7415 if (!Args.hasArg(options::OPT_nolibc)) {
7416 CmdArgs.push_back("-lc");
7417 }
7418
John McCall65b8da02013-04-11 22:55:55 +00007419 if (UseGCC47) {
7420 if (Args.hasArg(options::OPT_static) ||
7421 Args.hasArg(options::OPT_static_libgcc)) {
7422 CmdArgs.push_back("-lgcc");
7423 CmdArgs.push_back("-lgcc_eh");
7424 } else {
7425 if (Args.hasArg(options::OPT_shared_libgcc)) {
7426 CmdArgs.push_back("-lgcc_pic");
7427 if (!Args.hasArg(options::OPT_shared))
7428 CmdArgs.push_back("-lgcc");
7429 } else {
7430 CmdArgs.push_back("-lgcc");
7431 CmdArgs.push_back("--as-needed");
7432 CmdArgs.push_back("-lgcc_pic");
7433 CmdArgs.push_back("--no-as-needed");
7434 }
7435 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007436 } else {
John McCall65b8da02013-04-11 22:55:55 +00007437 if (Args.hasArg(options::OPT_shared)) {
7438 CmdArgs.push_back("-lgcc_pic");
7439 } else {
7440 CmdArgs.push_back("-lgcc");
7441 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007442 }
7443 }
7444
7445 if (!Args.hasArg(options::OPT_nostdlib) &&
7446 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007447 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007448 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007449 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007450 else
7451 CmdArgs.push_back(Args.MakeArgString(
7452 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007453 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007454 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007455 }
7456
Alexey Samsonov7811d192014-02-20 13:57:37 +00007457 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007458
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007459 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007460 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007461}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007462
Alexey Samsonov6424e022014-05-12 20:20:20 +00007463static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7464 ArgStringList &CmdArgs,
7465 const StringRef RTName) {
7466 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7467 llvm::sys::path::append(LibSanitizer,
7468 Twine("clang_rt.") + RTName + ".lib");
7469 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7470}
7471
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007472void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7473 const InputInfo &Output,
7474 const InputInfoList &Inputs,
7475 const ArgList &Args,
7476 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007477 ArgStringList CmdArgs;
7478
7479 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007480 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7481 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007482 } else {
7483 assert(Output.isNothing() && "Invalid output.");
7484 }
7485
7486 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007487 !Args.hasArg(options::OPT_nostartfiles) &&
7488 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007489 CmdArgs.push_back("-defaultlib:libcmt");
7490 }
7491
7492 CmdArgs.push_back("-nologo");
7493
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007494 if (Args.hasArg(options::OPT_g_Group)) {
7495 CmdArgs.push_back("-debug");
7496 }
7497
Hans Wennborgf1a74252013-09-10 20:18:04 +00007498 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7499
7500 if (DLL) {
7501 CmdArgs.push_back(Args.MakeArgString("-dll"));
7502
7503 SmallString<128> ImplibName(Output.getFilename());
7504 llvm::sys::path::replace_extension(ImplibName, "lib");
7505 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7506 ImplibName.str()));
7507 }
7508
Peter Collingbourne32701642013-11-01 18:16:25 +00007509 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007510 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007511 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007512 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007513 if (DLL) {
7514 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7515 "asan_dll_thunk-i386");
7516 } else {
7517 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7518 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7519 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007520 }
7521
Michael J. Spencere2f49362012-06-18 16:56:04 +00007522 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007523 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007524
7525 // Add filenames immediately.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007526 for (const auto &Input : Inputs)
7527 if (Input.isFilename())
7528 CmdArgs.push_back(Input.getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007529 else
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007530 Input.getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007531
7532 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007533 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007534 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7535}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007536
7537void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7538 const InputInfo &Output,
7539 const InputInfoList &Inputs,
7540 const ArgList &Args,
7541 const char *LinkingOutput) const {
7542 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7543}
7544
Hans Wennborg188382e2013-09-20 18:16:35 +00007545// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7546// If one cannot be found, return FallbackName.
7547// We do this special search to prevent clang-cl from falling back onto itself
7548// if it's available as cl.exe on the path.
7549static std::string FindFallback(const char *FallbackName,
7550 const char *ClangProgramPath) {
7551 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7552 if (!OptPath.hasValue())
7553 return FallbackName;
7554
7555#ifdef LLVM_ON_WIN32
7556 const StringRef PathSeparators = ";";
7557#else
7558 const StringRef PathSeparators = ":";
7559#endif
7560
7561 SmallVector<StringRef, 8> PathSegments;
7562 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7563
7564 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7565 const StringRef &PathSegment = PathSegments[i];
7566 if (PathSegment.empty())
7567 continue;
7568
7569 SmallString<128> FilePath(PathSegment);
7570 llvm::sys::path::append(FilePath, FallbackName);
7571 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7572 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7573 return FilePath.str();
7574 }
7575
7576 return FallbackName;
7577}
7578
Hans Wennborg87cfa712013-09-19 20:32:16 +00007579Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7580 const InputInfo &Output,
7581 const InputInfoList &Inputs,
7582 const ArgList &Args,
7583 const char *LinkingOutput) const {
7584 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007585 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007586 CmdArgs.push_back("/c"); // Compile only.
7587 CmdArgs.push_back("/W0"); // No warnings.
7588
7589 // The goal is to be able to invoke this tool correctly based on
7590 // any flag accepted by clang-cl.
7591
7592 // These are spelled the same way in clang and cl.exe,.
7593 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7594 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007595
7596 // Optimization level.
7597 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7598 if (A->getOption().getID() == options::OPT_O0) {
7599 CmdArgs.push_back("/Od");
7600 } else {
7601 StringRef OptLevel = A->getValue();
7602 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7603 A->render(Args, CmdArgs);
7604 else if (OptLevel == "3")
7605 CmdArgs.push_back("/Ox");
7606 }
7607 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007608
7609 // Flags for which clang-cl have an alias.
7610 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7611
7612 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7613 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7614 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007615 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7616 options::OPT_fno_function_sections))
7617 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7618 ? "/Gy"
7619 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007620 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7621 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007622 CmdArgs.push_back(
7623 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007624 if (Args.hasArg(options::OPT_fsyntax_only))
7625 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007626 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7627 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007628
Hans Wennborg260ff402013-09-27 17:54:18 +00007629 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007630 for (const auto &Include : Includes)
7631 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007632
Hans Wennborg87cfa712013-09-19 20:32:16 +00007633 // Flags that can simply be passed through.
7634 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7635 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7636
7637 // The order of these flags is relevant, so pick the last one.
7638 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7639 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7640 A->render(Args, CmdArgs);
7641
7642
7643 // Input filename.
7644 assert(Inputs.size() == 1);
7645 const InputInfo &II = Inputs[0];
7646 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7647 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7648 if (II.isFilename())
7649 CmdArgs.push_back(II.getFilename());
7650 else
7651 II.getInputArg().renderAsInput(Args, CmdArgs);
7652
7653 // Output filename.
7654 assert(Output.getType() == types::TY_Object);
7655 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7656 Output.getFilename());
7657 CmdArgs.push_back(Fo);
7658
Hans Wennborg188382e2013-09-20 18:16:35 +00007659 const Driver &D = getToolChain().getDriver();
7660 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg188382e2013-09-20 18:16:35 +00007661 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007662}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007663
7664
7665/// XCore Tools
7666// We pass assemble and link construction to the xcc tool.
7667
7668void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7669 const InputInfo &Output,
7670 const InputInfoList &Inputs,
7671 const ArgList &Args,
7672 const char *LinkingOutput) const {
7673 ArgStringList CmdArgs;
7674
7675 CmdArgs.push_back("-o");
7676 CmdArgs.push_back(Output.getFilename());
7677
7678 CmdArgs.push_back("-c");
7679
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007680 if (Args.hasArg(options::OPT_v))
7681 CmdArgs.push_back("-v");
7682
Robert Lytton894d25c2014-05-02 09:33:25 +00007683 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7684 if (!A->getOption().matches(options::OPT_g0))
7685 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007686
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007687 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7688 false))
7689 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007690
7691 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7692 options::OPT_Xassembler);
7693
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007694 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007695 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007696
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007697 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007698 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7699}
7700
7701void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7702 const InputInfo &Output,
7703 const InputInfoList &Inputs,
7704 const ArgList &Args,
7705 const char *LinkingOutput) const {
7706 ArgStringList CmdArgs;
7707
7708 if (Output.isFilename()) {
7709 CmdArgs.push_back("-o");
7710 CmdArgs.push_back(Output.getFilename());
7711 } else {
7712 assert(Output.isNothing() && "Invalid output.");
7713 }
7714
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007715 if (Args.hasArg(options::OPT_v))
7716 CmdArgs.push_back("-v");
7717
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007718 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7719 if (EH.ShouldUseExceptionTables)
7720 CmdArgs.push_back("-fexceptions");
7721
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007722 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7723
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007724 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007725 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7726}