blob: 3587bbb2f5fafad1f2cf147ee8ed66d4cfe51657 [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")
Will Schmidtf0487512014-06-26 13:34:10 +00001159 .Case("power8", "pwr8")
Bill Schmidt38378a02013-02-01 20:23:10 +00001160 .Case("pwr3", "pwr3")
1161 .Case("pwr4", "pwr4")
1162 .Case("pwr5", "pwr5")
1163 .Case("pwr5x", "pwr5x")
1164 .Case("pwr6", "pwr6")
1165 .Case("pwr6x", "pwr6x")
1166 .Case("pwr7", "pwr7")
Will Schmidtf0487512014-06-26 13:34:10 +00001167 .Case("pwr8", "pwr8")
Hal Finkel8eb59282012-06-11 22:35:19 +00001168 .Case("powerpc", "ppc")
1169 .Case("powerpc64", "ppc64")
Bill Schmidt778d3872013-07-26 01:36:11 +00001170 .Case("powerpc64le", "ppc64le")
Hal Finkel8eb59282012-06-11 22:35:19 +00001171 .Default("");
1172 }
1173
1174 return "";
1175}
1176
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001177static void getPPCTargetFeatures(const ArgList &Args,
1178 std::vector<const char *> &Features) {
Eric Christopher643bb6a2013-10-16 20:40:08 +00001179 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1180 ie = Args.filtered_end();
1181 it != ie; ++it) {
1182 StringRef Name = (*it)->getOption().getName();
1183 (*it)->claim();
1184
1185 // Skip over "-m".
1186 assert(Name.startswith("m") && "Invalid feature name.");
1187 Name = Name.substr(1);
1188
1189 bool IsNegative = Name.startswith("no-");
1190 if (IsNegative)
1191 Name = Name.substr(3);
1192
1193 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1194 // pass the correct option to the backend while calling the frontend
1195 // option the same.
1196 // TODO: Change the LLVM backend option maybe?
1197 if (Name == "mfcrf")
1198 Name = "mfocrf";
1199
1200 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1201 }
1202
1203 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001204 AddTargetFeature(Args, Features, options::OPT_faltivec,
1205 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001206}
1207
Tom Stellard6674c702013-04-01 20:56:53 +00001208/// Get the (LLVM) name of the R600 gpu we are targeting.
1209static std::string getR600TargetGPU(const ArgList &Args) {
1210 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001211 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001212 return llvm::StringSwitch<const char *>(GPUName)
Tom Stellardb38600c2013-05-06 16:12:05 +00001213 .Cases("rv630", "rv635", "r600")
1214 .Cases("rv610", "rv620", "rs780", "rs880")
Tom Stellard6674c702013-04-01 20:56:53 +00001215 .Case("rv740", "rv770")
1216 .Case("palm", "cedar")
Tom Stellardb38600c2013-05-06 16:12:05 +00001217 .Cases("sumo", "sumo2", "sumo")
Tom Stellard6674c702013-04-01 20:56:53 +00001218 .Case("hemlock", "cypress")
1219 .Case("aruba", "cayman")
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001220 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001221 }
1222 return "";
1223}
1224
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001225static void getSparcTargetFeatures(const ArgList &Args,
1226 std::vector<const char *> Features) {
1227 bool SoftFloatABI = true;
1228 if (Arg *A =
1229 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1230 if (A->getOption().matches(options::OPT_mhard_float))
1231 SoftFloatABI = false;
1232 }
1233 if (SoftFloatABI)
1234 Features.push_back("+soft-float");
1235}
1236
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001237void Clang::AddSparcTargetArgs(const ArgList &Args,
1238 ArgStringList &CmdArgs) const {
1239 const Driver &D = getToolChain().getDriver();
1240
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001241 // Select the float ABI as determined by -msoft-float, -mhard-float, and
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001242 StringRef FloatABI;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001243 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1244 options::OPT_mhard_float)) {
1245 if (A->getOption().matches(options::OPT_msoft_float))
1246 FloatABI = "soft";
1247 else if (A->getOption().matches(options::OPT_mhard_float))
1248 FloatABI = "hard";
1249 }
1250
1251 // If unspecified, choose the default based on the platform.
1252 if (FloatABI.empty()) {
Aaron Ballmand0d27ab2013-07-15 13:41:33 +00001253 // Assume "soft", but warn the user we are guessing.
1254 FloatABI = "soft";
1255 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001256 }
1257
1258 if (FloatABI == "soft") {
1259 // Floating point operations and argument passing are soft.
1260 //
1261 // FIXME: This changes CPP defines, we need -target-soft-float.
1262 CmdArgs.push_back("-msoft-float");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001263 } else {
1264 assert(FloatABI == "hard" && "Invalid float abi!");
1265 CmdArgs.push_back("-mhard-float");
1266 }
1267}
1268
Richard Sandiford4652d892013-07-19 16:51:51 +00001269static const char *getSystemZTargetCPU(const ArgList &Args) {
1270 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1271 return A->getValue();
1272 return "z10";
1273}
1274
Chandler Carruth953fb082013-01-13 11:46:33 +00001275static const char *getX86TargetCPU(const ArgList &Args,
1276 const llvm::Triple &Triple) {
1277 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001278 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001279 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001280 return "core-avx2";
1281
Chandler Carruth953fb082013-01-13 11:46:33 +00001282 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001283 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001284
1285 // FIXME: Reject attempts to use -march=native unless the target matches
1286 // the host.
1287 //
1288 // FIXME: We should also incorporate the detected target features for use
1289 // with -native.
1290 std::string CPU = llvm::sys::getHostCPUName();
1291 if (!CPU.empty() && CPU != "generic")
1292 return Args.MakeArgString(CPU);
1293 }
1294
1295 // Select the default CPU if none was given (or detection failed).
1296
1297 if (Triple.getArch() != llvm::Triple::x86_64 &&
1298 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001299 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001300
1301 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1302
1303 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001304 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001305 if (Triple.getArchName() == "x86_64h")
1306 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001307 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001308 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001309
Alexey Bataev286d1b92014-01-31 04:07:13 +00001310 // On Android use targets compatible with gcc
Chandler Carruth953fb082013-01-13 11:46:33 +00001311 if (Triple.getEnvironment() == llvm::Triple::Android)
Alexey Bataev286d1b92014-01-31 04:07:13 +00001312 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001313
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001314 // Everything else goes to x86-64 in 64-bit mode.
1315 if (Is64Bit)
1316 return "x86-64";
1317
1318 switch (Triple.getOS()) {
1319 case llvm::Triple::FreeBSD:
1320 case llvm::Triple::NetBSD:
1321 case llvm::Triple::OpenBSD:
1322 return "i486";
1323 case llvm::Triple::Haiku:
1324 return "i586";
1325 case llvm::Triple::Bitrig:
1326 return "i686";
1327 default:
1328 // Fallback to p4.
1329 return "pentium4";
1330 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001331}
1332
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001333static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1334 switch(T.getArch()) {
1335 default:
1336 return "";
1337
Amara Emerson703da2e2013-10-31 09:32:33 +00001338 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001339 case llvm::Triple::aarch64_be:
Quentin Colombetd9f26202014-04-15 00:27:35 +00001340 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00001341 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001342 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001343
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001344 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001345 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001346 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001347 case llvm::Triple::thumbeb:
Bernard Ogden31561762013-12-12 13:27:11 +00001348 return arm::getARMTargetCPU(Args, T);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001349
1350 case llvm::Triple::mips:
1351 case llvm::Triple::mipsel:
1352 case llvm::Triple::mips64:
1353 case llvm::Triple::mips64el: {
1354 StringRef CPUName;
1355 StringRef ABIName;
1356 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1357 return CPUName;
1358 }
1359
1360 case llvm::Triple::ppc:
1361 case llvm::Triple::ppc64:
1362 case llvm::Triple::ppc64le: {
1363 std::string TargetCPUName = getPPCTargetCPU(Args);
1364 // LLVM may default to generating code for the native CPU,
1365 // but, like gcc, we default to a more generic option for
1366 // each architecture. (except on Darwin)
1367 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1368 if (T.getArch() == llvm::Triple::ppc64)
1369 TargetCPUName = "ppc64";
1370 else if (T.getArch() == llvm::Triple::ppc64le)
1371 TargetCPUName = "ppc64le";
1372 else
1373 TargetCPUName = "ppc";
1374 }
1375 return TargetCPUName;
1376 }
1377
1378 case llvm::Triple::sparc:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001379 case llvm::Triple::sparcv9:
1380 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001381 return A->getValue();
1382 return "";
1383
1384 case llvm::Triple::x86:
1385 case llvm::Triple::x86_64:
1386 return getX86TargetCPU(Args, T);
1387
1388 case llvm::Triple::hexagon:
1389 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1390
1391 case llvm::Triple::systemz:
1392 return getSystemZTargetCPU(Args);
1393
1394 case llvm::Triple::r600:
1395 return getR600TargetGPU(Args);
1396 }
1397}
1398
Alp Tokerce365ca2013-12-02 12:43:03 +00001399static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1400 ArgStringList &CmdArgs) {
1401 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1402 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1403 // forward.
1404 CmdArgs.push_back("-plugin");
1405 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
1406 CmdArgs.push_back(Args.MakeArgString(Plugin));
1407
1408 // Try to pass driver level flags relevant to LTO code generation down to
1409 // the plugin.
1410
1411 // Handle flags for selecting CPU variants.
1412 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1413 if (!CPU.empty())
1414 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1415}
1416
Jim Grosbach82eee262013-11-16 00:53:35 +00001417static void getX86TargetFeatures(const llvm::Triple &Triple,
1418 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001419 std::vector<const char *> &Features) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001420 if (Triple.getArchName() == "x86_64h") {
1421 // x86_64h implies quite a few of the more modern subtarget features
1422 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1423 Features.push_back("-rdrnd");
1424 Features.push_back("-aes");
1425 Features.push_back("-pclmul");
1426 Features.push_back("-rtm");
1427 Features.push_back("-hle");
1428 Features.push_back("-fsgsbase");
1429 }
1430
Alexey Volkov54ff0802014-06-25 12:15:36 +00001431 // Add features to comply with gcc on Android
Alexey Bataev286d1b92014-01-31 04:07:13 +00001432 if (Triple.getEnvironment() == llvm::Triple::Android) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001433 if (Triple.getArch() == llvm::Triple::x86_64) {
1434 Features.push_back("+sse4.2");
1435 Features.push_back("+popcnt");
1436 } else
1437 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001438 }
1439
Jim Grosbach82eee262013-11-16 00:53:35 +00001440 // Now add any that the user explicitly requested on the command line,
1441 // which may override the defaults.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001442 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1443 ie = Args.filtered_end();
1444 it != ie; ++it) {
1445 StringRef Name = (*it)->getOption().getName();
1446 (*it)->claim();
1447
1448 // Skip over "-m".
1449 assert(Name.startswith("m") && "Invalid feature name.");
1450 Name = Name.substr(1);
1451
1452 bool IsNegative = Name.startswith("no-");
1453 if (IsNegative)
1454 Name = Name.substr(3);
1455
1456 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1457 }
1458}
1459
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001460void Clang::AddX86TargetArgs(const ArgList &Args,
1461 ArgStringList &CmdArgs) const {
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001462 if (!Args.hasFlag(options::OPT_mred_zone,
1463 options::OPT_mno_red_zone,
1464 true) ||
1465 Args.hasArg(options::OPT_mkernel) ||
1466 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001467 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001468
Bob Wilson2616e2e2013-02-10 16:01:41 +00001469 // Default to avoid implicit floating-point for kernel/kext code, but allow
1470 // that to be overridden with -mno-soft-float.
1471 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1472 Args.hasArg(options::OPT_fapple_kext));
1473 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1474 options::OPT_mno_soft_float,
Bob Wilson9c8af452013-04-11 18:53:25 +00001475 options::OPT_mimplicit_float,
Bob Wilson2616e2e2013-02-10 16:01:41 +00001476 options::OPT_mno_implicit_float)) {
1477 const Option &O = A->getOption();
1478 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1479 O.matches(options::OPT_msoft_float));
1480 }
1481 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001482 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001483
1484 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1485 StringRef Value = A->getValue();
1486 if (Value == "intel" || Value == "att") {
1487 CmdArgs.push_back("-mllvm");
1488 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1489 } else {
1490 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1491 << A->getOption().getName() << Value;
1492 }
1493 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001494}
1495
Matthew Curtise8f80a12012-12-06 17:49:03 +00001496static inline bool HasPICArg(const ArgList &Args) {
1497 return Args.hasArg(options::OPT_fPIC)
1498 || Args.hasArg(options::OPT_fpic);
1499}
1500
1501static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1502 return Args.getLastArg(options::OPT_G,
1503 options::OPT_G_EQ,
1504 options::OPT_msmall_data_threshold_EQ);
1505}
1506
1507static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1508 std::string value;
1509 if (HasPICArg(Args))
1510 value = "0";
1511 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1512 value = A->getValue();
1513 A->claim();
1514 }
1515 return value;
1516}
1517
Tony Linthicum76329bf2011-12-12 21:14:55 +00001518void Clang::AddHexagonTargetArgs(const ArgList &Args,
1519 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001520 CmdArgs.push_back("-fno-signed-char");
Matthew Curtis6b222782012-12-07 13:52:44 +00001521 CmdArgs.push_back("-mqdsp6-compat");
1522 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001523
Matthew Curtise8f80a12012-12-06 17:49:03 +00001524 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1525 if (!SmallDataThreshold.empty()) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00001526 CmdArgs.push_back ("-mllvm");
Matthew Curtise8f80a12012-12-06 17:49:03 +00001527 CmdArgs.push_back(Args.MakeArgString(
1528 "-hexagon-small-data-threshold=" + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001529 }
1530
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001531 if (!Args.hasArg(options::OPT_fno_short_enums))
1532 CmdArgs.push_back("-fshort-enums");
1533 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1534 CmdArgs.push_back ("-mllvm");
1535 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1536 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00001537 CmdArgs.push_back ("-mllvm");
1538 CmdArgs.push_back ("-machine-sink-split=0");
1539}
1540
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001541static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1542 std::vector<const char *> &Features) {
Tim Northover2fe823a2013-08-01 09:23:19 +00001543 // Honor -mfpu=.
1544 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
Amara Emerson4cdb87b2013-10-01 10:20:54 +00001545 getAArch64FPUFeatures(D, A, Args, Features);
Jiangning Liub19c5b62014-02-14 04:37:46 +00001546 else
1547 Features.push_back("+neon");
Amara Emerson04e2ecf2014-01-23 15:48:30 +00001548
1549 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1550 Features.push_back("-fp-armv8");
1551 Features.push_back("-crypto");
1552 Features.push_back("-neon");
1553 }
Bradley Smith418c5932014-05-02 15:17:51 +00001554
1555 // En/disable crc
1556 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1557 options::OPT_mnocrc)) {
1558 if (A->getOption().matches(options::OPT_mcrc))
1559 Features.push_back("+crc");
1560 else
1561 Features.push_back("-crc");
1562 }
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001563}
1564
1565static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001566 const ArgList &Args, ArgStringList &CmdArgs,
1567 bool ForAS) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001568 std::vector<const char *> Features;
1569 switch (Triple.getArch()) {
1570 default:
1571 break;
1572 case llvm::Triple::mips:
1573 case llvm::Triple::mipsel:
1574 case llvm::Triple::mips64:
1575 case llvm::Triple::mips64el:
1576 getMIPSTargetFeatures(D, Args, Features);
1577 break;
1578
1579 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001580 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001581 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001582 case llvm::Triple::thumbeb:
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00001583 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001584 break;
1585
1586 case llvm::Triple::ppc:
1587 case llvm::Triple::ppc64:
1588 case llvm::Triple::ppc64le:
1589 getPPCTargetFeatures(Args, Features);
1590 break;
1591 case llvm::Triple::sparc:
1592 getSparcTargetFeatures(Args, Features);
1593 break;
1594 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001595 case llvm::Triple::aarch64_be:
James Molloyafc352c2014-04-16 15:33:56 +00001596 case llvm::Triple::arm64:
1597 case llvm::Triple::arm64_be:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001598 getAArch64TargetFeatures(D, Args, Features);
1599 break;
1600 case llvm::Triple::x86:
1601 case llvm::Triple::x86_64:
Jim Grosbach82eee262013-11-16 00:53:35 +00001602 getX86TargetFeatures(Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001603 break;
1604 }
Rafael Espindola43964802013-08-21 17:34:32 +00001605
1606 // Find the last of each feature.
1607 llvm::StringMap<unsigned> LastOpt;
1608 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1609 const char *Name = Features[I];
1610 assert(Name[0] == '-' || Name[0] == '+');
1611 LastOpt[Name + 1] = I;
1612 }
1613
1614 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1615 // If this feature was overridden, ignore it.
1616 const char *Name = Features[I];
1617 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1618 assert(LastI != LastOpt.end());
1619 unsigned Last = LastI->second;
1620 if (Last != I)
1621 continue;
1622
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001623 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00001624 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001625 }
Tim Northover2fe823a2013-08-01 09:23:19 +00001626}
1627
Eric Christopher84fbdb42011-08-19 00:30:14 +00001628static bool
John McCall5fb5df92012-06-20 06:18:46 +00001629shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001630 const llvm::Triple &Triple) {
1631 // We use the zero-cost exception tables for Objective-C if the non-fragile
1632 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1633 // later.
John McCall5fb5df92012-06-20 06:18:46 +00001634 if (runtime.isNonFragile())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001635 return true;
1636
Bob Wilson83e723a2013-12-05 19:38:42 +00001637 if (!Triple.isMacOSX())
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001638 return false;
1639
Eric Christopherbf15d2b2011-07-02 00:20:22 +00001640 return (!Triple.isMacOSXVersionLT(10,5) &&
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001641 (Triple.getArch() == llvm::Triple::x86_64 ||
Eric Christopher84fbdb42011-08-19 00:30:14 +00001642 Triple.getArch() == llvm::Triple::arm));
Anders Carlsson246ff3f2011-02-28 00:44:51 +00001643}
1644
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001645namespace {
1646 struct ExceptionSettings {
1647 bool ExceptionsEnabled;
1648 bool ShouldUseExceptionTables;
1649 ExceptionSettings() : ExceptionsEnabled(false),
1650 ShouldUseExceptionTables(false) {}
1651 };
1652} // end anonymous namespace.
1653
Nico Webere8e53112014-05-11 01:04:02 +00001654// exceptionSettings() exists to share the logic between -cc1 and linker
1655// invocations.
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001656static ExceptionSettings exceptionSettings(const ArgList &Args,
1657 const llvm::Triple &Triple) {
1658 ExceptionSettings ES;
1659
1660 // Are exceptions enabled by default?
1661 ES.ExceptionsEnabled = (Triple.getArch() != llvm::Triple::xcore);
1662
1663 // This keeps track of whether exceptions were explicitly turned on or off.
1664 bool DidHaveExplicitExceptionFlag = false;
1665
1666 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1667 options::OPT_fno_exceptions)) {
1668 if (A->getOption().matches(options::OPT_fexceptions))
1669 ES.ExceptionsEnabled = true;
1670 else
1671 ES.ExceptionsEnabled = false;
1672
1673 DidHaveExplicitExceptionFlag = true;
1674 }
1675
1676 // Exception tables and cleanups can be enabled with -fexceptions even if the
1677 // language itself doesn't support exceptions.
1678 if (ES.ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1679 ES.ShouldUseExceptionTables = true;
1680
1681 return ES;
1682}
1683
Anders Carlssone96ab552011-02-28 02:27:16 +00001684/// addExceptionArgs - Adds exception related arguments to the driver command
1685/// arguments. There's a master flag, -fexceptions and also language specific
1686/// flags to enable/disable C++ and Objective-C exceptions.
1687/// This makes it possible to for example disable C++ exceptions but enable
1688/// Objective-C exceptions.
1689static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1690 const llvm::Triple &Triple,
Fariborz Jahanianb2482212012-04-04 18:28:00 +00001691 bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00001692 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00001693 ArgStringList &CmdArgs) {
Chad Rosier4fab82c2012-03-26 22:04:46 +00001694 if (KernelOrKext) {
1695 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1696 // arguments now to avoid warnings about unused arguments.
1697 Args.ClaimAllArgs(options::OPT_fexceptions);
1698 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1699 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1700 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1701 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1702 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00001703 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00001704 }
Anders Carlssone96ab552011-02-28 02:27:16 +00001705
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001706 // Gather the exception settings from the command line arguments.
1707 ExceptionSettings ES = exceptionSettings(Args, Triple);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00001708
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001709 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1710 // is not necessarily sensible, but follows GCC.
1711 if (types::isObjC(InputType) &&
Eric Christopher84fbdb42011-08-19 00:30:14 +00001712 Args.hasFlag(options::OPT_fobjc_exceptions,
Daniel Dunbarc44f8cf2011-03-17 23:28:31 +00001713 options::OPT_fno_objc_exceptions,
1714 true)) {
1715 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00001716
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001717 ES.ShouldUseExceptionTables |=
John McCall5fb5df92012-06-20 06:18:46 +00001718 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00001719 }
1720
1721 if (types::isCXX(InputType)) {
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001722 bool CXXExceptionsEnabled = ES.ExceptionsEnabled;
Anders Carlssone96ab552011-02-28 02:27:16 +00001723
Eric Christopher84fbdb42011-08-19 00:30:14 +00001724 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1725 options::OPT_fno_cxx_exceptions,
Anders Carlssone96ab552011-02-28 02:27:16 +00001726 options::OPT_fexceptions,
1727 options::OPT_fno_exceptions)) {
1728 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1729 CXXExceptionsEnabled = true;
Chandler Carruth74f87112011-02-28 07:25:18 +00001730 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
Anders Carlssone96ab552011-02-28 02:27:16 +00001731 CXXExceptionsEnabled = false;
1732 }
1733
1734 if (CXXExceptionsEnabled) {
1735 CmdArgs.push_back("-fcxx-exceptions");
1736
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001737 ES.ShouldUseExceptionTables = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00001738 }
1739 }
1740
Robert Lyttonf7e03c12014-02-13 10:34:44 +00001741 if (ES.ShouldUseExceptionTables)
Anders Carlssone96ab552011-02-28 02:27:16 +00001742 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00001743}
1744
Daniel Dunbare246fbe2013-04-16 18:21:19 +00001745static bool ShouldDisableAutolink(const ArgList &Args,
1746 const ToolChain &TC) {
1747 bool Default = true;
1748 if (TC.getTriple().isOSDarwin()) {
1749 // The native darwin assembler doesn't support the linker_option directives,
1750 // so we disable them if we think the .s file will be passed to it.
1751 Default = TC.useIntegratedAs();
1752 }
1753 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1754 Default);
1755}
1756
Ted Kremenek62093662013-03-12 17:02:12 +00001757static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1758 const ToolChain &TC) {
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001759 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1760 options::OPT_fno_dwarf_directory_asm,
Rafael Espindola84b588b2013-03-18 18:10:27 +00001761 TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00001762 return !UseDwarfDirectory;
1763}
1764
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001765/// \brief Check whether the given input tree contains any compilation actions.
1766static bool ContainsCompileAction(const Action *A) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001767 if (isa<CompileJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001768 return true;
1769
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001770 for (const auto &Act : *A)
1771 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001772 return true;
1773
1774 return false;
1775}
1776
1777/// \brief Check if -relax-all should be passed to the internal assembler.
1778/// This is done by default when compiling non-assembler source with -O0.
1779static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1780 bool RelaxDefault = true;
1781
1782 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1783 RelaxDefault = A->getOption().matches(options::OPT_O0);
1784
1785 if (RelaxDefault) {
1786 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00001787 for (const auto &Act : C.getActions()) {
1788 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00001789 RelaxDefault = true;
1790 break;
1791 }
1792 }
1793 }
1794
1795 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1796 RelaxDefault);
1797}
1798
David Blaikie9260ed62013-07-25 21:19:01 +00001799static void CollectArgsForIntegratedAssembler(Compilation &C,
1800 const ArgList &Args,
1801 ArgStringList &CmdArgs,
1802 const Driver &D) {
1803 if (UseRelaxAll(C, Args))
1804 CmdArgs.push_back("-mrelax-all");
1805
David Peixottodfb66142013-11-14 22:52:58 +00001806 // When passing -I arguments to the assembler we sometimes need to
David Peixotto4afe0792013-11-14 22:58:17 +00001807 // unconditionally take the next argument. For example, when parsing
David Peixottodfb66142013-11-14 22:52:58 +00001808 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1809 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1810 // arg after parsing the '-I' arg.
1811 bool TakeNextArg = false;
1812
David Blaikie9260ed62013-07-25 21:19:01 +00001813 // When using an integrated assembler, translate -Wa, and -Xassembler
1814 // options.
David Blaikie7e2fd942014-03-27 20:47:30 +00001815 bool CompressDebugSections = false;
David Blaikie9260ed62013-07-25 21:19:01 +00001816 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1817 options::OPT_Xassembler),
1818 ie = Args.filtered_end(); it != ie; ++it) {
1819 const Arg *A = *it;
1820 A->claim();
1821
1822 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1823 StringRef Value = A->getValue(i);
David Peixottodfb66142013-11-14 22:52:58 +00001824 if (TakeNextArg) {
1825 CmdArgs.push_back(Value.data());
1826 TakeNextArg = false;
1827 continue;
1828 }
David Blaikie9260ed62013-07-25 21:19:01 +00001829
1830 if (Value == "-force_cpusubtype_ALL") {
1831 // Do nothing, this is the default and we don't support anything else.
1832 } else if (Value == "-L") {
1833 CmdArgs.push_back("-msave-temp-labels");
1834 } else if (Value == "--fatal-warnings") {
1835 CmdArgs.push_back("-mllvm");
1836 CmdArgs.push_back("-fatal-assembler-warnings");
1837 } else if (Value == "--noexecstack") {
1838 CmdArgs.push_back("-mnoexecstack");
David Blaikieec59e752014-01-22 19:22:21 +00001839 } else if (Value == "-compress-debug-sections" ||
1840 Value == "--compress-debug-sections") {
David Blaikie7e2fd942014-03-27 20:47:30 +00001841 CompressDebugSections = true;
1842 } else if (Value == "-nocompress-debug-sections" ||
1843 Value == "--nocompress-debug-sections") {
1844 CompressDebugSections = false;
David Peixottodfb66142013-11-14 22:52:58 +00001845 } else if (Value.startswith("-I")) {
1846 CmdArgs.push_back(Value.data());
1847 // We need to consume the next argument if the current arg is a plain
1848 // -I. The next arg will be the include directory.
1849 if (Value == "-I")
1850 TakeNextArg = true;
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00001851 } else if (Value.startswith("-gdwarf-")) {
1852 CmdArgs.push_back(Value.data());
David Blaikie9260ed62013-07-25 21:19:01 +00001853 } else {
1854 D.Diag(diag::err_drv_unsupported_option_argument)
1855 << A->getOption().getName() << Value;
1856 }
1857 }
1858 }
David Blaikie24bbfed22014-03-31 23:29:38 +00001859 if (CompressDebugSections) {
1860 if (llvm::zlib::isAvailable())
1861 CmdArgs.push_back("-compress-debug-sections");
1862 else
1863 D.Diag(diag::warn_debug_compression_unavailable);
1864 }
David Blaikie9260ed62013-07-25 21:19:01 +00001865}
1866
Renato Goline807c122014-01-31 11:47:28 +00001867// Until ARM libraries are build separately, we have them all in one library
1868static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001869 if (TC.getArch() == llvm::Triple::arm ||
1870 TC.getArch() == llvm::Triple::armeb)
Renato Goline807c122014-01-31 11:47:28 +00001871 return "arm";
1872 else
1873 return TC.getArchName();
1874}
1875
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001876static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
1877 // The runtimes are located in the OS-specific resource directory.
1878 SmallString<128> Res(TC.getDriver().ResourceDir);
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00001879 const llvm::Triple &Triple = TC.getTriple();
1880 // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
1881 StringRef OSLibName = (Triple.getOS() == llvm::Triple::FreeBSD) ?
1882 "freebsd" : TC.getOS();
1883 llvm::sys::path::append(Res, "lib", OSLibName);
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001884 return Res;
Alexey Samsonov7811d192014-02-20 13:57:37 +00001885}
1886
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001887// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00001888// FIXME: Make sure we can also emit shared objects if they're requested
1889// and available, check for possible errors, etc.
1890static void addClangRTLinux(
1891 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001892 SmallString<128> LibClangRT = getCompilerRTLibDir(TC);
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00001893 llvm::sys::path::append(LibClangRT, Twine("libclang_rt.builtins-") +
1894 getArchNameForCompilerRTLib(TC) +
1895 ".a");
Renato Golinc4b49242014-02-13 10:01:16 +00001896
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001897 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
Renato Golinc4b49242014-02-13 10:01:16 +00001898 CmdArgs.push_back("-lgcc_s");
1899 if (TC.getDriver().CCCIsCXX())
1900 CmdArgs.push_back("-lgcc_eh");
1901}
1902
Alexey Samsonov7811d192014-02-20 13:57:37 +00001903static void addProfileRT(
Chandler Carruth36381702013-06-23 11:28:48 +00001904 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1905 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1906 Args.hasArg(options::OPT_fprofile_generate) ||
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00001907 Args.hasArg(options::OPT_fprofile_instr_generate) ||
Chandler Carruth36381702013-06-23 11:28:48 +00001908 Args.hasArg(options::OPT_fcreate_profile) ||
1909 Args.hasArg(options::OPT_coverage)))
1910 return;
1911
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001912 // -fprofile-instr-generate requires position-independent code to build with
1913 // shared objects. Link against the right archive.
1914 const char *Lib = "libclang_rt.profile-";
1915 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1916 Args.hasArg(options::OPT_shared))
1917 Lib = "libclang_rt.profile-pic-";
1918
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001919 SmallString<128> LibProfile = getCompilerRTLibDir(TC);
1920 llvm::sys::path::append(LibProfile,
Duncan P. N. Exon Smith540c3cd2014-05-16 04:09:41 +00001921 Twine(Lib) + getArchNameForCompilerRTLib(TC) + ".a");
Chandler Carruth36381702013-06-23 11:28:48 +00001922
Duncan P. N. Exon Smith2d8f93e2014-03-28 17:53:17 +00001923 CmdArgs.push_back(Args.MakeArgString(LibProfile));
Chandler Carruth36381702013-06-23 11:28:48 +00001924}
1925
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001926static SmallString<128> getSanitizerRTLibName(const ToolChain &TC,
1927 const StringRef Sanitizer,
1928 bool Shared) {
1929 // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.{a,so}"
1930 // (or "libclang_rt.<Sanitizer>-<ArchName>-android.so for Android)
1931 const char *EnvSuffix =
1932 TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : "";
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001933 SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
1934 llvm::sys::path::append(LibSanitizer,
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001935 Twine("libclang_rt.") + Sanitizer + "-" +
1936 getArchNameForCompilerRTLib(TC) + EnvSuffix +
1937 (Shared ? ".so" : ".a"));
1938 return LibSanitizer;
1939}
1940
1941static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
1942 ArgStringList &CmdArgs,
1943 const StringRef Sanitizer,
1944 bool BeforeLibStdCXX,
1945 bool ExportSymbols = true,
1946 bool LinkDeps = true) {
1947 SmallString<128> LibSanitizer =
1948 getSanitizerRTLibName(TC, Sanitizer, /*Shared*/ false);
Richard Smithcff3cde2013-03-20 23:49:07 +00001949
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001950 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1951 // etc.) so that the linker picks custom versions of the global 'operator
1952 // new' and 'operator delete' symbols. We take the extreme (but simple)
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001953 // strategy of inserting it at the front of the link command. It also
1954 // needs to be forced to end up in the executable, so wrap it in
1955 // whole-archive.
Richard Smithcff3cde2013-03-20 23:49:07 +00001956 SmallVector<const char *, 3> LibSanitizerArgs;
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001957 LibSanitizerArgs.push_back("-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001958 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00001959 LibSanitizerArgs.push_back("-no-whole-archive");
Richard Smithcff3cde2013-03-20 23:49:07 +00001960
1961 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1962 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1963
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001964 if (LinkDeps) {
1965 // Link sanitizer dependencies explicitly
1966 CmdArgs.push_back("-lpthread");
1967 CmdArgs.push_back("-lrt");
1968 CmdArgs.push_back("-lm");
1969 // There's no libdl on FreeBSD.
1970 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
1971 CmdArgs.push_back("-ldl");
1972 }
Richard Smithf3e624c2013-03-23 00:30:08 +00001973
1974 // If possible, use a dynamic symbols file to export the symbols from the
1975 // runtime library. If we can't do so, use -export-dynamic instead to export
1976 // all symbols from the binary.
1977 if (ExportSymbols) {
1978 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1979 CmdArgs.push_back(
1980 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1981 else
1982 CmdArgs.push_back("-export-dynamic");
1983 }
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00001984}
1985
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00001986/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1987/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00001988static void addAsanRT(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovb01f9362014-05-12 18:39:51 +00001989 ArgStringList &CmdArgs, bool Shared, bool IsCXX) {
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001990 if (Shared) {
1991 // Link dynamic runtime if necessary.
1992 SmallString<128> LibSanitizer =
1993 getSanitizerRTLibName(TC, "asan", Shared);
1994 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00001995 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00001996
1997 // Do not link static runtime to DSOs or if compiling for Android.
1998 if (Args.hasArg(options::OPT_shared) ||
1999 (TC.getTriple().getEnvironment() == llvm::Triple::Android))
2000 return;
2001
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002002 if (Shared) {
2003 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
2004 /*BeforeLibStdCXX*/ true, /*ExportSymbols*/ false,
2005 /*LinkDeps*/ false);
2006 } else {
2007 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2008 if (IsCXX)
2009 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2010 }
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002011}
2012
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002013/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
2014/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002015static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2016 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002017 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002018 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
Kostya Serebryany66e8fab2012-05-16 06:36:00 +00002019}
2020
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002021/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
2022/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002023static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2024 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002025 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002026 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002027}
2028
2029/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
2030/// This needs to be called before we add the C run-time (malloc, etc).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002031static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2032 ArgStringList &CmdArgs) {
Sergey Matveev1814e9e2013-05-27 11:17:01 +00002033 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002034 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
Evgeniy Stepanovaea92e52012-12-03 13:20:43 +00002035}
2036
Richard Smithe30752c2012-10-09 19:52:38 +00002037/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
2038/// (Linux).
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002039static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2040 ArgStringList &CmdArgs, bool IsCXX,
2041 bool HasOtherSanitizerRt) {
Richard Smith4244ea92014-06-04 23:28:46 +00002042 // Export symbols if we're not building a shared library. This allows two
2043 // models: either every DSO containing ubsan-sanitized code contains the
2044 // ubsan runtime, or the main executable does (or both).
2045 const bool ExportSymbols = !Args.hasArg(options::OPT_shared);
2046
Nick Lewycky24921692013-10-19 00:27:23 +00002047 // Need a copy of sanitizer_common. This could come from another sanitizer
2048 // runtime; if we're not including one, include our own copy.
2049 if (!HasOtherSanitizerRt)
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002050 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002051
Richard Smith4244ea92014-06-04 23:28:46 +00002052 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, ExportSymbols);
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002053
2054 // Only include the bits of the runtime which need a C++ ABI library if
2055 // we're linking in C++ mode.
2056 if (IsCXX)
Richard Smith4244ea92014-06-04 23:28:46 +00002057 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false,
2058 ExportSymbols);
Richard Smithe30752c2012-10-09 19:52:38 +00002059}
2060
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002061static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2062 ArgStringList &CmdArgs) {
Peter Collingbournec3772752013-08-07 22:47:34 +00002063 if (!Args.hasArg(options::OPT_shared))
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002064 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2065}
2066
2067// Should be called before we add C++ ABI library.
2068static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2069 ArgStringList &CmdArgs) {
2070 const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
2071 const Driver &D = TC.getDriver();
2072 if (Sanitize.needsUbsanRt())
2073 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2074 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
2075 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
2076 if (Sanitize.needsAsanRt())
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002077 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002078 if (Sanitize.needsTsanRt())
2079 addTsanRT(TC, Args, CmdArgs);
2080 if (Sanitize.needsMsanRt())
2081 addMsanRT(TC, Args, CmdArgs);
2082 if (Sanitize.needsLsanRt())
2083 addLsanRT(TC, Args, CmdArgs);
2084 if (Sanitize.needsDfsanRt())
2085 addDfsanRT(TC, Args, CmdArgs);
Peter Collingbournec3772752013-08-07 22:47:34 +00002086}
2087
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002088static bool shouldUseFramePointerForTarget(const ArgList &Args,
2089 const llvm::Triple &Triple) {
2090 switch (Triple.getArch()) {
2091 // Don't use a frame pointer on linux if optimizing for certain targets.
2092 case llvm::Triple::mips64:
2093 case llvm::Triple::mips64el:
2094 case llvm::Triple::mips:
2095 case llvm::Triple::mipsel:
2096 case llvm::Triple::systemz:
2097 case llvm::Triple::x86:
2098 case llvm::Triple::x86_64:
2099 if (Triple.isOSLinux())
2100 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2101 if (!A->getOption().matches(options::OPT_O0))
2102 return false;
2103 return true;
2104 case llvm::Triple::xcore:
2105 return false;
2106 default:
2107 return true;
2108 }
2109}
2110
Rafael Espindola224dd632011-12-14 21:02:23 +00002111static bool shouldUseFramePointer(const ArgList &Args,
2112 const llvm::Triple &Triple) {
2113 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2114 options::OPT_fomit_frame_pointer))
2115 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2116
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002117 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002118}
2119
Eric Christopherb7d97e92013-04-03 01:58:53 +00002120static bool shouldUseLeafFramePointer(const ArgList &Args,
2121 const llvm::Triple &Triple) {
2122 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2123 options::OPT_momit_leaf_frame_pointer))
2124 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2125
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002126 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002127}
2128
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002129/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002130static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002131 SmallString<128> cwd;
2132 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002133 CmdArgs.push_back("-fdebug-compilation-dir");
2134 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002135 }
2136}
2137
Eric Christopherd3804002013-02-22 20:12:52 +00002138static const char *SplitDebugName(const ArgList &Args,
2139 const InputInfoList &Inputs) {
2140 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2141 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2142 SmallString<128> T(FinalOutput->getValue());
2143 llvm::sys::path::replace_extension(T, "dwo");
2144 return Args.MakeArgString(T);
2145 } else {
2146 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002147 SmallString<128> T(
2148 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Eric Christopherd3804002013-02-22 20:12:52 +00002149 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
2150 llvm::sys::path::replace_extension(F, "dwo");
2151 T += F;
2152 return Args.MakeArgString(F);
2153 }
2154}
2155
2156static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
2157 const Tool &T, const JobAction &JA,
2158 const ArgList &Args, const InputInfo &Output,
2159 const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002160 ArgStringList ExtractArgs;
2161 ExtractArgs.push_back("--extract-dwo");
2162
2163 ArgStringList StripArgs;
2164 StripArgs.push_back("--strip-dwo");
2165
2166 // Grabbing the output of the earlier compile step.
2167 StripArgs.push_back(Output.getFilename());
2168 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002169 ExtractArgs.push_back(OutFile);
2170
2171 const char *Exec =
Eric Christopherd3804002013-02-22 20:12:52 +00002172 Args.MakeArgString(TC.GetProgramPath("objcopy"));
Eric Christopher248357f2013-02-21 22:35:01 +00002173
2174 // First extract the dwo sections.
Eric Christopherd3804002013-02-22 20:12:52 +00002175 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002176
2177 // Then remove them from the original .o file.
Eric Christopherd3804002013-02-22 20:12:52 +00002178 C.addCommand(new Command(JA, T, Exec, StripArgs));
Eric Christopher248357f2013-02-21 22:35:01 +00002179}
2180
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002181/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002182/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2183static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002184 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002185 if (A->getOption().matches(options::OPT_O4) ||
2186 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002187 return true;
2188
2189 if (A->getOption().matches(options::OPT_O0))
2190 return false;
2191
2192 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2193
Rafael Espindola91780de2013-08-26 14:05:41 +00002194 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002195 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002196 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002197 return true;
2198
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002199 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002200 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002201 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002202
2203 unsigned OptLevel = 0;
2204 if (S.getAsInteger(10, OptLevel))
2205 return false;
2206
2207 return OptLevel > 1;
2208 }
2209
2210 return false;
2211}
2212
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002213/// Add -x lang to \p CmdArgs for \p Input.
2214static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2215 ArgStringList &CmdArgs) {
2216 // When using -verify-pch, we don't want to provide the type
2217 // 'precompiled-header' if it was inferred from the file extension
2218 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2219 return;
2220
2221 CmdArgs.push_back("-x");
2222 if (Args.hasArg(options::OPT_rewrite_objc))
2223 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2224 else
2225 CmdArgs.push_back(types::getTypeName(Input.getType()));
2226}
2227
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002228void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +00002229 const InputInfo &Output,
Daniel Dunbar0450e6d2009-03-18 06:07:59 +00002230 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002231 const ArgList &Args,
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002232 const char *LinkingOutput) const {
Daniel Dunbare46b52a2010-03-20 04:52:14 +00002233 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2234 options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00002235 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00002236 ArgStringList CmdArgs;
2237
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002238 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00002239 bool IsWindowsCygnus =
2240 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002241 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2242
Daniel Dunbare521a892009-03-31 20:53:55 +00002243 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2244
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00002245 // Invoke ourselves in -cc1 mode.
2246 //
2247 // FIXME: Implement custom jobs for internal actions.
2248 CmdArgs.push_back("-cc1");
2249
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002250 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00002251 CmdArgs.push_back("-triple");
Daniel Dunbar82eb4ce2010-08-23 22:35:37 +00002252 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002253 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00002254
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002255 const llvm::Triple TT(TripleStr);
2256 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2257 TT.getArch() == llvm::Triple::thumb)) {
2258 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2259 unsigned Version;
2260 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2261 if (Version < 7)
Nico Webere8e53112014-05-11 01:04:02 +00002262 D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2263 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00002264 }
2265
Tim Northover336f1892014-03-29 13:16:12 +00002266 // Push all default warning arguments that are specific to
2267 // the given target. These come before user provided warning options
2268 // are provided.
2269 getToolChain().addClangWarningOptions(CmdArgs);
2270
Daniel Dunbar624c21b2009-10-30 18:12:20 +00002271 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00002272 RewriteKind rewriteKind = RK_None;
Fariborz Jahanian7ebeede2012-04-04 18:50:28 +00002273
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002274 if (isa<AnalyzeJobAction>(JA)) {
2275 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2276 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00002277 } else if (isa<MigrateJobAction>(JA)) {
2278 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002279 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002280 if (Output.getType() == types::TY_Dependencies)
2281 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002282 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002283 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00002284 if (Args.hasArg(options::OPT_rewrite_objc) &&
2285 !Args.hasArg(options::OPT_g_Group))
2286 CmdArgs.push_back("-P");
2287 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002288 } else if (isa<AssembleJobAction>(JA)) {
2289 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00002290
David Blaikie9260ed62013-07-25 21:19:01 +00002291 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00002292
2293 // Also ignore explicit -force_cpusubtype_ALL option.
2294 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002295 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00002296 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002297 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00002298
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002299 if (JA.getType() == types::TY_Nothing)
2300 CmdArgs.push_back("-fsyntax-only");
2301 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00002302 CmdArgs.push_back("-emit-pch");
2303 else
2304 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002305 } else if (isa<VerifyPCHJobAction>(JA)) {
2306 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002307 } else {
2308 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002309
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002310 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00002311 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002312 } else if (JA.getType() == types::TY_LLVM_IR ||
2313 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002314 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00002315 } else if (JA.getType() == types::TY_LLVM_BC ||
2316 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002317 CmdArgs.push_back("-emit-llvm-bc");
2318 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00002319 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00002320 } else if (JA.getType() == types::TY_AST) {
2321 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002322 } else if (JA.getType() == types::TY_ModuleFile) {
2323 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002324 } else if (JA.getType() == types::TY_RewrittenObjC) {
2325 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002326 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00002327 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2328 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00002329 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00002330 } else {
2331 assert(JA.getType() == types::TY_PP_Asm &&
2332 "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002333 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00002334 }
2335
Justin Bognera88f0122014-06-20 22:59:50 +00002336 // We normally speed up the clang process a bit by skipping destructors at
2337 // exit, but when we're generating diagnostics we can rely on some of the
2338 // cleanup.
2339 if (!C.isForDiagnostics())
2340 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002341
John McCallbb79b5f2010-02-13 03:50:24 +00002342 // Disable the verification pass in -asserts builds.
2343#ifdef NDEBUG
2344 CmdArgs.push_back("-disable-llvm-verifier");
2345#endif
2346
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002347 // Set the main file name, so that debug info works even with
2348 // -save-temps.
2349 CmdArgs.push_back("-main-file-name");
Bob Wilsondecc03e2012-11-23 06:14:39 +00002350 CmdArgs.push_back(getBaseInputName(Args, Inputs));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00002351
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002352 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00002353 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00002354 if (Args.hasArg(options::OPT_static))
2355 CmdArgs.push_back("-static-define");
2356
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002357 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00002358 // Enable region store model by default.
2359 CmdArgs.push_back("-analyzer-store=region");
2360
Ted Kremenek7bea9a12009-12-07 22:26:14 +00002361 // Treat blocks as analysis entry points.
2362 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2363
Ted Kremenek49c79792011-03-24 00:28:47 +00002364 CmdArgs.push_back("-analyzer-eagerly-assume");
2365
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002366 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002367 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002368 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00002369
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002370 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002371 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00002372
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00002373 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00002374 CmdArgs.push_back("-analyzer-checker=osx");
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00002375
2376 CmdArgs.push_back("-analyzer-checker=deadcode");
Ted Kremenek37e96522012-01-26 02:27:38 +00002377
Jordan Rose10ad0812013-04-05 17:55:07 +00002378 if (types::isCXX(Inputs[0].getType()))
2379 CmdArgs.push_back("-analyzer-checker=cplusplus");
2380
Nico Webere8e53112014-05-11 01:04:02 +00002381 // Enable the following experimental checkers for testing.
2382 CmdArgs.push_back(
2383 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00002384 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2385 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2386 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2387 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2388 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002389 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00002390
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002391 // Set the output format. The default is plist, for (lame) historical
2392 // reasons.
2393 CmdArgs.push_back("-analyzer-output");
2394 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00002395 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00002396 else
2397 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002398
Ted Kremenekfe449a22010-03-22 22:32:05 +00002399 // Disable the presentation of standard compiler warnings when
2400 // using --analyze. We only want to show static analyzer diagnostics
2401 // or frontend errors.
2402 CmdArgs.push_back("-w");
2403
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002404 // Add -Xanalyzer arguments when running as analyzer.
2405 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00002406 }
2407
Daniel Dunbar4eadb602009-09-10 01:21:12 +00002408 CheckCodeGenerationOptions(D, Args);
2409
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002410 bool PIE = getToolChain().isPIEDefault();
2411 bool PIC = PIE || getToolChain().isPICDefault();
Chandler Carruth76a943b2012-11-19 03:52:03 +00002412 bool IsPICLevelTwo = PIC;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002413
Alexey Bataev40e75222014-01-28 06:30:35 +00002414 // Android-specific defaults for PIC/PIE
2415 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
2416 switch (getToolChain().getTriple().getArch()) {
2417 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002418 case llvm::Triple::armeb:
Alexey Bataev40e75222014-01-28 06:30:35 +00002419 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002420 case llvm::Triple::thumbeb:
Logan Chien4ecf0152014-04-29 18:18:58 +00002421 case llvm::Triple::aarch64:
Logan Chien28f87f82014-04-30 12:18:12 +00002422 case llvm::Triple::arm64:
Alexey Bataev40e75222014-01-28 06:30:35 +00002423 case llvm::Triple::mips:
2424 case llvm::Triple::mipsel:
2425 case llvm::Triple::mips64:
2426 case llvm::Triple::mips64el:
2427 PIC = true; // "-fpic"
2428 break;
2429
2430 case llvm::Triple::x86:
2431 case llvm::Triple::x86_64:
2432 PIC = true; // "-fPIC"
2433 IsPICLevelTwo = true;
2434 break;
2435
2436 default:
2437 break;
2438 }
2439 }
2440
Brad Smith5b05db82014-06-24 19:51:29 +00002441 // OpenBSD-specific defaults for PIE
2442 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
2443 switch (getToolChain().getTriple().getArch()) {
2444 case llvm::Triple::mips64:
2445 case llvm::Triple::mips64el:
2446 case llvm::Triple::sparc:
2447 case llvm::Triple::x86:
2448 case llvm::Triple::x86_64:
2449 IsPICLevelTwo = false; // "-fpie"
2450 break;
2451
2452 case llvm::Triple::ppc:
2453 case llvm::Triple::sparcv9:
2454 IsPICLevelTwo = true; // "-fPIE"
2455 break;
2456
2457 default:
2458 break;
2459 }
2460 }
2461
Alexey Samsonov090301e2013-04-09 12:28:19 +00002462 // For the PIC and PIE flag options, this logic is different from the
2463 // legacy logic in very old versions of GCC, as that logic was just
2464 // a bug no one had ever fixed. This logic is both more rational and
2465 // consistent with GCC's new logic now that the bugs are fixed. The last
2466 // argument relating to either PIC or PIE wins, and no other argument is
2467 // used. If the last argument is any flavor of the '-fno-...' arguments,
2468 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2469 // at the same level.
2470 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2471 options::OPT_fpic, options::OPT_fno_pic,
2472 options::OPT_fPIE, options::OPT_fno_PIE,
2473 options::OPT_fpie, options::OPT_fno_pie);
Chandler Carruth76a943b2012-11-19 03:52:03 +00002474 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2475 // is forced, then neither PIC nor PIE flags will have no effect.
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002476 if (!getToolChain().isPICDefaultForced()) {
Alexey Samsonov090301e2013-04-09 12:28:19 +00002477 if (LastPICArg) {
2478 Option O = LastPICArg->getOption();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00002479 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2480 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2481 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2482 PIC = PIE || O.matches(options::OPT_fPIC) ||
2483 O.matches(options::OPT_fpic);
2484 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2485 O.matches(options::OPT_fPIC);
2486 } else {
2487 PIE = PIC = false;
2488 }
2489 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002490 }
Chandler Carruth76a943b2012-11-19 03:52:03 +00002491
Nick Lewycky609dd662013-10-11 03:33:53 +00002492 // Introduce a Darwin-specific hack. If the default is PIC but the flags
Chandler Carruth76a943b2012-11-19 03:52:03 +00002493 // specified while enabling PIC enabled level 1 PIC, just force it back to
2494 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2495 // informal testing).
2496 if (PIC && getToolChain().getTriple().isOSDarwin())
2497 IsPICLevelTwo |= getToolChain().isPICDefault();
2498
Chandler Carruthc0c04552012-04-08 16:40:35 +00002499 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2500 // PIC or PIE options above, if these show up, PIC is disabled.
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00002501 llvm::Triple Triple(TripleStr);
Tim Northovera2ee4332014-03-29 15:09:45 +00002502 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6) ||
Tim Northover573cbee2014-05-24 12:52:07 +00002503 Triple.getArch() == llvm::Triple::arm64 ||
2504 Triple.getArch() == llvm::Triple::aarch64))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002505 PIC = PIE = false;
Simon Atanasyaneeb6f272013-10-04 11:46:54 +00002506 if (Args.hasArg(options::OPT_static))
Chandler Carruth76a943b2012-11-19 03:52:03 +00002507 PIC = PIE = false;
Chandler Carruthc0c04552012-04-08 16:40:35 +00002508
Chandler Carruth76a943b2012-11-19 03:52:03 +00002509 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2510 // This is a very special mode. It trumps the other modes, almost no one
2511 // uses it, and it isn't even valid on any OS but Darwin.
2512 if (!getToolChain().getTriple().isOSDarwin())
2513 D.Diag(diag::err_drv_unsupported_opt_for_target)
2514 << A->getSpelling() << getToolChain().getTriple().str();
2515
2516 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2517
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002518 CmdArgs.push_back("-mrelocation-model");
Chandler Carruth76a943b2012-11-19 03:52:03 +00002519 CmdArgs.push_back("dynamic-no-pic");
Daniel Dunbar44e71222009-04-29 18:32:25 +00002520
Chandler Carruth76a943b2012-11-19 03:52:03 +00002521 // Only a forced PIC mode can cause the actual compile to have PIC defines
2522 // etc., no flags are sufficient. This behavior was selected to closely
2523 // match that of llvm-gcc and Apple GCC before that.
2524 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2525 CmdArgs.push_back("-pic-level");
2526 CmdArgs.push_back("2");
2527 }
2528 } else {
2529 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2530 // handled in Clang's IRGen by the -pie-level flag.
2531 CmdArgs.push_back("-mrelocation-model");
2532 CmdArgs.push_back(PIC ? "pic" : "static");
2533
2534 if (PIC) {
2535 CmdArgs.push_back("-pic-level");
2536 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2537 if (PIE) {
2538 CmdArgs.push_back("-pie-level");
2539 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2540 }
2541 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002542 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00002543
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00002544 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2545 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00002546 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00002547
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002548 // LLVM Code Generator Options.
2549
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002550 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2551 StringRef v = A->getValue();
2552 CmdArgs.push_back("-mllvm");
2553 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2554 A->claim();
2555 }
2556
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002557 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2558 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00002559 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00002560 }
2561
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00002562 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2563 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002564 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00002565 D.Diag(diag::err_drv_unsupported_opt_for_target)
2566 << A->getSpelling() << getToolChain().getTriple().str();
2567 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2568 CmdArgs.push_back("-fpcc-struct-return");
2569 } else {
2570 assert(A->getOption().matches(options::OPT_freg_struct_return));
2571 CmdArgs.push_back("-freg-struct-return");
2572 }
2573 }
2574
Roman Divacky65b88cd2011-03-01 17:40:53 +00002575 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2576 CmdArgs.push_back("-mrtd");
2577
Rafael Espindola224dd632011-12-14 21:02:23 +00002578 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002579 CmdArgs.push_back("-mdisable-fp-elim");
2580 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2581 options::OPT_fno_zero_initialized_in_bss))
2582 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002583
2584 bool OFastEnabled = isOptimizationLevelFast(Args);
2585 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2586 // enabled. This alias option is being used to simplify the hasFlag logic.
2587 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2588 options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002589 // We turn strict aliasing off by default if we're in CL mode, since MSVC
2590 // doesn't do any TBAA.
2591 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002592 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00002593 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00002594 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00002595 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2596 options::OPT_fno_struct_path_tbaa))
2597 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00002598 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2599 false))
2600 CmdArgs.push_back("-fstrict-enums");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00002601 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2602 options::OPT_fno_optimize_sibling_calls))
2603 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002604
Eric Christopher006208c2013-04-04 06:29:47 +00002605 // Handle segmented stacks.
2606 if (Args.hasArg(options::OPT_fsplit_stack))
2607 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002608
2609 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2610 // This alias option is being used to simplify the getLastArg logic.
2611 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2612 options::OPT_ffast_math;
Eric Christopher006208c2013-04-04 06:29:47 +00002613
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002614 // Handle various floating point optimization flags, mapping them to the
2615 // appropriate LLVM code generation flags. The pattern for all of these is to
2616 // default off the codegen optimizations, and if any flag enables them and no
2617 // flag disables them after the flag enabling them, enable the codegen
2618 // optimization. This is complicated by several "umbrella" flags.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002619 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002620 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002621 options::OPT_ffinite_math_only,
2622 options::OPT_fno_finite_math_only,
2623 options::OPT_fhonor_infinities,
2624 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002625 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2626 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002627 A->getOption().getID() != options::OPT_fhonor_infinities)
2628 CmdArgs.push_back("-menable-no-infs");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002629 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002630 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002631 options::OPT_ffinite_math_only,
2632 options::OPT_fno_finite_math_only,
2633 options::OPT_fhonor_nans,
2634 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002635 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2636 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002637 A->getOption().getID() != options::OPT_fhonor_nans)
2638 CmdArgs.push_back("-menable-no-nans");
2639
Benjamin Kramerc242ef22012-05-02 14:55:48 +00002640 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2641 bool MathErrno = getToolChain().IsMathErrnoDefault();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002642 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002643 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002644 options::OPT_fmath_errno,
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00002645 options::OPT_fno_math_errno)) {
2646 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2647 // However, turning *off* -ffast_math merely restores the toolchain default
2648 // (which may be false).
2649 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2650 A->getOption().getID() == options::OPT_ffast_math ||
2651 A->getOption().getID() == options::OPT_Ofast)
2652 MathErrno = false;
2653 else if (A->getOption().getID() == options::OPT_fmath_errno)
2654 MathErrno = true;
2655 }
Chandler Carruth3634c662012-04-26 02:10:51 +00002656 if (MathErrno)
2657 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002658
2659 // There are several flags which require disabling very specific
2660 // optimizations. Any of these being disabled forces us to turn off the
2661 // entire set of LLVM optimizations, so collect them through all the flag
2662 // madness.
2663 bool AssociativeMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002664 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002665 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002666 options::OPT_funsafe_math_optimizations,
2667 options::OPT_fno_unsafe_math_optimizations,
2668 options::OPT_fassociative_math,
2669 options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002670 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2671 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002672 A->getOption().getID() != options::OPT_fno_associative_math)
2673 AssociativeMath = true;
2674 bool ReciprocalMath = false;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002675 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002676 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002677 options::OPT_funsafe_math_optimizations,
2678 options::OPT_fno_unsafe_math_optimizations,
2679 options::OPT_freciprocal_math,
2680 options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002681 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2682 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002683 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2684 ReciprocalMath = true;
2685 bool SignedZeros = true;
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,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002688 options::OPT_funsafe_math_optimizations,
2689 options::OPT_fno_unsafe_math_optimizations,
2690 options::OPT_fsigned_zeros,
2691 options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002692 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2693 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002694 A->getOption().getID() != options::OPT_fsigned_zeros)
2695 SignedZeros = false;
2696 bool TrappingMath = true;
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002697 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002698 options::OPT_fno_fast_math,
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002699 options::OPT_funsafe_math_optimizations,
2700 options::OPT_fno_unsafe_math_optimizations,
2701 options::OPT_ftrapping_math,
2702 options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002703 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2704 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002705 A->getOption().getID() != options::OPT_ftrapping_math)
2706 TrappingMath = false;
2707 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2708 !TrappingMath)
2709 CmdArgs.push_back("-menable-unsafe-fp-math");
2710
Lang Hamesaa53b932012-07-06 00:59:19 +00002711
2712 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002713 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002714 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00002715 options::OPT_ffp_contract)) {
2716 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002717 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00002718 if (Val == "fast" || Val == "on" || Val == "off") {
2719 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2720 } else {
2721 D.Diag(diag::err_drv_unsupported_option_argument)
2722 << A->getOption().getName() << Val;
2723 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002724 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2725 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00002726 // If fast-math is set then set the fp-contract mode to fast.
2727 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2728 }
2729 }
2730
Bob Wilson6a039162012-07-19 03:52:53 +00002731 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2732 // and if we find them, tell the frontend to provide the appropriate
2733 // preprocessor macros. This is distinct from enabling any optimizations as
2734 // these options induce language changes which must survive serialization
2735 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00002736 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2737 options::OPT_fno_fast_math))
2738 if (!A->getOption().matches(options::OPT_fno_fast_math))
2739 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00002740 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2741 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00002742 if (A->getOption().matches(options::OPT_ffinite_math_only))
2743 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002744
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002745 // Decide whether to use verbose asm. Verbose assembly is the default on
2746 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002747 bool IsIntegratedAssemblerDefault =
2748 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002749 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002750 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002751 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002752 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00002753
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00002754 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00002755 IsIntegratedAssemblerDefault))
2756 CmdArgs.push_back("-no-integrated-as");
2757
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002758 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2759 CmdArgs.push_back("-mdebug-pass");
2760 CmdArgs.push_back("Structure");
2761 }
2762 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2763 CmdArgs.push_back("-mdebug-pass");
2764 CmdArgs.push_back("Arguments");
2765 }
2766
John McCall8517abc2010-02-19 02:45:38 +00002767 // Enable -mconstructor-aliases except on darwin, where we have to
2768 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00002769 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00002770 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00002771
John McCall7ef5cb32011-03-18 02:56:14 +00002772 // Darwin's kernel doesn't support guard variables; just die if we
2773 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00002774 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00002775 CmdArgs.push_back("-fforbid-guard-variables");
2776
Douglas Gregordbe39272011-02-01 15:15:22 +00002777 if (Args.hasArg(options::OPT_mms_bitfields)) {
2778 CmdArgs.push_back("-mms-bitfields");
2779 }
John McCall8517abc2010-02-19 02:45:38 +00002780
Daniel Dunbar306945d2009-09-16 06:17:29 +00002781 // This is a coarse approximation of what llvm-gcc actually does, both
2782 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2783 // complicated ways.
2784 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00002785 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2786 options::OPT_fno_asynchronous_unwind_tables,
2787 (getToolChain().IsUnwindTablesDefault() ||
2788 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
2789 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00002790 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2791 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002792 CmdArgs.push_back("-munwind-tables");
2793
Chandler Carruth05fb5852012-11-21 23:40:23 +00002794 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00002795
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002796 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2797 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00002798 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002799 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00002800
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002801 // FIXME: Handle -mtune=.
2802 (void) Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00002803
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002804 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00002805 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00002806 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00002807 }
2808
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002809 // Add the target cpu
2810 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2811 llvm::Triple ETriple(ETripleStr);
2812 std::string CPU = getCPUName(Args, ETriple);
2813 if (!CPU.empty()) {
2814 CmdArgs.push_back("-target-cpu");
2815 CmdArgs.push_back(Args.MakeArgString(CPU));
2816 }
2817
Rafael Espindolaeb265472013-08-21 21:59:03 +00002818 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2819 CmdArgs.push_back("-mfpmath");
2820 CmdArgs.push_back(A->getValue());
2821 }
2822
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002823 // Add the target features
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002824 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002825
Rafael Espindola22ce34a2013-08-20 22:12:08 +00002826 // Add target specific flags.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002827 switch(getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002828 default:
2829 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002830
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002831 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002832 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002833 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002834 case llvm::Triple::thumbeb:
Daniel Dunbarc9388c12011-03-17 17:10:06 +00002835 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00002836 break;
2837
Tim Northover573cbee2014-05-24 12:52:07 +00002838 case llvm::Triple::aarch64:
2839 case llvm::Triple::aarch64_be:
Tim Northovera2ee4332014-03-29 15:09:45 +00002840 case llvm::Triple::arm64:
James Molloy2b24fc42014-04-17 12:51:23 +00002841 case llvm::Triple::arm64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00002842 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00002843 break;
2844
Eric Christopher0b26a612010-03-02 02:41:08 +00002845 case llvm::Triple::mips:
2846 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00002847 case llvm::Triple::mips64:
2848 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00002849 AddMIPSTargetArgs(Args, CmdArgs);
2850 break;
2851
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002852 case llvm::Triple::sparc:
2853 AddSparcTargetArgs(Args, CmdArgs);
2854 break;
2855
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002856 case llvm::Triple::x86:
2857 case llvm::Triple::x86_64:
2858 AddX86TargetArgs(Args, CmdArgs);
2859 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002860
2861 case llvm::Triple::hexagon:
2862 AddHexagonTargetArgs(Args, CmdArgs);
2863 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00002864 }
2865
Hans Wennborg75958c42013-08-08 00:17:41 +00002866 // Add clang-cl arguments.
2867 if (getToolChain().getDriver().IsCLMode())
2868 AddClangCLArgs(Args, CmdArgs);
2869
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002870 // Pass the linker version in use.
2871 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2872 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00002873 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00002874 }
2875
Eric Christopherb7d97e92013-04-03 01:58:53 +00002876 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00002877 CmdArgs.push_back("-momit-leaf-frame-pointer");
2878
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002879 // Explicitly error on some things we know we don't support and can't just
2880 // ignore.
2881 types::ID InputType = Inputs[0].getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002882 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2883 Arg *Unsupported;
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002884 if (types::isCXX(InputType) &&
Bob Wilson6524dd32011-10-14 05:03:44 +00002885 getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00002886 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00002887 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2888 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002889 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00002890 << Unsupported->getOption().getName();
2891 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00002892 }
2893
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002894 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00002895 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00002896 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00002897 CmdArgs.push_back("-header-include-file");
2898 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2899 D.CCPrintHeadersFilename : "-");
2900 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002901 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00002902 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002903
Chad Rosierbe10f982011-08-02 17:58:04 +00002904 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00002905 CmdArgs.push_back("-diagnostic-log-file");
2906 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2907 D.CCLogDiagnosticsFilename : "-");
2908 }
2909
Manman Ren17bdb0f2013-11-20 20:22:14 +00002910 // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
2911 // are preserved, all other debug options are substituted with "-g".
Rafael Espindola08a692a2010-03-07 04:46:18 +00002912 Args.ClaimAllArgs(options::OPT_g_Group);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002913 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
David Blaikief5961452014-03-25 20:42:27 +00002914 if (A->getOption().matches(options::OPT_gline_tables_only)) {
Manman Ren17bdb0f2013-11-20 20:22:14 +00002915 // FIXME: we should support specifying dwarf version with
2916 // -gline-tables-only.
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002917 CmdArgs.push_back("-gline-tables-only");
Brad Smith378e7f9b2014-06-13 03:35:37 +00002918 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2919 const llvm::Triple &Triple = getToolChain().getTriple();
2920 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2921 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002922 CmdArgs.push_back("-gdwarf-2");
Manman Ren17bdb0f2013-11-20 20:22:14 +00002923 } else if (A->getOption().matches(options::OPT_gdwarf_2))
Manman Ren9691f7f2013-06-19 01:46:49 +00002924 CmdArgs.push_back("-gdwarf-2");
2925 else if (A->getOption().matches(options::OPT_gdwarf_3))
2926 CmdArgs.push_back("-gdwarf-3");
2927 else if (A->getOption().matches(options::OPT_gdwarf_4))
2928 CmdArgs.push_back("-gdwarf-4");
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002929 else if (!A->getOption().matches(options::OPT_g0) &&
Adrian Prantl549c5142014-02-17 17:40:52 +00002930 !A->getOption().matches(options::OPT_ggdb0)) {
Brad Smith378e7f9b2014-06-13 03:35:37 +00002931 // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.
2932 const llvm::Triple &Triple = getToolChain().getTriple();
2933 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
2934 Triple.getOS() == llvm::Triple::FreeBSD)
Adrian Prantl549c5142014-02-17 17:40:52 +00002935 CmdArgs.push_back("-gdwarf-2");
2936 else
2937 CmdArgs.push_back("-g");
2938 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00002939 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00002940
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002941 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2942 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Eric Christophera2f7eb72012-10-18 21:52:18 +00002943 if (Args.hasArg(options::OPT_gcolumn_info))
2944 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00002945
Eric Christopher138c32b2013-09-13 22:37:55 +00002946 // FIXME: Move backend command line options to the module.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002947 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2948 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00002949 // FIXME: Currently only works on Linux.
Cameron Esfahani556d91e2013-09-14 01:09:11 +00002950 if (getToolChain().getTriple().isOSLinux() &&
Eric Christopherd42fb732013-02-21 22:35:05 +00002951 Args.hasArg(options::OPT_gsplit_dwarf)) {
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002952 CmdArgs.push_back("-g");
2953 CmdArgs.push_back("-backend-option");
2954 CmdArgs.push_back("-split-dwarf=Enable");
2955 }
2956
Eric Christopher138c32b2013-09-13 22:37:55 +00002957 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2958 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2959 CmdArgs.push_back("-backend-option");
2960 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2961 }
Eric Christophereec89c22013-06-18 00:03:50 +00002962
Eric Christopher0d403d22014-02-14 01:27:03 +00002963 // -gdwarf-aranges turns on the emission of the aranges section in the
2964 // backend.
2965 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2966 CmdArgs.push_back("-backend-option");
2967 CmdArgs.push_back("-generate-arange-section");
2968 }
2969
David Blaikief36d9ba2014-01-27 18:52:43 +00002970 if (Args.hasFlag(options::OPT_fdebug_types_section,
2971 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00002972 CmdArgs.push_back("-backend-option");
2973 CmdArgs.push_back("-generate-type-units");
2974 }
Eric Christophereec89c22013-06-18 00:03:50 +00002975
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00002976 if (Args.hasFlag(options::OPT_ffunction_sections,
2977 options::OPT_fno_function_sections, false)) {
2978 CmdArgs.push_back("-ffunction-sections");
2979 }
2980
2981 if (Args.hasFlag(options::OPT_fdata_sections,
2982 options::OPT_fno_data_sections, false)) {
2983 CmdArgs.push_back("-fdata-sections");
2984 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00002985
Chris Lattner3c77a352010-06-22 00:03:40 +00002986 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2987
Justin Bogner6a9d2cf2014-01-06 22:27:36 +00002988 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2989 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2990 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
2991 D.Diag(diag::err_drv_argument_not_allowed_with)
2992 << "-fprofile-instr-generate" << "-fprofile-instr-use";
2993
2994 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2995
2996 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
2997 A->render(Args, CmdArgs);
2998 else if (Args.hasArg(options::OPT_fprofile_instr_use))
2999 CmdArgs.push_back("-fprofile-instr-use=pgo-data");
3000
Nick Lewycky207bce32011-04-21 23:44:07 +00003001 if (Args.hasArg(options::OPT_ftest_coverage) ||
3002 Args.hasArg(options::OPT_coverage))
3003 CmdArgs.push_back("-femit-coverage-notes");
3004 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3005 Args.hasArg(options::OPT_coverage))
3006 CmdArgs.push_back("-femit-coverage-data");
3007
Nick Lewycky480cb992011-05-04 20:46:58 +00003008 if (C.getArgs().hasArg(options::OPT_c) ||
3009 C.getArgs().hasArg(options::OPT_S)) {
3010 if (Output.isFilename()) {
Nick Lewycky85c011d2011-05-05 00:08:20 +00003011 CmdArgs.push_back("-coverage-file");
Eric Christophere30f61c2013-02-22 00:24:40 +00003012 SmallString<128> CoverageFilename(Output.getFilename());
Nick Lewycky737a4522013-03-07 08:28:53 +00003013 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003014 SmallString<128> Pwd;
3015 if (!llvm::sys::fs::current_path(Pwd)) {
3016 llvm::sys::path::append(Pwd, CoverageFilename.str());
3017 CoverageFilename.swap(Pwd);
Nick Lewycky737a4522013-03-07 08:28:53 +00003018 }
3019 }
Eric Christophere30f61c2013-02-22 00:24:40 +00003020 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
Nick Lewycky480cb992011-05-04 20:46:58 +00003021 }
3022 }
3023
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003024 // Pass options for controlling the default header search paths.
3025 if (Args.hasArg(options::OPT_nostdinc)) {
3026 CmdArgs.push_back("-nostdsysteminc");
3027 CmdArgs.push_back("-nobuiltininc");
3028 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003029 if (Args.hasArg(options::OPT_nostdlibinc))
3030 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003031 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3032 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3033 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003034
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003035 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003036 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003037 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003038
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003039 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3040
Ted Kremenekf7639e12012-03-06 20:06:33 +00003041 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003042 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003043 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003044 options::OPT_ccc_arcmt_modify,
3045 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003046 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00003047 switch (A->getOption().getID()) {
3048 default:
3049 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003050 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00003051 CmdArgs.push_back("-arcmt-check");
3052 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00003053 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00003054 CmdArgs.push_back("-arcmt-modify");
3055 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003056 case options::OPT_ccc_arcmt_migrate:
3057 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003058 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003059 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00003060
3061 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3062 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00003063 break;
John McCalld70fb982011-06-15 23:25:17 +00003064 }
3065 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00003066 } else {
3067 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3068 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3069 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00003070 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003071
Ted Kremenekf7639e12012-03-06 20:06:33 +00003072 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3073 if (ARCMTEnabled) {
3074 D.Diag(diag::err_drv_argument_not_allowed_with)
3075 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3076 }
3077 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00003078 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00003079
3080 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003081 options::OPT_objcmt_migrate_subscripting,
3082 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00003083 // None specified, means enable them all.
3084 CmdArgs.push_back("-objcmt-migrate-literals");
3085 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003086 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003087 } else {
3088 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3089 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00003090 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003091 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00003092 } else {
3093 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3094 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3095 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3096 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3097 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3098 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3099 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3100 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3101 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3102 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3103 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3104 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3105 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00003106 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00003107 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00003108 }
3109
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003110 // Add preprocessing options like -I, -D, etc. if we are using the
3111 // preprocessor.
3112 //
3113 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003114 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00003115 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003116
Rafael Espindolaa7431922011-07-21 23:40:37 +00003117 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3118 // that "The compiler can only warn and ignore the option if not recognized".
3119 // When building with ccache, it will pass -D options to clang even on
3120 // preprocessed inputs and configure concludes that -fPIC is not supported.
3121 Args.ClaimAllArgs(options::OPT_D);
3122
Alp Toker7874bdc2013-11-15 20:40:58 +00003123 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00003124 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3125 if (A->getOption().matches(options::OPT_O4)) {
3126 CmdArgs.push_back("-O3");
3127 D.Diag(diag::warn_O4_is_O3);
3128 } else {
3129 A->render(Args, CmdArgs);
3130 }
3131 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003132
Chad Rosier86b82082012-12-12 20:06:31 +00003133 // Don't warn about unused -flto. This can happen when we're preprocessing or
3134 // precompiling.
3135 Args.ClaimAllArgs(options::OPT_flto);
3136
Daniel Dunbar945577c2009-10-29 02:24:45 +00003137 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00003138 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3139 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00003140 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003141 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003142
3143 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00003144 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003145 //
3146 // If a std is supplied, only add -trigraphs if it follows the
3147 // option.
3148 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3149 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00003150 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003151 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00003152 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003153 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003154 else
3155 Std->render(Args, CmdArgs);
3156
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00003157 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3158 options::OPT_trigraphs))
3159 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003160 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003161 } else {
3162 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00003163 //
3164 // FIXME: Clang doesn't correctly handle -std= when the input language
3165 // doesn't match. For the time being just ignore this for C++ inputs;
3166 // eventually we want to do all the standard defaulting here instead of
3167 // splitting it between the driver and clang -cc1.
3168 if (!types::isCXX(InputType))
Nico Weber723b4f02012-08-30 02:08:31 +00003169 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3170 "-std=", /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003171 else if (IsWindowsMSVC)
Nico Weber723b4f02012-08-30 02:08:31 +00003172 CmdArgs.push_back("-std=c++11");
3173
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00003174 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00003175 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003176
Richard Smith282b4492013-09-04 22:50:31 +00003177 // GCC's behavior for -Wwrite-strings is a bit strange:
3178 // * In C, this "warning flag" changes the types of string literals from
3179 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3180 // for the discarded qualifier.
3181 // * In C++, this is just a normal warning flag.
3182 //
3183 // Implementing this warning correctly in C is hard, so we follow GCC's
3184 // behavior for now. FIXME: Directly diagnose uses of a string literal as
3185 // a non-const char* in C, rather than using this crude hack.
3186 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00003187 // FIXME: This should behave just like a warning flag, and thus should also
3188 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3189 Arg *WriteStrings =
3190 Args.getLastArg(options::OPT_Wwrite_strings,
3191 options::OPT_Wno_write_strings, options::OPT_w);
3192 if (WriteStrings &&
3193 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00003194 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00003195 }
3196
Chandler Carruth61fbf622011-04-23 09:27:53 +00003197 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00003198 // during C++ compilation, which it is by default. GCC keeps this define even
3199 // in the presence of '-w', match this behavior bug-for-bug.
3200 if (types::isCXX(InputType) &&
3201 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3202 true)) {
3203 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00003204 }
3205
Chandler Carruthe0391482010-05-22 02:21:53 +00003206 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3207 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3208 if (Asm->getOption().matches(options::OPT_fasm))
3209 CmdArgs.push_back("-fgnu-keywords");
3210 else
3211 CmdArgs.push_back("-fno-gnu-keywords");
3212 }
3213
Nick Lewycky1d617ac2011-10-17 23:05:52 +00003214 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3215 CmdArgs.push_back("-fno-dwarf-directory-asm");
3216
Daniel Dunbare246fbe2013-04-16 18:21:19 +00003217 if (ShouldDisableAutolink(Args, getToolChain()))
3218 CmdArgs.push_back("-fno-autolink");
3219
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003220 // Add in -fdebug-compilation-dir if necessary.
3221 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00003222
Richard Smith9a568822011-11-21 19:36:32 +00003223 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3224 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003225 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003226 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003227 }
3228
Richard Smith79c927b2013-11-06 19:31:51 +00003229 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3230 CmdArgs.push_back("-foperator-arrow-depth");
3231 CmdArgs.push_back(A->getValue());
3232 }
3233
Richard Smith9a568822011-11-21 19:36:32 +00003234 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3235 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00003236 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00003237 }
3238
Richard Smitha3d3bd22013-05-08 02:12:03 +00003239 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3240 CmdArgs.push_back("-fconstexpr-steps");
3241 CmdArgs.push_back(A->getValue());
3242 }
3243
Richard Smithb3a14522013-02-22 01:59:51 +00003244 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3245 CmdArgs.push_back("-fbracket-depth");
3246 CmdArgs.push_back(A->getValue());
3247 }
3248
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00003249 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3250 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003251 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003252 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00003253 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3254 } else
3255 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00003256 }
3257
Nuno Lopes3d6311d2012-05-08 22:10:46 +00003258
Michael J. Spencer929fccd2012-10-22 22:13:48 +00003259 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00003260 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00003261
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003262 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3263 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00003264 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00003265 }
David Chisnall5778fce2009-08-31 16:41:57 +00003266
Chris Lattnere23003d2010-01-09 21:54:33 +00003267 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3268 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00003269 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00003270 }
3271
Chris Lattnerb35583d2010-04-07 20:49:23 +00003272 CmdArgs.push_back("-ferror-limit");
3273 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00003274 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00003275 else
3276 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00003277
Chandler Carrutha77a7272010-05-06 04:55:18 +00003278 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3279 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003280 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003281 }
3282
3283 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3284 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003285 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00003286 }
3287
Richard Smithf6f003a2011-12-16 19:06:07 +00003288 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3289 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00003290 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00003291 }
3292
Daniel Dunbar2c978472009-11-04 06:24:47 +00003293 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00003294 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00003295 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003296 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00003297 } else {
3298 // If -fmessage-length=N was not specified, determine whether this is a
3299 // terminal and, if so, implicitly define -fmessage-length appropriately.
3300 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003301 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00003302 }
3303
John McCallb4a99d32013-02-19 01:57:35 +00003304 // -fvisibility= and -fvisibility-ms-compat are of a piece.
3305 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3306 options::OPT_fvisibility_ms_compat)) {
3307 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3308 CmdArgs.push_back("-fvisibility");
3309 CmdArgs.push_back(A->getValue());
3310 } else {
3311 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3312 CmdArgs.push_back("-fvisibility");
3313 CmdArgs.push_back("hidden");
3314 CmdArgs.push_back("-ftype-visibility");
3315 CmdArgs.push_back("default");
3316 }
Daniel Dunbare357d562009-12-03 18:42:11 +00003317 }
3318
Douglas Gregor08329632010-06-15 17:05:35 +00003319 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003320
Hans Wennborgf60f6af2012-06-28 08:01:44 +00003321 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3322
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003323 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003324 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3325 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00003326 CmdArgs.push_back("-ffreestanding");
3327
Daniel Dunbare357d562009-12-03 18:42:11 +00003328 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003329 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003330 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Adrian Prantla7634472014-01-07 01:19:08 +00003331 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3332 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
Eric Christopher86050822011-10-25 07:13:06 +00003333 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Bill Schmidtb3b804e2013-07-03 15:36:02 +00003334 // AltiVec language extensions aren't relevant for assembling.
3335 if (!isa<PreprocessJobAction>(JA) ||
3336 Output.getType() != types::TY_PP_Asm)
3337 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Richard Trieu91844232012-06-26 18:18:47 +00003338 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3339 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00003340
Peter Collingbourne32701642013-11-01 18:16:25 +00003341 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3342 Sanitize.addArgs(Args, CmdArgs);
Richard Smith52be6192012-11-05 22:04:41 +00003343
Will Dietz3676d562012-12-30 20:53:28 +00003344 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3345 options::OPT_fno_sanitize_recover,
3346 true))
3347 CmdArgs.push_back("-fno-sanitize-recover");
3348
Alexey Samsonovcb3f8122014-03-20 10:48:29 +00003349 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
Chad Rosierae229d52013-01-29 23:31:22 +00003350 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3351 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3352
Eric Christopher459d2712013-02-19 06:16:53 +00003353 // Report an error for -faltivec on anything other than PowerPC.
Chad Rosier864dfe12012-03-13 23:45:51 +00003354 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003355 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
Bill Schmidt778d3872013-07-26 01:36:11 +00003356 getToolChain().getArch() == llvm::Triple::ppc64 ||
3357 getToolChain().getArch() == llvm::Triple::ppc64le))
Chad Rosier864dfe12012-03-13 23:45:51 +00003358 D.Diag(diag::err_drv_argument_only_allowed_with)
Bill Schmidt778d3872013-07-26 01:36:11 +00003359 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
Chad Rosier864dfe12012-03-13 23:45:51 +00003360
Daniel Dunbar733b0f82011-03-01 18:49:30 +00003361 if (getToolChain().SupportsProfiling())
3362 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00003363
3364 // -flax-vector-conversions is default.
3365 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3366 options::OPT_fno_lax_vector_conversions))
3367 CmdArgs.push_back("-fno-lax-vector-conversions");
3368
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003369 if (Args.getLastArg(options::OPT_fapple_kext))
3370 CmdArgs.push_back("-fapple-kext");
3371
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00003372 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00003373 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00003374 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003375 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3376 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00003377
3378 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3379 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00003380 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00003381 }
3382
Bob Wilson14adb362012-02-03 06:27:22 +00003383 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00003384
Chandler Carruth6e501032011-03-27 00:04:55 +00003385 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3386 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3387 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3388 options::OPT_fno_wrapv)) {
3389 if (A->getOption().matches(options::OPT_fwrapv))
3390 CmdArgs.push_back("-fwrapv");
3391 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3392 options::OPT_fno_strict_overflow)) {
3393 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3394 CmdArgs.push_back("-fwrapv");
3395 }
Hal Finkelce0697f2013-11-17 16:03:29 +00003396
3397 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3398 options::OPT_fno_reroll_loops))
3399 if (A->getOption().matches(options::OPT_freroll_loops))
3400 CmdArgs.push_back("-freroll-loops");
3401
Daniel Dunbar3a148f22009-04-07 21:51:40 +00003402 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00003403 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3404 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003405
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00003406 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3407
Mahesha S6a682be42012-10-27 07:47:56 +00003408
Daniel Dunbar4930e332009-11-17 08:07:36 +00003409 // -stack-protector=0 is default.
3410 unsigned StackProtectorLevel = 0;
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003411 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3412 options::OPT_fstack_protector_all,
Josh Mageee0fc1a82014-02-11 01:35:14 +00003413 options::OPT_fstack_protector_strong,
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003414 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00003415 if (A->getOption().matches(options::OPT_fstack_protector)) {
3416 StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
3417 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
3418 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003419 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00003420 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00003421 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00003422 } else {
3423 StackProtectorLevel =
3424 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3425 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003426 if (StackProtectorLevel) {
3427 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003428 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003429 }
Chad Rosierdb3da832012-08-21 16:16:06 +00003430
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003431 // --param ssp-buffer-size=
3432 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3433 ie = Args.filtered_end(); it != ie; ++it) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003434 StringRef Str((*it)->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003435 if (Str.startswith("ssp-buffer-size=")) {
3436 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00003437 CmdArgs.push_back("-stack-protector-buffer-size");
3438 // FIXME: Verify the argument is a valid integer.
3439 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00003440 }
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00003441 (*it)->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00003442 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00003443 }
3444
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00003445 // Translate -mstackrealign
3446 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3447 false)) {
3448 CmdArgs.push_back("-backend-option");
3449 CmdArgs.push_back("-force-align-stack");
3450 }
3451 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3452 false)) {
3453 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3454 }
3455
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00003456 if (Args.hasArg(options::OPT_mstack_alignment)) {
3457 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3458 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00003459 }
Chad Rosier9ae53f82012-11-29 00:42:06 +00003460 // -mkernel implies -mstrict-align; don't add the redundant option.
Renato Golina146a482013-08-24 14:44:41 +00003461 if (!KernelOrKext) {
Renato Golin8d5f3142013-08-28 23:56:07 +00003462 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3463 options::OPT_munaligned_access)) {
3464 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3465 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003466 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3467 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3468 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003469 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003470 CmdArgs.push_back("-aarch64-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003471 else
3472 CmdArgs.push_back("-arm-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003473 } else {
3474 CmdArgs.push_back("-backend-option");
Tim Northover573cbee2014-05-24 12:52:07 +00003475 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
3476 getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be ||
3477 getToolChain().getTriple().getArch() == llvm::Triple::arm64 ||
Kevin Qine5cee2602014-05-06 09:51:32 +00003478 getToolChain().getTriple().getArch() == llvm::Triple::arm64_be)
Tim Northover573cbee2014-05-24 12:52:07 +00003479 CmdArgs.push_back("-aarch64-no-strict-align");
Kevin Qine5cee2602014-05-06 09:51:32 +00003480 else
3481 CmdArgs.push_back("-arm-no-strict-align");
Renato Golin8d5f3142013-08-28 23:56:07 +00003482 }
Renato Golina146a482013-08-24 14:44:41 +00003483 }
Chad Rosier60027022012-11-09 17:29:19 +00003484 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00003485
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003486 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3487 options::OPT_mno_restrict_it)) {
3488 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3489 CmdArgs.push_back("-backend-option");
3490 CmdArgs.push_back("-arm-restrict-it");
3491 } else {
3492 CmdArgs.push_back("-backend-option");
3493 CmdArgs.push_back("-arm-no-restrict-it");
3494 }
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00003495 } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
3496 TT.getArch() == llvm::Triple::thumb)) {
3497 // Windows on ARM expects restricted IT blocks
3498 CmdArgs.push_back("-backend-option");
3499 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00003500 }
3501
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003502 if (TT.getArch() == llvm::Triple::arm ||
3503 TT.getArch() == llvm::Triple::thumb) {
3504 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3505 options::OPT_mno_long_calls)) {
3506 if (A->getOption().matches(options::OPT_mlong_calls)) {
3507 CmdArgs.push_back("-backend-option");
Saleem Abdulrasooldf903932014-06-18 16:52:24 +00003508 CmdArgs.push_back("-arm-long-calls");
Saleem Abdulrasoolaea65e92014-06-07 19:32:38 +00003509 }
3510 }
3511 }
3512
Daniel Dunbard18049a2009-04-07 21:16:11 +00003513 // Forward -f options with positive and negative forms; we translate
3514 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00003515 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3516 StringRef fname = A->getValue();
3517 if (!llvm::sys::fs::exists(fname))
3518 D.Diag(diag::err_drv_no_such_file) << fname;
3519 else
3520 A->render(Args, CmdArgs);
3521 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003522
Diego Novillo829b1702014-04-16 16:54:24 +00003523 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3524 A->render(Args, CmdArgs);
3525
Diego Novillod23ec942014-05-29 19:55:06 +00003526 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3527 A->render(Args, CmdArgs);
3528
3529 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3530 A->render(Args, CmdArgs);
3531
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003532 if (Args.hasArg(options::OPT_mkernel)) {
Daniel Dunbar80f787c2011-02-04 17:24:47 +00003533 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003534 CmdArgs.push_back("-fapple-kext");
3535 if (!Args.hasArg(options::OPT_fbuiltin))
3536 CmdArgs.push_back("-fno-builtin");
Chad Rosierf27e1c42012-03-26 21:29:17 +00003537 Args.ClaimAllArgs(options::OPT_fno_builtin);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003538 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00003539 // -fbuiltin is default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003540 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
Daniel Dunbar484afa22009-11-19 04:55:23 +00003541 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00003542
Nuno Lopes13c88c72009-12-16 16:59:22 +00003543 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3544 options::OPT_fno_assume_sane_operator_new))
3545 CmdArgs.push_back("-fno-assume-sane-operator-new");
3546
Daniel Dunbar4930e332009-11-17 08:07:36 +00003547 // -fblocks=0 is default.
3548 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00003549 getToolChain().IsBlocksDefault()) ||
3550 (Args.hasArg(options::OPT_fgnu_runtime) &&
3551 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3552 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00003553 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00003554
3555 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3556 !getToolChain().hasBlocksRuntime())
3557 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00003558 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00003559
Douglas Gregor226173a2012-01-18 15:19:58 +00003560 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3561 // users must also pass -fcxx-modules. The latter flag will disappear once the
3562 // modules implementation is solid for C++/Objective-C++ programs as well.
Douglas Gregorc60437f2013-01-16 01:23:41 +00003563 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00003564 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3565 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3566 options::OPT_fno_cxx_modules,
3567 false);
Douglas Gregorc60437f2013-01-16 01:23:41 +00003568 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00003569 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00003570 HaveModules = true;
3571 }
3572 }
3573
Daniel Jasper07e6c402013-08-05 20:26:17 +00003574 // -fmodule-maps enables module map processing (off by default) for header
3575 // checking. It is implied by -fmodules.
3576 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3577 false)) {
3578 CmdArgs.push_back("-fmodule-maps");
3579 }
3580
Daniel Jasperac42b752013-10-21 06:34:34 +00003581 // -fmodules-decluse checks that modules used are declared so (off by
3582 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003583 if (Args.hasFlag(options::OPT_fmodules_decluse,
3584 options::OPT_fno_modules_decluse,
3585 false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00003586 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003587 }
3588
Daniel Jasper962b38e2014-04-11 11:47:45 +00003589 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3590 // all #included headers are part of modules.
3591 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3592 options::OPT_fno_modules_strict_decluse,
3593 false)) {
3594 CmdArgs.push_back("-fmodules-strict-decluse");
3595 }
3596
Daniel Jasperac42b752013-10-21 06:34:34 +00003597 // -fmodule-name specifies the module that is currently being built (or
3598 // used for header checking by -fmodule-maps).
Justin Bogner5443ad52014-06-20 21:12:53 +00003599 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
Daniel Jasperac42b752013-10-21 06:34:34 +00003600 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003601
3602 // -fmodule-map-file can be used to specify a file containing module
3603 // definitions.
Justin Bogner5443ad52014-06-20 21:12:53 +00003604 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
Daniel Jasperac42b752013-10-21 06:34:34 +00003605 A->render(Args, CmdArgs);
Daniel Jasperac42b752013-10-21 06:34:34 +00003606
Justin Bognera88f0122014-06-20 22:59:50 +00003607 // -fmodule-cache-path specifies where our module files should be written.
3608 SmallString<128> ModuleCachePath;
3609 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3610 ModuleCachePath = A->getValue();
3611 if (HaveModules) {
3612 if (C.isForDiagnostics()) {
3613 // When generating crash reports, we want to emit the modules along with
3614 // the reproduction sources, so we ignore any provided module path.
3615 ModuleCachePath = Output.getFilename();
3616 llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
3617 llvm::sys::path::append(ModuleCachePath, "modules");
3618 } else if (ModuleCachePath.empty()) {
3619 // No module path was provided: use the default.
3620 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3621 ModuleCachePath);
3622 llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
3623 llvm::sys::path::append(ModuleCachePath, "ModuleCache");
3624 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00003625 const char Arg[] = "-fmodules-cache-path=";
Justin Bognera88f0122014-06-20 22:59:50 +00003626 ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
3627 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3628 }
3629
3630 // When building modules and generating crashdumps, we need to dump a module
3631 // dependency VFS alongside the output.
3632 if (HaveModules && C.isForDiagnostics()) {
3633 SmallString<128> VFSDir(Output.getFilename());
3634 llvm::sys::path::replace_extension(VFSDir, ".cache");
3635 llvm::sys::path::append(VFSDir, "vfs");
3636 CmdArgs.push_back("-module-dependency-dir");
3637 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00003638 }
3639
Justin Bogner5443ad52014-06-20 21:12:53 +00003640 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3641 if (HaveModules)
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003642 A->render(Args, CmdArgs);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00003643
Douglas Gregor35b04d62013-02-07 19:01:24 +00003644 // Pass through all -fmodules-ignore-macro arguments.
3645 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00003646 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3647 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00003648
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003649 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3650
3651 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3652 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3653 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3654
3655 Args.AddLastArg(CmdArgs,
3656 options::OPT_fmodules_validate_once_per_build_session);
3657 }
3658
Ben Langmuirdcf73862014-03-12 00:06:17 +00003659 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3660
John McCalldfea9982010-04-09 19:12:06 +00003661 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00003662 if (Args.hasFlag(options::OPT_fno_access_control,
3663 options::OPT_faccess_control,
John McCalldfea9982010-04-09 19:12:06 +00003664 false))
John McCall3155f572010-04-09 19:03:51 +00003665 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00003666
Anders Carlssond470fef2010-11-21 00:09:52 +00003667 // -felide-constructors is the default.
3668 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3669 options::OPT_felide_constructors,
3670 false))
3671 CmdArgs.push_back("-fno-elide-constructors");
3672
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003673 // -frtti is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00003674 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
Richard Smith52be6192012-11-05 22:04:41 +00003675 KernelOrKext) {
Daniel Dunbar484afa22009-11-19 04:55:23 +00003676 CmdArgs.push_back("-fno-rtti");
Mike Stump183c3d22009-07-31 23:15:31 +00003677
Richard Smith52be6192012-11-05 22:04:41 +00003678 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
Alexey Samsonov627b10f2012-11-06 15:09:03 +00003679 if (Sanitize.sanitizesVptr()) {
NAKAMURA Takumiab060362012-11-06 22:02:00 +00003680 std::string NoRttiArg =
Richard Smith52be6192012-11-05 22:04:41 +00003681 Args.getLastArg(options::OPT_mkernel,
3682 options::OPT_fapple_kext,
Richard Smithaa716572012-11-06 01:12:02 +00003683 options::OPT_fno_rtti)->getAsString(Args);
Richard Smith52be6192012-11-05 22:04:41 +00003684 D.Diag(diag::err_drv_argument_not_allowed_with)
3685 << "-fsanitize=vptr" << NoRttiArg;
3686 }
3687 }
3688
Tony Linthicum76329bf2011-12-12 21:14:55 +00003689 // -fshort-enums=0 is default for all architectures except Hexagon.
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003690 if (Args.hasFlag(options::OPT_fshort_enums,
Tony Linthicum76329bf2011-12-12 21:14:55 +00003691 options::OPT_fno_short_enums,
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003692 getToolChain().getArch() ==
Tony Linthicum76329bf2011-12-12 21:14:55 +00003693 llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00003694 CmdArgs.push_back("-fshort-enums");
3695
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003696 // -fsigned-char is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003697 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
Daniel Dunbard609b7b2009-11-17 06:37:03 +00003698 isSignedCharDefault(getToolChain().getTriple())))
Daniel Dunbar5fe08662009-11-29 02:39:08 +00003699 CmdArgs.push_back("-fno-signed-char");
Eli Friedman327f0b52009-06-05 07:21:14 +00003700
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003701 // -fthreadsafe-static is default.
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003702 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
Anders Carlssonfcd764a2010-02-06 23:23:06 +00003703 options::OPT_fno_threadsafe_statics))
3704 CmdArgs.push_back("-fno-threadsafe-statics");
3705
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003706 // -fuse-cxa-atexit is default.
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003707 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3708 options::OPT_fno_use_cxa_atexit,
3709 !IsWindowsCygnus && !IsWindowsGNU &&
3710 getToolChain().getArch() != llvm::Triple::hexagon &&
3711 getToolChain().getArch() != llvm::Triple::xcore) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00003712 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00003713 CmdArgs.push_back("-fno-use-cxa-atexit");
3714
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003715 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00003716 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003717 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00003718 CmdArgs.push_back("-fms-extensions");
3719
Francois Pichet1b4f1632011-09-17 04:32:15 +00003720 // -fms-compatibility=0 is default.
Douglas Gregor2b4907e2011-10-24 15:49:38 +00003721 if (Args.hasFlag(options::OPT_fms_compatibility,
3722 options::OPT_fno_ms_compatibility,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003723 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3724 options::OPT_fno_ms_extensions,
3725 true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00003726 CmdArgs.push_back("-fms-compatibility");
3727
Reid Klecknerc106fda2013-09-18 00:33:59 +00003728 // -fmsc-version=1700 is default.
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003729 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003730 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003731 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003732 if (msc_ver.empty())
Reid Klecknerc106fda2013-09-18 00:33:59 +00003733 CmdArgs.push_back("-fmsc-version=1700");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003734 else
3735 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3736 }
3737
3738
Eric Christopher5ecce122013-02-18 00:38:31 +00003739 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00003740 if (Args.hasFlag(options::OPT_fborland_extensions,
3741 options::OPT_fno_borland_extensions, false))
3742 CmdArgs.push_back("-fborland-extensions");
3743
Francois Pichet02744872011-09-01 16:38:08 +00003744 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3745 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00003746 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003747 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00003748 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00003749
Chandler Carruthe03aa552010-04-17 20:17:31 +00003750 // -fgnu-keywords default varies depending on language; only pass if
3751 // specified.
3752 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00003753 options::OPT_fno_gnu_keywords))
3754 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00003755
Rafael Espindola922a6242011-06-02 17:30:53 +00003756 if (Args.hasFlag(options::OPT_fgnu89_inline,
3757 options::OPT_fno_gnu89_inline,
3758 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00003759 CmdArgs.push_back("-fgnu89-inline");
3760
Chad Rosier9c76d242012-03-15 22:31:42 +00003761 if (Args.hasArg(options::OPT_fno_inline))
3762 CmdArgs.push_back("-fno-inline");
3763
Chad Rosier64d6be92012-03-06 21:17:19 +00003764 if (Args.hasArg(options::OPT_fno_inline_functions))
3765 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00003766
John McCall5fb5df92012-06-20 06:18:46 +00003767 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00003768
John McCall5fb5df92012-06-20 06:18:46 +00003769 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00003770 // legacy is the default. Except for deployment taget of 10.5,
3771 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
3772 // gets ignored silently.
3773 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00003774 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3775 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00003776 objcRuntime.isLegacyDispatchDefaultForArch(
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003777 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00003778 if (getToolChain().UseObjCMixedDispatch())
3779 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3780 else
3781 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3782 }
3783 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00003784
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003785 // When ObjectiveC legacy runtime is in effect on MacOSX,
3786 // turn on the option to do Array/Dictionary subscripting
3787 // by default.
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00003788 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3789 getToolChain().getTriple().isMacOSX() &&
3790 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3791 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00003792 objcRuntime.isNeXTFamily())
3793 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3794
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00003795 // -fencode-extended-block-signature=1 is default.
3796 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3797 CmdArgs.push_back("-fencode-extended-block-signature");
3798 }
3799
John McCall24fc0de2011-07-06 00:26:06 +00003800 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3801 // NOTE: This logic is duplicated in ToolChains.cpp.
3802 bool ARC = isObjCAutoRefCount(Args);
3803 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00003804 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00003805
John McCall24fc0de2011-07-06 00:26:06 +00003806 CmdArgs.push_back("-fobjc-arc");
3807
Chandler Carruth491db322011-11-04 07:34:47 +00003808 // FIXME: It seems like this entire block, and several around it should be
3809 // wrapped in isObjC, but for now we just use it here as this is where it
3810 // was being used previously.
3811 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3812 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3813 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3814 else
3815 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3816 }
3817
John McCall24fc0de2011-07-06 00:26:06 +00003818 // Allow the user to enable full exceptions code emission.
3819 // We define off for Objective-CC, on for Objective-C++.
3820 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3821 options::OPT_fno_objc_arc_exceptions,
3822 /*default*/ types::isCXX(InputType)))
3823 CmdArgs.push_back("-fobjc-arc-exceptions");
3824 }
3825
3826 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3827 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00003828 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00003829 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003830
John McCall24fc0de2011-07-06 00:26:06 +00003831 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3832 // takes precedence.
3833 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3834 if (!GCArg)
3835 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3836 if (GCArg) {
3837 if (ARC) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003838 D.Diag(diag::err_drv_objc_gc_arr)
John McCall24fc0de2011-07-06 00:26:06 +00003839 << GCArg->getAsString(Args);
3840 } else if (getToolChain().SupportsObjCGC()) {
3841 GCArg->render(Args, CmdArgs);
3842 } else {
3843 // FIXME: We should move this to a hard error.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003844 D.Diag(diag::warn_drv_objc_gc_unsupported)
John McCall24fc0de2011-07-06 00:26:06 +00003845 << GCArg->getAsString(Args);
3846 }
3847 }
3848
Reid Klecknerc542d372014-06-27 17:02:02 +00003849 // Handle GCC-style exception args.
3850 if (!C.getDriver().IsCLMode())
3851 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
3852 objcRuntime, CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00003853
3854 if (getToolChain().UseSjLjExceptions())
3855 CmdArgs.push_back("-fsjlj-exceptions");
3856
3857 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00003858 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3859 options::OPT_fno_assume_sane_operator_new))
3860 CmdArgs.push_back("-fno-assume-sane-operator-new");
3861
Daniel Dunbar34d7a992010-04-27 15:34:57 +00003862 // -fconstant-cfstrings is default, and may be subject to argument translation
3863 // on Darwin.
3864 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3865 options::OPT_fno_constant_cfstrings) ||
3866 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3867 options::OPT_mno_constant_cfstrings))
3868 CmdArgs.push_back("-fno-constant-cfstrings");
3869
John Thompsoned4e2952009-11-05 20:14:16 +00003870 // -fshort-wchar default varies depending on platform; only
3871 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00003872 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3873 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00003874 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00003875
Hans Wennborg28c96312013-07-31 23:39:13 +00003876 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003877 if (Args.hasFlag(options::OPT_fpascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003878 options::OPT_fno_pascal_strings,
Daniel Dunbard4510f22009-04-07 23:51:44 +00003879 false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003880 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003881
Daniel Dunbar096ed292011-10-05 21:04:55 +00003882 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3883 // -fno-pack-struct doesn't apply to -fpack-struct=.
3884 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00003885 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00003886 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00003887 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00003888 } else if (Args.hasFlag(options::OPT_fpack_struct,
3889 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00003890 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00003891 }
3892
Robert Lytton0e076492013-08-13 09:43:10 +00003893 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003894 if (!Args.hasArg(options::OPT_fcommon))
3895 CmdArgs.push_back("-fno-common");
Chad Rosierd9d80e02012-03-26 21:35:40 +00003896 Args.ClaimAllArgs(options::OPT_fno_common);
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003897 }
Daniel Dunbar096ed292011-10-05 21:04:55 +00003898
Daniel Dunbard18049a2009-04-07 21:16:11 +00003899 // -fcommon is default, only pass non-default.
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00003900 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
Daniel Dunbard18049a2009-04-07 21:16:11 +00003901 CmdArgs.push_back("-fno-common");
3902
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003903 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00003904 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00003905 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003906 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003907 D.Diag(diag::warn_drv_clang_unsupported)
Daniel Dunbar2edd9232009-04-15 02:37:43 +00003908 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3909
Daniel Dunbar6358d682010-10-15 22:30:42 +00003910 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3911 if (!Args.hasFlag(options::OPT_ffor_scope,
3912 options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003913 D.Diag(diag::err_drv_clang_unsupported)
Daniel Dunbar6358d682010-10-15 22:30:42 +00003914 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3915
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00003916 // -fcaret-diagnostics is default.
3917 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3918 options::OPT_fno_caret_diagnostics, true))
3919 CmdArgs.push_back("-fno-caret-diagnostics");
3920
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003921 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00003922 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00003923 options::OPT_fno_diagnostics_fixit_info))
3924 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00003925
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003926 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00003927 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003928 options::OPT_fno_diagnostics_show_option))
3929 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003930
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003931 if (const Arg *A =
3932 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3933 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00003934 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00003935 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00003936
Douglas Gregor643c9222011-05-21 17:07:29 +00003937 if (const Arg *A =
3938 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3939 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00003940 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00003941 }
3942
Chandler Carruthb6766f02011-03-27 01:50:55 +00003943 if (Arg *A = Args.getLastArg(
3944 options::OPT_fdiagnostics_show_note_include_stack,
3945 options::OPT_fno_diagnostics_show_note_include_stack)) {
3946 if (A->getOption().matches(
3947 options::OPT_fdiagnostics_show_note_include_stack))
3948 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3949 else
3950 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3951 }
3952
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003953 // Color diagnostics are the default, unless the terminal doesn't support
3954 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00003955 // Support both clang's -f[no-]color-diagnostics and gcc's
3956 // -f[no-]diagnostics-colors[=never|always|auto].
3957 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003958 for (const auto &Arg : Args) {
3959 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00003960 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3961 !O.matches(options::OPT_fdiagnostics_color) &&
3962 !O.matches(options::OPT_fno_color_diagnostics) &&
3963 !O.matches(options::OPT_fno_diagnostics_color) &&
3964 !O.matches(options::OPT_fdiagnostics_color_EQ))
3965 continue;
3966
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003967 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00003968 if (O.matches(options::OPT_fcolor_diagnostics) ||
3969 O.matches(options::OPT_fdiagnostics_color)) {
3970 ShowColors = Colors_On;
3971 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3972 O.matches(options::OPT_fno_diagnostics_color)) {
3973 ShowColors = Colors_Off;
3974 } else {
3975 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00003976 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00003977 if (value == "always")
3978 ShowColors = Colors_On;
3979 else if (value == "never")
3980 ShowColors = Colors_Off;
3981 else if (value == "auto")
3982 ShowColors = Colors_Auto;
3983 else
3984 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3985 << ("-fdiagnostics-color=" + value).str();
3986 }
3987 }
3988 if (ShowColors == Colors_On ||
3989 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00003990 CmdArgs.push_back("-fcolor-diagnostics");
3991
Nico Rieck7857d462013-09-11 00:38:02 +00003992 if (Args.hasArg(options::OPT_fansi_escape_codes))
3993 CmdArgs.push_back("-fansi-escape-codes");
3994
Daniel Dunbardb097022009-06-08 21:13:54 +00003995 if (!Args.hasFlag(options::OPT_fshow_source_location,
3996 options::OPT_fno_show_source_location))
3997 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00003998
Douglas Gregor643c9222011-05-21 17:07:29 +00003999 if (!Args.hasFlag(options::OPT_fshow_column,
4000 options::OPT_fno_show_column,
4001 true))
4002 CmdArgs.push_back("-fno-show-column");
4003
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00004004 if (!Args.hasFlag(options::OPT_fspell_checking,
4005 options::OPT_fno_spell_checking))
4006 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004007
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004008
Chad Rosierc8e56e82012-12-05 21:08:21 +00004009 // -fno-asm-blocks is default.
4010 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4011 false))
4012 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00004013
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004014 // Enable vectorization per default according to the optimization level
4015 // selected. For optimization levels that want vectorization we use the alias
4016 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004017 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00004018 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
Chad Rosier679b0752013-04-24 18:29:59 +00004019 options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00004020 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00004021 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004022 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00004023
Chad Rosier136d67d2014-04-28 19:30:57 +00004024 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004025 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4026 OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
Chad Rosier136d67d2014-04-28 19:30:57 +00004027 options::OPT_fslp_vectorize;
4028 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00004029 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00004030 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00004031
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004032 // -fno-slp-vectorize-aggressive is default.
4033 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004034 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004035 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00004036
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00004037 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4038 A->render(Args, CmdArgs);
4039
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004040 // -fdollars-in-identifiers default varies depending on platform and
4041 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00004042 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004043 options::OPT_fno_dollars_in_identifiers)) {
4044 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004045 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004046 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00004047 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00004048 }
4049
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004050 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4051 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00004052 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004053 options::OPT_fno_unit_at_a_time)) {
4054 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004055 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00004056 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004057
Eli Friedman055c9702011-11-02 01:53:16 +00004058 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4059 options::OPT_fno_apple_pragma_pack, false))
4060 CmdArgs.push_back("-fapple-pragma-pack");
4061
Eli Benderskyc95cfe82013-07-24 18:20:14 +00004062 // le32-specific flags:
4063 // -fno-math-builtin: clang should not convert math builtins to intrinsics
4064 // by default.
4065 if (getToolChain().getArch() == llvm::Triple::le32) {
4066 CmdArgs.push_back("-fno-math-builtin");
4067 }
4068
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004069 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004070 //
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00004071 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004072#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00004073 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004074 (getToolChain().getArch() == llvm::Triple::arm ||
4075 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004076 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4077 CmdArgs.push_back("-fno-builtin-strcat");
4078 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4079 CmdArgs.push_back("-fno-builtin-strcpy");
4080 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00004081#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00004082
Justin Bognera88f0122014-06-20 22:59:50 +00004083 // Enable rewrite includes if the user's asked for it or if we're generating
4084 // diagnostics.
4085 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4086 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00004087 if (Args.hasFlag(options::OPT_frewrite_includes,
4088 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00004089 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00004090 CmdArgs.push_back("-frewrite-includes");
4091
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004092 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00004093 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004094 options::OPT_traditional_cpp)) {
4095 if (isa<PreprocessJobAction>(JA))
4096 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004097 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004098 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00004099 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00004100
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004101 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00004102 Args.AddLastArg(CmdArgs, options::OPT_dD);
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004103
4104 // Handle serialized diagnostics.
4105 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4106 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00004107 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00004108 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004109
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00004110 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4111 CmdArgs.push_back("-fretain-comments-from-system-headers");
4112
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004113 // Forward -fcomment-block-commands to -cc1.
4114 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004115 // Forward -fparse-all-comments to -cc1.
4116 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004117
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004118 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4119 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004120 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004121 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4122 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00004123 (*it)->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00004124
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004125 // We translate this by hand to the -cc1 argument, since nightly test uses
4126 // it and developers have been trained to spell it with -mllvm.
Richard Smithbd55daf2012-11-01 04:30:05 +00004127 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004128 CmdArgs.push_back("-disable-llvm-optzns");
4129 else
Daniel Dunbara442fd52010-06-11 22:00:13 +00004130 (*it)->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00004131 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004132
Daniel Dunbard67a3222009-03-30 06:36:42 +00004133 if (Output.getType() == types::TY_Dependencies) {
4134 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004135 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004136 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004137 CmdArgs.push_back(Output.getFilename());
4138 } else {
4139 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004140 }
4141
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004142 for (const auto &II : Inputs) {
Ben Langmuir2cb4a782014-02-05 22:21:15 +00004143 addDashXForInput(Args, II, CmdArgs);
4144
Daniel Dunbarb440f562010-08-02 02:38:21 +00004145 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004146 CmdArgs.push_back(II.getFilename());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004147 else
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004148 II.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004149 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004150
Chris Lattnere9d7d782009-11-03 19:50:27 +00004151 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4152
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004153 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004154
4155 // Optionally embed the -cc1 level arguments into the debug info, for build
4156 // analysis.
4157 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004158 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004159 for (const auto &Arg : Args)
4160 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00004161
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004162 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004163 Flags += Exec;
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004164 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004165 Flags += " ";
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00004166 Flags += OriginalArgs[i];
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00004167 }
4168 CmdArgs.push_back("-dwarf-debug-flags");
4169 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4170 }
4171
Eric Christopherd3804002013-02-22 20:12:52 +00004172 // Add the split debug info name to the command lines here so we
4173 // can propagate it to the backend.
4174 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004175 getToolChain().getTriple().isOSLinux() &&
Eric Christopherf1545832013-02-22 23:50:16 +00004176 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00004177 const char *SplitDwarfOut;
4178 if (SplitDwarf) {
4179 CmdArgs.push_back("-split-dwarf-file");
4180 SplitDwarfOut = SplitDebugName(Args, Inputs);
4181 CmdArgs.push_back(SplitDwarfOut);
4182 }
4183
4184 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00004185 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00004186 Output.getType() == types::TY_Object &&
4187 (InputType == types::TY_C || InputType == types::TY_CXX)) {
Hans Wennborg1da044a2014-06-26 19:59:02 +00004188 Command *CLCommand = getCLFallback()->GetCommand(C, JA, Output, Inputs,
4189 Args, LinkingOutput);
Reid Kleckner47c2f842014-05-14 16:03:05 +00004190 // RTTI support in clang-cl is a work in progress. Fall back to MSVC early
4191 // if we are using 'clang-cl /fallback /GR'.
4192 // FIXME: Remove this when RTTI is finished.
4193 if (Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti, false)) {
4194 D.Diag(diag::warn_drv_rtti_fallback) << CLCommand->getExecutable();
4195 C.addCommand(CLCommand);
4196 } else {
4197 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
4198 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00004199 } else {
4200 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4201 }
4202
Daniel Dunbar17731772009-03-23 19:03:36 +00004203
Eric Christopherf1545832013-02-22 23:50:16 +00004204 // Handle the debug info splitting at object creation time if we're
4205 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00004206 // TODO: Currently only works on linux with newer objcopy.
Eric Christopherf1545832013-02-22 23:50:16 +00004207 if (SplitDwarf && !isa<CompileJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00004208 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00004209
Roman Divacky178e01602011-02-10 16:52:03 +00004210 if (Arg *A = Args.getLastArg(options::OPT_pg))
4211 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004212 D.Diag(diag::err_drv_argument_not_allowed_with)
Roman Divacky178e01602011-02-10 16:52:03 +00004213 << "-fomit-frame-pointer" << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004214
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004215 // Claim some arguments which clang supports automatically.
4216
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00004217 // -fpch-preprocess is used with gcc to add a special marker in the output to
4218 // include the PCH file. Clang's PTH solution is completely transparent, so we
4219 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00004220 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004221
Daniel Dunbar17731772009-03-23 19:03:36 +00004222 // Claim some arguments which clang doesn't support, but we don't
4223 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00004224 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4225 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00004226
Rafael Espindolab0092d72013-09-04 19:37:35 +00004227 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00004228 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004229}
4230
John McCall5fb5df92012-06-20 06:18:46 +00004231/// Add options related to the Objective-C runtime/ABI.
4232///
4233/// Returns true if the runtime is non-fragile.
4234ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4235 ArgStringList &cmdArgs,
4236 RewriteKind rewriteKind) const {
4237 // Look for the controlling runtime option.
4238 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4239 options::OPT_fgnu_runtime,
4240 options::OPT_fobjc_runtime_EQ);
4241
4242 // Just forward -fobjc-runtime= to the frontend. This supercedes
4243 // options about fragility.
4244 if (runtimeArg &&
4245 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4246 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00004247 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004248 if (runtime.tryParse(value)) {
4249 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4250 << value;
4251 }
4252
4253 runtimeArg->render(args, cmdArgs);
4254 return runtime;
4255 }
4256
4257 // Otherwise, we'll need the ABI "version". Version numbers are
4258 // slightly confusing for historical reasons:
4259 // 1 - Traditional "fragile" ABI
4260 // 2 - Non-fragile ABI, version 1
4261 // 3 - Non-fragile ABI, version 2
4262 unsigned objcABIVersion = 1;
4263 // If -fobjc-abi-version= is present, use that to set the version.
4264 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004265 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004266 if (value == "1")
4267 objcABIVersion = 1;
4268 else if (value == "2")
4269 objcABIVersion = 2;
4270 else if (value == "3")
4271 objcABIVersion = 3;
4272 else
4273 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4274 << value;
4275 } else {
4276 // Otherwise, determine if we are using the non-fragile ABI.
4277 bool nonFragileABIIsDefault =
4278 (rewriteKind == RK_NonFragile ||
4279 (rewriteKind == RK_None &&
4280 getToolChain().IsObjCNonFragileABIDefault()));
4281 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4282 options::OPT_fno_objc_nonfragile_abi,
4283 nonFragileABIIsDefault)) {
4284 // Determine the non-fragile ABI version to use.
4285#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4286 unsigned nonFragileABIVersion = 1;
4287#else
4288 unsigned nonFragileABIVersion = 2;
4289#endif
4290
4291 if (Arg *abiArg = args.getLastArg(
4292 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004293 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00004294 if (value == "1")
4295 nonFragileABIVersion = 1;
4296 else if (value == "2")
4297 nonFragileABIVersion = 2;
4298 else
4299 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4300 << value;
4301 }
4302
4303 objcABIVersion = 1 + nonFragileABIVersion;
4304 } else {
4305 objcABIVersion = 1;
4306 }
4307 }
4308
4309 // We don't actually care about the ABI version other than whether
4310 // it's non-fragile.
4311 bool isNonFragile = objcABIVersion != 1;
4312
4313 // If we have no runtime argument, ask the toolchain for its default runtime.
4314 // However, the rewriter only really supports the Mac runtime, so assume that.
4315 ObjCRuntime runtime;
4316 if (!runtimeArg) {
4317 switch (rewriteKind) {
4318 case RK_None:
4319 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4320 break;
4321 case RK_Fragile:
4322 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
4323 break;
4324 case RK_NonFragile:
4325 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4326 break;
4327 }
4328
4329 // -fnext-runtime
4330 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
4331 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004332 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00004333 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
4334
4335 // Otherwise, build for a generic macosx port.
4336 } else {
4337 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
4338 }
4339
4340 // -fgnu-runtime
4341 } else {
4342 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00004343 // Legacy behaviour is to target the gnustep runtime if we are i
4344 // non-fragile mode or the GCC runtime in fragile mode.
4345 if (isNonFragile)
David Chisnalla5f59412012-10-16 15:11:55 +00004346 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
David Chisnall314896c2012-07-04 10:37:03 +00004347 else
4348 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00004349 }
4350
4351 cmdArgs.push_back(args.MakeArgString(
4352 "-fobjc-runtime=" + runtime.getAsString()));
4353 return runtime;
4354}
4355
Reid Klecknerc542d372014-06-27 17:02:02 +00004356static bool maybeConsumeDash(const std::string &EH, size_t &I) {
4357 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
4358 I += HaveDash;
4359 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00004360}
Reid Klecknerc542d372014-06-27 17:02:02 +00004361
4362struct EHFlags {
4363 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
4364 bool Synch;
4365 bool Asynch;
4366 bool NoExceptC;
4367};
4368
4369/// /EH controls whether to run destructor cleanups when exceptions are
4370/// thrown. There are three modifiers:
4371/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
4372/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
4373/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
4374/// - c: Assume that extern "C" functions are implicitly noexcept. This
4375/// modifier is an optimization, so we ignore it for now.
4376/// The default is /EHs-c-, meaning cleanups are disabled.
4377static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4378 EHFlags EH;
4379 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4380 for (auto EHVal : EHArgs) {
4381 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
4382 switch (EHVal[I]) {
4383 case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
4384 case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
4385 case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
4386 default: break;
4387 }
4388 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
4389 break;
4390 }
4391 }
4392 return EH;
4393}
4394
Hans Wennborg75958c42013-08-08 00:17:41 +00004395void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4396 unsigned RTOptionID = options::OPT__SLASH_MT;
4397
Hans Wennborgf1a74252013-09-10 20:18:04 +00004398 if (Args.hasArg(options::OPT__SLASH_LDd))
4399 // The /LDd option implies /MTd. The dependent lib part can be overridden,
4400 // but defining _DEBUG is sticky.
4401 RTOptionID = options::OPT__SLASH_MTd;
4402
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00004403 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00004404 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00004405
Hans Wennborg75958c42013-08-08 00:17:41 +00004406 switch(RTOptionID) {
4407 case options::OPT__SLASH_MD:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004408 if (Args.hasArg(options::OPT__SLASH_LDd))
4409 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004410 CmdArgs.push_back("-D_MT");
4411 CmdArgs.push_back("-D_DLL");
4412 CmdArgs.push_back("--dependent-lib=msvcrt");
4413 break;
4414 case options::OPT__SLASH_MDd:
4415 CmdArgs.push_back("-D_DEBUG");
4416 CmdArgs.push_back("-D_MT");
4417 CmdArgs.push_back("-D_DLL");
4418 CmdArgs.push_back("--dependent-lib=msvcrtd");
4419 break;
4420 case options::OPT__SLASH_MT:
Hans Wennborgf1a74252013-09-10 20:18:04 +00004421 if (Args.hasArg(options::OPT__SLASH_LDd))
4422 CmdArgs.push_back("-D_DEBUG");
Hans Wennborg75958c42013-08-08 00:17:41 +00004423 CmdArgs.push_back("-D_MT");
4424 CmdArgs.push_back("--dependent-lib=libcmt");
4425 break;
4426 case options::OPT__SLASH_MTd:
4427 CmdArgs.push_back("-D_DEBUG");
4428 CmdArgs.push_back("-D_MT");
4429 CmdArgs.push_back("--dependent-lib=libcmtd");
4430 break;
4431 default:
4432 llvm_unreachable("Unexpected option ID.");
4433 }
4434
Reid Kleckner6beca0e2013-08-08 19:33:10 +00004435 // This provides POSIX compatibility (maps 'open' to '_open'), which most
4436 // users want. The /Za flag to cl.exe turns this off, but it's not
4437 // implemented in clang.
4438 CmdArgs.push_back("--dependent-lib=oldnames");
Hans Wennborg614f7072013-08-08 19:54:30 +00004439
Hans Wennborg0fd62072013-08-09 00:32:23 +00004440 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4441 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00004442
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00004443 // RTTI is currently not supported, so disable it by default.
4444 if (!Args.hasArg(options::OPT_frtti, options::OPT_fno_rtti))
4445 CmdArgs.push_back("-fno-rtti");
4446
Reid Klecknerc542d372014-06-27 17:02:02 +00004447 const Driver &D = getToolChain().getDriver();
4448 EHFlags EH = parseClangCLEHFlags(D, Args);
4449 // FIXME: Do something with NoExceptC.
4450 if (EH.Synch || EH.Asynch) {
4451 CmdArgs.push_back("-fexceptions");
4452 CmdArgs.push_back("-fcxx-exceptions");
4453 }
4454
Hans Wennborge50cec32014-06-13 20:59:54 +00004455 // /EP should expand to -E -P.
4456 if (Args.hasArg(options::OPT__SLASH_EP)) {
4457 CmdArgs.push_back("-E");
4458 CmdArgs.push_back("-P");
4459 }
4460
David Majnemer86c318f2014-02-11 21:05:00 +00004461 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4462 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4463 if (MostGeneralArg && BestCaseArg)
4464 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4465 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4466
4467 if (MostGeneralArg) {
4468 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4469 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4470 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4471
4472 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
4473 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
4474 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
4475 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
4476 << FirstConflict->getAsString(Args)
4477 << SecondConflict->getAsString(Args);
4478
4479 if (SingleArg)
4480 CmdArgs.push_back("-fms-memptr-rep=single");
4481 else if (MultipleArg)
4482 CmdArgs.push_back("-fms-memptr-rep=multiple");
4483 else
4484 CmdArgs.push_back("-fms-memptr-rep=virtual");
4485 }
4486
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00004487 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4488 A->render(Args, CmdArgs);
4489
Hans Wennborg81f74482013-09-10 01:07:07 +00004490 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4491 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00004492 if (Args.hasArg(options::OPT__SLASH_fallback))
4493 CmdArgs.push_back("msvc-fallback");
4494 else
4495 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00004496 }
Hans Wennborg75958c42013-08-08 00:17:41 +00004497}
4498
Hans Wennborg1da044a2014-06-26 19:59:02 +00004499visualstudio::Compile *Clang::getCLFallback() const {
4500 if (!CLFallback)
4501 CLFallback.reset(new visualstudio::Compile(getToolChain()));
4502 return CLFallback.get();
4503}
4504
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004505void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004506 const InputInfo &Output,
4507 const InputInfoList &Inputs,
4508 const ArgList &Args,
4509 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004510 ArgStringList CmdArgs;
4511
4512 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4513 const InputInfo &Input = Inputs[0];
4514
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004515 // Don't warn about "clang -w -c foo.s"
4516 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00004517 // and "clang -emit-llvm -c foo.s"
4518 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00004519
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004520 // Invoke ourselves in -cc1as mode.
4521 //
4522 // FIXME: Implement custom jobs for internal actions.
4523 CmdArgs.push_back("-cc1as");
4524
4525 // Add the "effective" target triple.
4526 CmdArgs.push_back("-triple");
Chad Rosierd3a0f952011-09-20 20:44:06 +00004527 std::string TripleStr =
4528 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004529 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4530
4531 // Set the output mode, we currently only expect to be used as a real
4532 // assembler.
4533 CmdArgs.push_back("-filetype");
4534 CmdArgs.push_back("obj");
4535
Eric Christopher45f2e712012-12-18 00:31:10 +00004536 // Set the main file name, so that debug info works even with
4537 // -save-temps or preprocessed assembly.
4538 CmdArgs.push_back("-main-file-name");
4539 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4540
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004541 // Add the target cpu
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004542 const llvm::Triple &Triple = getToolChain().getTriple();
4543 std::string CPU = getCPUName(Args, Triple);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004544 if (!CPU.empty()) {
4545 CmdArgs.push_back("-target-cpu");
4546 CmdArgs.push_back(Args.MakeArgString(CPU));
4547 }
4548
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004549 // Add the target features
4550 const Driver &D = getToolChain().getDriver();
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00004551 getTargetFeatures(D, Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00004552
Daniel Dunbar1d733e22011-03-17 17:37:29 +00004553 // Ignore explicit -force_cpusubtype_ALL option.
4554 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004555
Eric Christopherfc3ee562012-01-10 00:38:01 +00004556 // Determine the original source input.
4557 const Action *SourceAction = &JA;
4558 while (SourceAction->getKind() != Action::InputClass) {
4559 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4560 SourceAction = SourceAction->getInputs()[0];
4561 }
4562
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004563 // Forward -g and handle debug info related flags, assuming we are dealing
4564 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00004565 if (SourceAction->getType() == types::TY_Asm ||
4566 SourceAction->getType() == types::TY_PP_Asm) {
4567 Args.ClaimAllArgs(options::OPT_g_Group);
4568 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4569 if (!A->getOption().matches(options::OPT_g0))
4570 CmdArgs.push_back("-g");
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004571
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00004572 if (Args.hasArg(options::OPT_gdwarf_2))
4573 CmdArgs.push_back("-gdwarf-2");
4574 if (Args.hasArg(options::OPT_gdwarf_3))
4575 CmdArgs.push_back("-gdwarf-3");
4576 if (Args.hasArg(options::OPT_gdwarf_4))
4577 CmdArgs.push_back("-gdwarf-4");
4578
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004579 // Add the -fdebug-compilation-dir flag if needed.
4580 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00004581
4582 // Set the AT_producer to the clang version when using the integrated
4583 // assembler on assembly source files.
4584 CmdArgs.push_back("-dwarf-debug-producer");
4585 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Eric Christopherfc3ee562012-01-10 00:38:01 +00004586 }
Kevin Enderby292dc082011-12-22 19:31:58 +00004587
4588 // Optionally embed the -cc1as level arguments into the debug info, for build
4589 // analysis.
4590 if (getToolChain().UseDwarfDebugFlags()) {
4591 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004592 for (const auto &Arg : Args)
4593 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00004594
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00004595 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00004596 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4597 Flags += Exec;
4598 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4599 Flags += " ";
4600 Flags += OriginalArgs[i];
4601 }
4602 CmdArgs.push_back("-dwarf-debug-flags");
4603 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4604 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004605
4606 // FIXME: Add -static support, once we have it.
4607
David Blaikie372d9502014-01-17 03:17:40 +00004608 // Consume all the warning flags. Usually this would be handled more
4609 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
4610 // doesn't handle that so rather than warning about unused flags that are
4611 // actually used, we'll lie by omission instead.
4612 // FIXME: Stop lying and consume only the appropriate driver flags
4613 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4614 ie = Args.filtered_end();
4615 it != ie; ++it)
4616 (*it)->claim();
4617
David Blaikie9260ed62013-07-25 21:19:01 +00004618 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4619 getToolChain().getDriver());
4620
Daniel Dunbar252e8f92011-04-29 17:53:18 +00004621 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004622
4623 assert(Output.isFilename() && "Unexpected lipo output.");
4624 CmdArgs.push_back("-o");
4625 CmdArgs.push_back(Output.getFilename());
4626
Daniel Dunbarb440f562010-08-02 02:38:21 +00004627 assert(Input.isFilename() && "Invalid input.");
4628 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004629
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00004630 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004631 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christophera75018a2013-04-10 21:30:40 +00004632
4633 // Handle the debug info splitting at object creation time if we're
4634 // creating an object.
4635 // TODO: Currently only works on linux with newer objcopy.
4636 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00004637 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00004638 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4639 SplitDebugName(Args, Inputs));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00004640}
4641
Daniel Dunbara3246a02009-03-18 08:07:30 +00004642void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004643 const InputInfo &Output,
4644 const InputInfoList &Inputs,
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004645 const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00004646 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00004647 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00004648 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004649
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004650 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00004651 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00004652 // Don't forward any -g arguments to assembly steps.
4653 if (isa<AssembleJobAction>(JA) &&
4654 A->getOption().matches(options::OPT_g_Group))
4655 continue;
4656
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00004657 // Don't forward any -W arguments to assembly and link steps.
4658 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4659 A->getOption().matches(options::OPT_W_Group))
4660 continue;
4661
Daniel Dunbar2da02722009-03-19 07:55:12 +00004662 // It is unfortunate that we have to claim here, as this means
4663 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00004664 // platforms using a generic gcc, even if we are just using gcc
4665 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00004666 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004667 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00004668 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004669 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004670
Daniel Dunbar4e295052010-01-25 22:35:08 +00004671 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004672
4673 // If using a driver driver, force the arch.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004674 llvm::Triple::ArchType Arch = getToolChain().getArch();
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00004675 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004676 CmdArgs.push_back("-arch");
Daniel Dunbar0a05d932009-04-01 20:33:11 +00004677
4678 // FIXME: Remove these special cases.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004679 if (Arch == llvm::Triple::ppc)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004680 CmdArgs.push_back("ppc");
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004681 else if (Arch == llvm::Triple::ppc64)
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004682 CmdArgs.push_back("ppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00004683 else if (Arch == llvm::Triple::ppc64le)
4684 CmdArgs.push_back("ppc64le");
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004685 else
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004686 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00004687 }
4688
Daniel Dunbar5716d872009-05-02 21:41:52 +00004689 // Try to force gcc to match the tool chain we want, if we recognize
4690 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00004691 //
4692 // FIXME: The triple class should directly provide the information we want
4693 // here.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00004694 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004695 CmdArgs.push_back("-m32");
Bill Schmidt778d3872013-07-26 01:36:11 +00004696 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4697 Arch == llvm::Triple::ppc64le)
Daniel Dunbar5716d872009-05-02 21:41:52 +00004698 CmdArgs.push_back("-m64");
4699
Daniel Dunbarb440f562010-08-02 02:38:21 +00004700 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004701 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004702 CmdArgs.push_back(Output.getFilename());
4703 } else {
4704 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00004705 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004706 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004707
Tony Linthicum76329bf2011-12-12 21:14:55 +00004708 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4709 options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00004710
4711 // Only pass -x if gcc will understand it; otherwise hope gcc
4712 // understands the suffix correctly. The main use case this would go
4713 // wrong in is for linker inputs if they happened to have an odd
4714 // suffix; really the only way to get this to happen is a command
4715 // like '-x foobar a.c' which will treat a.c like a linker input.
4716 //
4717 // FIXME: For the linker case specifically, can we safely convert
4718 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004719 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004720 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004721 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4722 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004723 D.Diag(diag::err_drv_no_linker_llvm_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004724 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00004725 else if (II.getType() == types::TY_AST)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004726 D.Diag(diag::err_drv_no_ast_support)
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00004727 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004728 else if (II.getType() == types::TY_ModuleFile)
4729 D.Diag(diag::err_drv_no_module_support)
4730 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00004731
Daniel Dunbara3246a02009-03-18 08:07:30 +00004732 if (types::canTypeBeUserSpecified(II.getType())) {
4733 CmdArgs.push_back("-x");
4734 CmdArgs.push_back(types::getTypeName(II.getType()));
4735 }
4736
Daniel Dunbarb440f562010-08-02 02:38:21 +00004737 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004738 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00004739 else {
4740 const Arg &A = II.getInputArg();
4741
4742 // Reverse translate some rewritten options.
4743 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4744 CmdArgs.push_back("-lstdc++");
4745 continue;
4746 }
4747
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00004748 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00004749 A.render(Args, CmdArgs);
4750 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00004751 }
4752
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004753 const std::string customGCCName = D.getCCCGenericGCCName();
4754 const char *GCCName;
4755 if (!customGCCName.empty())
4756 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00004757 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004758 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00004759 } else
4760 GCCName = "gcc";
4761
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004762 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00004763 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00004764 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004765}
4766
Daniel Dunbar4e295052010-01-25 22:35:08 +00004767void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4768 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004769 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004770}
4771
Daniel Dunbar4e295052010-01-25 22:35:08 +00004772void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4773 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004774 const Driver &D = getToolChain().getDriver();
4775
Daniel Dunbar4e295052010-01-25 22:35:08 +00004776 // If -flto, etc. are present then make sure not to force assembly output.
Daniel Dunbar24e52992010-06-07 23:28:45 +00004777 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4778 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
Daniel Dunbar4e295052010-01-25 22:35:08 +00004779 CmdArgs.push_back("-c");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004780 else {
4781 if (JA.getType() != types::TY_PP_Asm)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004782 D.Diag(diag::err_drv_invalid_gcc_output_type)
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004783 << getTypeName(JA.getType());
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004784
Daniel Dunbar4e295052010-01-25 22:35:08 +00004785 CmdArgs.push_back("-S");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00004786 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00004787}
4788
Daniel Dunbar4e295052010-01-25 22:35:08 +00004789void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4790 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00004791 // The types are (hopefully) good enough.
4792}
4793
Tony Linthicum76329bf2011-12-12 21:14:55 +00004794// Hexagon tools start.
4795void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4796 ArgStringList &CmdArgs) const {
4797
4798}
4799void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4800 const InputInfo &Output,
4801 const InputInfoList &Inputs,
4802 const ArgList &Args,
4803 const char *LinkingOutput) const {
4804
4805 const Driver &D = getToolChain().getDriver();
4806 ArgStringList CmdArgs;
4807
4808 std::string MarchString = "-march=";
Matthew Curtisf10a5952012-12-06 14:16:43 +00004809 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00004810 CmdArgs.push_back(Args.MakeArgString(MarchString));
4811
4812 RenderExtraToolArgs(JA, CmdArgs);
4813
4814 if (Output.isFilename()) {
4815 CmdArgs.push_back("-o");
4816 CmdArgs.push_back(Output.getFilename());
4817 } else {
4818 assert(Output.isNothing() && "Unexpected output");
4819 CmdArgs.push_back("-fsyntax-only");
4820 }
4821
Matthew Curtise8f80a12012-12-06 17:49:03 +00004822 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4823 if (!SmallDataThreshold.empty())
4824 CmdArgs.push_back(
4825 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004826
Matthew Curtise5df3812012-12-07 17:23:04 +00004827 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4828 options::OPT_Xassembler);
4829
Tony Linthicum76329bf2011-12-12 21:14:55 +00004830 // Only pass -x if gcc will understand it; otherwise hope gcc
4831 // understands the suffix correctly. The main use case this would go
4832 // wrong in is for linker inputs if they happened to have an odd
4833 // suffix; really the only way to get this to happen is a command
4834 // like '-x foobar a.c' which will treat a.c like a linker input.
4835 //
4836 // FIXME: For the linker case specifically, can we safely convert
4837 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004838 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004839 // Don't try to pass LLVM or AST inputs to a generic gcc.
4840 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4841 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4842 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4843 << getToolChain().getTripleString();
4844 else if (II.getType() == types::TY_AST)
4845 D.Diag(clang::diag::err_drv_no_ast_support)
4846 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004847 else if (II.getType() == types::TY_ModuleFile)
4848 D.Diag(diag::err_drv_no_module_support)
4849 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00004850
4851 if (II.isFilename())
4852 CmdArgs.push_back(II.getFilename());
4853 else
4854 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4855 II.getInputArg().render(Args, CmdArgs);
4856 }
4857
4858 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004859 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004860 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00004861}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004862
Tony Linthicum76329bf2011-12-12 21:14:55 +00004863void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4864 ArgStringList &CmdArgs) const {
4865 // The types are (hopefully) good enough.
4866}
4867
4868void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4869 const InputInfo &Output,
4870 const InputInfoList &Inputs,
4871 const ArgList &Args,
4872 const char *LinkingOutput) const {
4873
Matthew Curtise689b052012-12-06 15:46:07 +00004874 const toolchains::Hexagon_TC& ToolChain =
4875 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4876 const Driver &D = ToolChain.getDriver();
4877
Tony Linthicum76329bf2011-12-12 21:14:55 +00004878 ArgStringList CmdArgs;
4879
Matthew Curtise689b052012-12-06 15:46:07 +00004880 //----------------------------------------------------------------------------
4881 //
4882 //----------------------------------------------------------------------------
4883 bool hasStaticArg = Args.hasArg(options::OPT_static);
4884 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00004885 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00004886 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4887 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4888 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4889 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004890
Matthew Curtise689b052012-12-06 15:46:07 +00004891 //----------------------------------------------------------------------------
4892 // Silence warnings for various options
4893 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00004894
Matthew Curtise689b052012-12-06 15:46:07 +00004895 Args.ClaimAllArgs(options::OPT_g_Group);
4896 Args.ClaimAllArgs(options::OPT_emit_llvm);
4897 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4898 // handled somewhere else.
4899 Args.ClaimAllArgs(options::OPT_static_libgcc);
4900
4901 //----------------------------------------------------------------------------
4902 //
4903 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004904 for (const auto &Opt : ToolChain.ExtraOpts)
4905 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004906
Matthew Curtisf10a5952012-12-06 14:16:43 +00004907 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4908 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00004909
Matthew Curtise689b052012-12-06 15:46:07 +00004910 if (buildingLib) {
4911 CmdArgs.push_back("-shared");
4912 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4913 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00004914 }
4915
Matthew Curtise689b052012-12-06 15:46:07 +00004916 if (hasStaticArg)
4917 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004918
Matthew Curtise8f80a12012-12-06 17:49:03 +00004919 if (buildPIE && !buildingLib)
4920 CmdArgs.push_back("-pie");
4921
4922 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4923 if (!SmallDataThreshold.empty()) {
4924 CmdArgs.push_back(
4925 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4926 }
4927
Matthew Curtise689b052012-12-06 15:46:07 +00004928 //----------------------------------------------------------------------------
4929 //
4930 //----------------------------------------------------------------------------
4931 CmdArgs.push_back("-o");
4932 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00004933
Matthew Curtise689b052012-12-06 15:46:07 +00004934 const std::string MarchSuffix = "/" + MarchString;
4935 const std::string G0Suffix = "/G0";
4936 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4937 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4938 + "/";
4939 const std::string StartFilesDir = RootDir
4940 + "hexagon/lib"
4941 + (buildingLib
4942 ? MarchG0Suffix : MarchSuffix);
4943
4944 //----------------------------------------------------------------------------
4945 // moslib
4946 //----------------------------------------------------------------------------
4947 std::vector<std::string> oslibs;
4948 bool hasStandalone= false;
4949
4950 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4951 ie = Args.filtered_end(); it != ie; ++it) {
4952 (*it)->claim();
4953 oslibs.push_back((*it)->getValue());
4954 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00004955 }
Matthew Curtise689b052012-12-06 15:46:07 +00004956 if (oslibs.empty()) {
4957 oslibs.push_back("standalone");
4958 hasStandalone = true;
4959 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004960
Matthew Curtise689b052012-12-06 15:46:07 +00004961 //----------------------------------------------------------------------------
4962 // Start Files
4963 //----------------------------------------------------------------------------
4964 if (incStdLib && incStartFiles) {
4965
4966 if (!buildingLib) {
4967 if (hasStandalone) {
4968 CmdArgs.push_back(
4969 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4970 }
4971 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4972 }
4973 std::string initObj = useShared ? "/initS.o" : "/init.o";
4974 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4975 }
4976
4977 //----------------------------------------------------------------------------
4978 // Library Search Paths
4979 //----------------------------------------------------------------------------
4980 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00004981 for (const auto &LibPath : LibPaths)
4982 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00004983
4984 //----------------------------------------------------------------------------
4985 //
4986 //----------------------------------------------------------------------------
4987 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4988 Args.AddAllArgs(CmdArgs, options::OPT_e);
4989 Args.AddAllArgs(CmdArgs, options::OPT_s);
4990 Args.AddAllArgs(CmdArgs, options::OPT_t);
4991 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4992
4993 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4994
4995 //----------------------------------------------------------------------------
4996 // Libraries
4997 //----------------------------------------------------------------------------
4998 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00004999 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00005000 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5001 CmdArgs.push_back("-lm");
5002 }
5003
5004 CmdArgs.push_back("--start-group");
5005
5006 if (!buildingLib) {
5007 for(std::vector<std::string>::iterator i = oslibs.begin(),
5008 e = oslibs.end(); i != e; ++i)
5009 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5010 CmdArgs.push_back("-lc");
5011 }
5012 CmdArgs.push_back("-lgcc");
5013
5014 CmdArgs.push_back("--end-group");
5015 }
5016
5017 //----------------------------------------------------------------------------
5018 // End files
5019 //----------------------------------------------------------------------------
5020 if (incStdLib && incStartFiles) {
5021 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5022 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5023 }
5024
5025 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005026 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00005027}
5028// Hexagon tools end.
5029
Bernard Ogden31561762013-12-12 13:27:11 +00005030/// getARMCPUForMArch - Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting
5031//
5032// FIXME: tblgen this.
5033const char *arm::getARMCPUForMArch(const ArgList &Args,
5034 const llvm::Triple &Triple) {
5035 StringRef MArch;
5036 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5037 // Otherwise, if we have -march= choose the base CPU for that arch.
5038 MArch = A->getValue();
5039 } else {
5040 // Otherwise, use the Arch from the triple.
5041 MArch = Triple.getArchName();
5042 }
5043
5044 // Handle -march=native.
Bernard Ogden31561762013-12-12 13:27:11 +00005045 if (MArch == "native") {
5046 std::string CPU = llvm::sys::getHostCPUName();
5047 if (CPU != "generic") {
5048 // Translate the native cpu into the architecture. The switch below will
5049 // then chose the minimum cpu for that arch.
Bernard Ogdenf6ba17d2013-12-12 13:27:15 +00005050 MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
Bernard Ogden31561762013-12-12 13:27:11 +00005051 }
5052 }
5053
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005054 switch (Triple.getOS()) {
5055 case llvm::Triple::NetBSD:
Bernard Ogden31561762013-12-12 13:27:11 +00005056 if (MArch == "armv6")
5057 return "arm1176jzf-s";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005058 break;
5059 case llvm::Triple::Win32:
5060 // FIXME: this is invalid for WindowsCE
5061 return "cortex-a9";
5062 default:
5063 break;
Bernard Ogden31561762013-12-12 13:27:11 +00005064 }
5065
Christian Pirker918d1092014-05-05 08:48:18 +00005066 const char *result = nullptr;
5067 size_t offset = StringRef::npos;
5068 if (MArch.startswith("arm"))
5069 offset = 3;
5070 if (MArch.startswith("thumb"))
5071 offset = 5;
5072 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
5073 offset += 2;
5074 if (offset != StringRef::npos)
5075 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
5076 .Cases("v2", "v2a", "arm2")
5077 .Case("v3", "arm6")
5078 .Case("v3m", "arm7m")
5079 .Case("v4", "strongarm")
5080 .Case("v4t", "arm7tdmi")
5081 .Cases("v5", "v5t", "arm10tdmi")
5082 .Cases("v5e", "v5te", "arm1022e")
5083 .Case("v5tej", "arm926ej-s")
5084 .Cases("v6", "v6k", "arm1136jf-s")
5085 .Case("v6j", "arm1136j-s")
5086 .Cases("v6z", "v6zk", "arm1176jzf-s")
5087 .Case("v6t2", "arm1156t2-s")
5088 .Cases("v6m", "v6-m", "cortex-m0")
5089 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
5090 .Cases("v7s", "v7-s", "swift")
5091 .Cases("v7r", "v7-r", "cortex-r4")
5092 .Cases("v7m", "v7-m", "cortex-m3")
5093 .Cases("v7em", "v7e-m", "cortex-m4")
5094 .Cases("v8", "v8a", "v8-a", "cortex-a53")
5095 .Default(nullptr);
5096 else
5097 result = llvm::StringSwitch<const char *>(MArch)
5098 .Case("ep9312", "ep9312")
5099 .Case("iwmmxt", "iwmmxt")
5100 .Case("xscale", "xscale")
5101 .Default(nullptr);
Bernard Ogden31561762013-12-12 13:27:11 +00005102
5103 if (result)
5104 return result;
5105
Christian Pirker918d1092014-05-05 08:48:18 +00005106 // If all else failed, return the most base CPU with thumb interworking
5107 // supported by LLVM.
5108 // FIXME: Should warn once that we're falling back.
Joerg Sonnenberger695fdb32014-02-21 21:53:33 +00005109 switch (Triple.getOS()) {
5110 case llvm::Triple::NetBSD:
5111 switch (Triple.getEnvironment()) {
5112 case llvm::Triple::GNUEABIHF:
5113 case llvm::Triple::GNUEABI:
5114 case llvm::Triple::EABIHF:
5115 case llvm::Triple::EABI:
5116 return "arm926ej-s";
5117 default:
5118 return "strongarm";
5119 }
5120 default:
5121 switch (Triple.getEnvironment()) {
5122 case llvm::Triple::EABIHF:
5123 case llvm::Triple::GNUEABIHF:
5124 return "arm1176jzf-s";
5125 default:
5126 return "arm7tdmi";
5127 }
5128 }
Bernard Ogden31561762013-12-12 13:27:11 +00005129}
5130
5131/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Rafael Espindola80d333b2013-12-12 15:48:19 +00005132StringRef arm::getARMTargetCPU(const ArgList &Args,
5133 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00005134 // FIXME: Warn on inconsistent use of -mcpu and -march.
5135 // If we have -mcpu=, use that.
5136 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5137 StringRef MCPU = A->getValue();
5138 // Handle -mcpu=native.
5139 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00005140 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00005141 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00005142 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00005143 }
5144
5145 return getARMCPUForMArch(Args, Triple);
5146}
5147
5148/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5149/// CPU.
5150//
5151// FIXME: This is redundant with -mcpu, why does LLVM use this.
5152// FIXME: tblgen this, or kill it!
5153const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
5154 return llvm::StringSwitch<const char *>(CPU)
5155 .Case("strongarm", "v4")
5156 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
5157 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
5158 .Cases("arm920", "arm920t", "arm922t", "v4t")
5159 .Cases("arm940t", "ep9312","v4t")
5160 .Cases("arm10tdmi", "arm1020t", "v5")
5161 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
5162 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
5163 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
5164 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
5165 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
5166 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
Bob Wilsonb767d152014-01-15 21:43:40 +00005167 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "v7")
Bernard Ogden31561762013-12-12 13:27:11 +00005168 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "v7")
5169 .Cases("cortex-r4", "cortex-r5", "v7r")
5170 .Case("cortex-m0", "v6m")
5171 .Case("cortex-m3", "v7m")
5172 .Case("cortex-m4", "v7em")
Bernard Ogden31561762013-12-12 13:27:11 +00005173 .Case("swift", "v7s")
Tim Northovera2ee4332014-03-29 15:09:45 +00005174 .Case("cyclone", "v8")
Bernard Ogden31561762013-12-12 13:27:11 +00005175 .Cases("cortex-a53", "cortex-a57", "v8")
5176 .Default("");
5177}
5178
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005179bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5180 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5181 return A && (A->getValue() == StringRef(Value));
5182}
5183
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00005184bool mips::isNaN2008(const ArgList &Args) {
5185 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5186 return llvm::StringSwitch<bool>(NaNArg->getValue())
5187 .Case("2008", true)
5188 .Case("legacy", false)
5189 .Default(false);
5190
5191 // NaN2008 is the default for MIPS32r6/MIPS64r6.
5192 if (Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ))
5193 return llvm::StringSwitch<bool>(CPUArg->getValue())
5194 .Cases("mips32r6", "mips64r6", true)
5195 .Default(false);
5196
5197 return false;
5198}
5199
Tim Northover157d9112014-01-16 08:48:16 +00005200llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005201 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5202 // archs which Darwin doesn't use.
5203
5204 // The matching this routine does is fairly pointless, since it is neither the
5205 // complete architecture list, nor a reasonable subset. The problem is that
5206 // historically the driver driver accepts this and also ties its -march=
5207 // handling to the architecture name, so we need to be careful before removing
5208 // support for it.
5209
5210 // This code must be kept in sync with Clang's Darwin specific argument
5211 // translation.
5212
5213 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5214 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5215 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5216 .Case("ppc64", llvm::Triple::ppc64)
5217 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5218 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5219 llvm::Triple::x86)
Jim Grosbach82eee262013-11-16 00:53:35 +00005220 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005221 // This is derived from the driver driver.
Bob Wilson743bf672013-03-04 22:37:49 +00005222 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
Bob Wilsonb767d152014-01-15 21:43:40 +00005223 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
Bob Wilson743bf672013-03-04 22:37:49 +00005224 .Cases("armv7s", "xscale", llvm::Triple::arm)
Tim Northovera2ee4332014-03-29 15:09:45 +00005225 .Case("arm64", llvm::Triple::arm64)
Rafael Espindoladcbf6982012-10-31 18:51:07 +00005226 .Case("r600", llvm::Triple::r600)
5227 .Case("nvptx", llvm::Triple::nvptx)
5228 .Case("nvptx64", llvm::Triple::nvptx64)
5229 .Case("amdil", llvm::Triple::amdil)
5230 .Case("spir", llvm::Triple::spir)
5231 .Default(llvm::Triple::UnknownArch);
5232}
Tony Linthicum76329bf2011-12-12 21:14:55 +00005233
Tim Northover157d9112014-01-16 08:48:16 +00005234void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5235 llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5236 T.setArch(Arch);
5237
5238 if (Str == "x86_64h")
5239 T.setArchName(Str);
5240 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5241 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00005242 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00005243 }
5244}
5245
Bob Wilsondecc03e2012-11-23 06:14:39 +00005246const char *Clang::getBaseInputName(const ArgList &Args,
5247 const InputInfoList &Inputs) {
Michael J. Spencere1696752010-12-18 00:19:12 +00005248 return Args.MakeArgString(
5249 llvm::sys::path::filename(Inputs[0].getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005250}
5251
Bob Wilsondecc03e2012-11-23 06:14:39 +00005252const char *Clang::getBaseInputStem(const ArgList &Args,
5253 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005254 const char *Str = getBaseInputName(Args, Inputs);
5255
Chris Lattner906bb902011-01-16 08:14:11 +00005256 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005257 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005258
5259 return Str;
5260}
5261
Bob Wilsondecc03e2012-11-23 06:14:39 +00005262const char *Clang::getDependencyFileName(const ArgList &Args,
5263 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005264 // FIXME: Think about this more.
5265 std::string Res;
5266
5267 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005268 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005269 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005270 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00005271 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00005272 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00005273 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00005274}
5275
Daniel Dunbarbe220842009-03-20 16:06:39 +00005276void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005277 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005278 const InputInfoList &Inputs,
5279 const ArgList &Args,
Daniel Dunbarbe220842009-03-20 16:06:39 +00005280 const char *LinkingOutput) const {
5281 ArgStringList CmdArgs;
5282
5283 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5284 const InputInfo &Input = Inputs[0];
5285
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005286 // Determine the original source input.
5287 const Action *SourceAction = &JA;
5288 while (SourceAction->getKind() != Action::InputClass) {
5289 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5290 SourceAction = SourceAction->getInputs()[0];
5291 }
5292
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005293 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00005294 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00005295 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
5296 // FIXME: at run-time detect assembler capabilities or rely on version
5297 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00005298 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00005299 const llvm::Triple &T(getToolChain().getTriple());
5300 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00005301 CmdArgs.push_back("-Q");
5302 }
Kevin Enderby319baa42013-11-18 23:30:29 +00005303
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005304 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00005305 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00005306 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005307 if (Args.hasArg(options::OPT_gstabs))
5308 CmdArgs.push_back("--gstabs");
5309 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00005310 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00005311 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005312
Daniel Dunbarbe220842009-03-20 16:06:39 +00005313 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00005314 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00005315
Daniel Dunbar6d484762010-07-22 01:47:22 +00005316 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005317 if (getToolChain().getArch() == llvm::Triple::x86 ||
5318 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00005319 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5320 CmdArgs.push_back("-force_cpusubtype_ALL");
5321
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005322 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005323 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00005324 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00005325 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00005326 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005327 CmdArgs.push_back("-static");
5328
Daniel Dunbarbe220842009-03-20 16:06:39 +00005329 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5330 options::OPT_Xassembler);
5331
5332 assert(Output.isFilename() && "Unexpected lipo output.");
5333 CmdArgs.push_back("-o");
5334 CmdArgs.push_back(Output.getFilename());
5335
Daniel Dunbarb440f562010-08-02 02:38:21 +00005336 assert(Input.isFilename() && "Invalid input.");
5337 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00005338
5339 // asm_final spec is empty.
5340
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005341 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005342 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005343 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00005344}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005345
Tim Northover157d9112014-01-16 08:48:16 +00005346void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00005347
Tim Northover157d9112014-01-16 08:48:16 +00005348void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5349 ArgStringList &CmdArgs) const {
5350 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005351
Daniel Dunbarc1964212009-03-26 16:23:12 +00005352 // Derived from darwin_arch spec.
5353 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005354 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005355
Daniel Dunbardcc3b652010-01-22 02:04:58 +00005356 // FIXME: Is this needed anymore?
5357 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00005358 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00005359}
5360
Bill Wendling3b2000f2012-10-02 18:02:50 +00005361bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
5362 // We only need to generate a temp path for LTO if we aren't compiling object
5363 // files. When compiling source files, we run 'dsymutil' after linking. We
5364 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005365 for (const auto &Input : Inputs)
5366 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00005367 return true;
5368
5369 return false;
5370}
5371
Daniel Dunbarccbc4522010-09-09 21:51:05 +00005372void darwin::Link::AddLinkArgs(Compilation &C,
5373 const ArgList &Args,
Bill Wendling3b2000f2012-10-02 18:02:50 +00005374 ArgStringList &CmdArgs,
5375 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005376 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00005377 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00005378
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005379 unsigned Version[3] = { 0, 0, 0 };
5380 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5381 bool HadExtra;
Richard Smithbd55daf2012-11-01 04:30:05 +00005382 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005383 Version[1], Version[2], HadExtra) ||
5384 HadExtra)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005385 D.Diag(diag::err_drv_invalid_version_number)
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005386 << A->getAsString(Args);
5387 }
5388
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005389 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005390 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00005391 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5392 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00005393
Bob Wilson3d27dad2013-08-02 22:25:34 +00005394 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5395 CmdArgs.push_back("-export_dynamic");
5396
Bill Wendling313b6bf2012-11-16 23:03:00 +00005397 // If we are using LTO, then automatically create a temporary file path for
5398 // the linker to use, so that it's lifetime will extend past a possible
5399 // dsymutil step.
5400 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5401 const char *TmpPath = C.getArgs().MakeArgString(
5402 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
5403 C.addTempFile(TmpPath);
5404 CmdArgs.push_back("-object_path_lto");
5405 CmdArgs.push_back(TmpPath);
Daniel Dunbaref889c72011-06-21 20:55:11 +00005406 }
5407
Daniel Dunbarc1964212009-03-26 16:23:12 +00005408 // Derived from the "link" spec.
5409 Args.AddAllArgs(CmdArgs, options::OPT_static);
5410 if (!Args.hasArg(options::OPT_static))
5411 CmdArgs.push_back("-dynamic");
5412 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5413 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5414 // here. How do we wish to handle such things?
5415 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005416
Daniel Dunbarc1964212009-03-26 16:23:12 +00005417 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00005418 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00005419 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00005420 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005421
5422 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5423 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5424 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5425
5426 Arg *A;
5427 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5428 (A = Args.getLastArg(options::OPT_current__version)) ||
5429 (A = Args.getLastArg(options::OPT_install__name)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005430 D.Diag(diag::err_drv_argument_only_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005431 << A->getAsString(Args) << "-dynamiclib";
5432
5433 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5434 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5435 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5436 } else {
5437 CmdArgs.push_back("-dylib");
5438
5439 Arg *A;
5440 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5441 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5442 (A = Args.getLastArg(options::OPT_client__name)) ||
5443 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5444 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5445 (A = Args.getLastArg(options::OPT_private__bundle)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005446 D.Diag(diag::err_drv_argument_not_allowed_with)
Daniel Dunbarc1964212009-03-26 16:23:12 +00005447 << A->getAsString(Args) << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005448
Daniel Dunbarc1964212009-03-26 16:23:12 +00005449 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5450 "-dylib_compatibility_version");
5451 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5452 "-dylib_current_version");
5453
Tim Northover157d9112014-01-16 08:48:16 +00005454 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005455
5456 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5457 "-dylib_install_name");
5458 }
5459
5460 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5461 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5462 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00005463 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005464 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005465 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5466 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5467 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5468 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5469 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5470 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00005471 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005472 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5473 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5474 Args.AddAllArgs(CmdArgs, options::OPT_init);
5475
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005476 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00005477 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00005478
Daniel Dunbarc1964212009-03-26 16:23:12 +00005479 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5480 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5481 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5482 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5483 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005484
Daniel Dunbaraf68a882010-07-13 23:31:40 +00005485 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5486 options::OPT_fno_pie,
5487 options::OPT_fno_PIE)) {
5488 if (A->getOption().matches(options::OPT_fpie) ||
5489 A->getOption().matches(options::OPT_fPIE))
5490 CmdArgs.push_back("-pie");
5491 else
5492 CmdArgs.push_back("-no_pie");
5493 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005494
5495 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5496 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5497 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5498 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5499 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5500 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5501 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5502 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5503 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5504 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5505 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5506 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5507 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5508 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5509 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5510 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005511
Daniel Dunbar84384642011-05-02 21:03:47 +00005512 // Give --sysroot= preference, over the Apple specific behavior to also use
5513 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00005514 StringRef sysroot = C.getSysRoot();
5515 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00005516 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00005517 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00005518 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5519 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00005520 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005521 }
5522
Daniel Dunbarc1964212009-03-26 16:23:12 +00005523 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5524 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5525 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5526 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5527 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00005528 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005529 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5530 Args.AddAllArgs(CmdArgs, options::OPT_y);
5531 Args.AddLastArg(CmdArgs, options::OPT_w);
5532 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5533 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5534 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5535 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5536 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5537 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5538 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5539 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5540 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5541 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5542 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5543 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5544}
5545
Alexey Bataev186b28a2014-03-06 05:43:53 +00005546enum LibOpenMP {
5547 LibUnknown,
5548 LibGOMP,
5549 LibIOMP5
5550};
5551
Daniel Dunbarc1964212009-03-26 16:23:12 +00005552void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005553 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005554 const InputInfoList &Inputs,
5555 const ArgList &Args,
Daniel Dunbarc1964212009-03-26 16:23:12 +00005556 const char *LinkingOutput) const {
5557 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00005558
Daniel Dunbarc1964212009-03-26 16:23:12 +00005559 // The logic here is derived from gcc's behavior; most of which
5560 // comes from specs (starting with link_command). Consult gcc for
5561 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00005562 ArgStringList CmdArgs;
5563
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005564 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
5565 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5566 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005567 for (const auto &Arg : Args)
5568 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00005569 const char *Exec =
5570 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5571 CmdArgs.push_back(Output.getFilename());
5572 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5573 return;
5574 }
5575
Daniel Dunbarc1964212009-03-26 16:23:12 +00005576 // I'm not sure why this particular decomposition exists in gcc, but
5577 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00005578 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005579
Daniel Dunbarc1964212009-03-26 16:23:12 +00005580 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5581 Args.AddAllArgs(CmdArgs, options::OPT_s);
5582 Args.AddAllArgs(CmdArgs, options::OPT_t);
5583 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5584 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005585 Args.AddLastArg(CmdArgs, options::OPT_e);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005586 Args.AddAllArgs(CmdArgs, options::OPT_r);
5587
Daniel Dunbar767bbab2010-10-18 22:08:36 +00005588 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
5589 // members of static archive libraries which implement Objective-C classes or
5590 // categories.
5591 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5592 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005593
Daniel Dunbarc1964212009-03-26 16:23:12 +00005594 CmdArgs.push_back("-o");
5595 CmdArgs.push_back(Output.getFilename());
5596
Chad Rosier06fd3c62012-05-16 23:45:12 +00005597 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00005598 !Args.hasArg(options::OPT_nostartfiles))
5599 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005600
5601 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005602
Alexey Bataev186b28a2014-03-06 05:43:53 +00005603 LibOpenMP UsedOpenMPLib = LibUnknown;
5604 if (Args.hasArg(options::OPT_fopenmp)) {
5605 UsedOpenMPLib = LibGOMP;
5606 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5607 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
5608 .Case("libgomp", LibGOMP)
5609 .Case("libiomp5", LibIOMP5)
5610 .Default(LibUnknown);
5611 if (UsedOpenMPLib == LibUnknown)
5612 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
5613 << A->getOption().getName() << A->getValue();
5614 }
5615 switch (UsedOpenMPLib) {
5616 case LibGOMP:
Daniel Dunbarc1964212009-03-26 16:23:12 +00005617 CmdArgs.push_back("-lgomp");
Alexey Bataev186b28a2014-03-06 05:43:53 +00005618 break;
5619 case LibIOMP5:
5620 CmdArgs.push_back("-liomp5");
5621 break;
5622 case LibUnknown:
5623 break;
5624 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00005625
Douglas Gregor9295df02012-05-15 21:00:27 +00005626 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5627
Bob Wilson16d93952012-05-15 18:57:39 +00005628 if (isObjCRuntimeLinked(Args) &&
5629 !Args.hasArg(options::OPT_nostdlib) &&
5630 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00005631 // We use arclite library for both ARC and subscripting support.
5632 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5633
Bob Wilson7dda0cd2012-04-21 00:21:42 +00005634 CmdArgs.push_back("-framework");
5635 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00005636 // Link libobj.
5637 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00005638 }
John McCall31168b02011-06-15 23:02:42 +00005639
Daniel Dunbarc1964212009-03-26 16:23:12 +00005640 if (LinkingOutput) {
5641 CmdArgs.push_back("-arch_multiple");
5642 CmdArgs.push_back("-final_output");
5643 CmdArgs.push_back(LinkingOutput);
5644 }
5645
Daniel Dunbarc1964212009-03-26 16:23:12 +00005646 if (Args.hasArg(options::OPT_fnested_functions))
5647 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005648
Daniel Dunbarc1964212009-03-26 16:23:12 +00005649 if (!Args.hasArg(options::OPT_nostdlib) &&
5650 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005651 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00005652 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00005653
Daniel Dunbarc1964212009-03-26 16:23:12 +00005654 // link_ssp spec is empty.
5655
Daniel Dunbar26d482a2009-09-18 08:15:03 +00005656 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00005657 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00005658 }
5659
Chad Rosier06fd3c62012-05-16 23:45:12 +00005660 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00005661 !Args.hasArg(options::OPT_nostartfiles)) {
5662 // endfile_spec is empty.
5663 }
5664
5665 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5666 Args.AddAllArgs(CmdArgs, options::OPT_F);
5667
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005668 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005669 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005670 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarc1964212009-03-26 16:23:12 +00005671}
5672
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005673void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005674 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005675 const InputInfoList &Inputs,
5676 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005677 const char *LinkingOutput) const {
5678 ArgStringList CmdArgs;
5679
5680 CmdArgs.push_back("-create");
5681 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005682
5683 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005684 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00005685
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005686 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005687 assert(II.isFilename() && "Unexpected lipo input.");
5688 CmdArgs.push_back(II.getFilename());
5689 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005690
5691 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005692 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00005693}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00005694
Daniel Dunbar88299622010-06-04 18:28:36 +00005695void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005696 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00005697 const InputInfoList &Inputs,
5698 const ArgList &Args,
5699 const char *LinkingOutput) const {
5700 ArgStringList CmdArgs;
5701
Daniel Dunbareb86b042011-05-09 17:23:16 +00005702 CmdArgs.push_back("-o");
5703 CmdArgs.push_back(Output.getFilename());
5704
Daniel Dunbar88299622010-06-04 18:28:36 +00005705 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5706 const InputInfo &Input = Inputs[0];
5707 assert(Input.isFilename() && "Unexpected dsymutil input.");
5708 CmdArgs.push_back(Input.getFilename());
5709
Daniel Dunbar88299622010-06-04 18:28:36 +00005710 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005711 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005712 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar88299622010-06-04 18:28:36 +00005713}
5714
Eric Christopher551ef452011-08-23 17:56:55 +00005715void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00005716 const InputInfo &Output,
5717 const InputInfoList &Inputs,
5718 const ArgList &Args,
5719 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00005720 ArgStringList CmdArgs;
5721 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00005722 CmdArgs.push_back("--debug-info");
5723 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00005724 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00005725
5726 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5727 const InputInfo &Input = Inputs[0];
5728 assert(Input.isFilename() && "Unexpected verify input");
5729
5730 // Grabbing the output of the earlier dsymutil run.
5731 CmdArgs.push_back(Input.getFilename());
5732
5733 const char *Exec =
5734 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5735 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5736}
5737
David Chisnallf571cde2012-02-15 13:39:01 +00005738void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5739 const InputInfo &Output,
5740 const InputInfoList &Inputs,
5741 const ArgList &Args,
5742 const char *LinkingOutput) const {
5743 ArgStringList CmdArgs;
5744
5745 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5746 options::OPT_Xassembler);
5747
5748 CmdArgs.push_back("-o");
5749 CmdArgs.push_back(Output.getFilename());
5750
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005751 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00005752 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00005753
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005754 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
David Chisnallf571cde2012-02-15 13:39:01 +00005755 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5756}
5757
David Chisnallf571cde2012-02-15 13:39:01 +00005758void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5759 const InputInfo &Output,
5760 const InputInfoList &Inputs,
5761 const ArgList &Args,
5762 const char *LinkingOutput) const {
5763 // FIXME: Find a real GCC, don't hard-code versions here
5764 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5765 const llvm::Triple &T = getToolChain().getTriple();
5766 std::string LibPath = "/usr/lib/";
5767 llvm::Triple::ArchType Arch = T.getArch();
5768 switch (Arch) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00005769 case llvm::Triple::x86:
5770 GCCLibPath +=
5771 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5772 break;
5773 case llvm::Triple::x86_64:
5774 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5775 GCCLibPath += "/4.5.2/amd64/";
5776 LibPath += "amd64/";
5777 break;
5778 default:
5779 llvm_unreachable("Unsupported architecture");
David Chisnallf571cde2012-02-15 13:39:01 +00005780 }
5781
5782 ArgStringList CmdArgs;
5783
David Chisnall272a0712012-02-29 15:06:12 +00005784 // Demangle C++ names in errors
5785 CmdArgs.push_back("-C");
5786
David Chisnallf571cde2012-02-15 13:39:01 +00005787 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5788 (!Args.hasArg(options::OPT_shared))) {
5789 CmdArgs.push_back("-e");
5790 CmdArgs.push_back("_start");
5791 }
5792
5793 if (Args.hasArg(options::OPT_static)) {
5794 CmdArgs.push_back("-Bstatic");
5795 CmdArgs.push_back("-dn");
5796 } else {
5797 CmdArgs.push_back("-Bdynamic");
5798 if (Args.hasArg(options::OPT_shared)) {
5799 CmdArgs.push_back("-shared");
5800 } else {
5801 CmdArgs.push_back("--dynamic-linker");
5802 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5803 }
5804 }
5805
5806 if (Output.isFilename()) {
5807 CmdArgs.push_back("-o");
5808 CmdArgs.push_back(Output.getFilename());
5809 } else {
5810 assert(Output.isNothing() && "Invalid output.");
5811 }
5812
5813 if (!Args.hasArg(options::OPT_nostdlib) &&
5814 !Args.hasArg(options::OPT_nostartfiles)) {
5815 if (!Args.hasArg(options::OPT_shared)) {
5816 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5817 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005818 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005819 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5820 } else {
5821 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
David Chisnall0c52c0f2012-02-28 17:10:04 +00005822 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5823 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005824 }
Hans Wennborg70850d82013-07-18 20:29:38 +00005825 if (getToolChain().getDriver().CCCIsCXX())
David Chisnallddc4c9d2012-03-13 14:14:54 +00005826 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005827 }
5828
5829 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5830
5831 Args.AddAllArgs(CmdArgs, options::OPT_L);
5832 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5833 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall0c52c0f2012-02-28 17:10:04 +00005834 Args.AddAllArgs(CmdArgs, options::OPT_r);
David Chisnallf571cde2012-02-15 13:39:01 +00005835
5836 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5837
5838 if (!Args.hasArg(options::OPT_nostdlib) &&
5839 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00005840 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00005841 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00005842 CmdArgs.push_back("-lgcc_s");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005843 if (!Args.hasArg(options::OPT_shared)) {
5844 CmdArgs.push_back("-lgcc");
David Chisnallf571cde2012-02-15 13:39:01 +00005845 CmdArgs.push_back("-lc");
David Chisnallc73fb892012-02-28 20:06:45 +00005846 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00005847 }
David Chisnallf571cde2012-02-15 13:39:01 +00005848 }
5849
5850 if (!Args.hasArg(options::OPT_nostdlib) &&
5851 !Args.hasArg(options::OPT_nostartfiles)) {
David Chisnall0c52c0f2012-02-28 17:10:04 +00005852 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005853 }
David Chisnall96de9932012-02-16 16:00:47 +00005854 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
David Chisnallf571cde2012-02-15 13:39:01 +00005855
Alexey Samsonov7811d192014-02-20 13:57:37 +00005856 addProfileRT(getToolChain(), Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00005857
5858 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005859 Args.MakeArgString(getToolChain().GetLinkerPath());
David Chisnallf571cde2012-02-15 13:39:01 +00005860 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5861}
5862
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005863void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005864 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005865 const InputInfoList &Inputs,
5866 const ArgList &Args,
5867 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005868 ArgStringList CmdArgs;
5869
5870 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5871 options::OPT_Xassembler);
5872
5873 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00005874 CmdArgs.push_back(Output.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005875
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005876 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00005877 CmdArgs.push_back(II.getFilename());
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005878
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005879 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005880 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005881}
5882
5883void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005884 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005885 const InputInfoList &Inputs,
5886 const ArgList &Args,
5887 const char *LinkingOutput) const {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005888 ArgStringList CmdArgs;
5889
5890 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005891 (!Args.hasArg(options::OPT_shared))) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005892 CmdArgs.push_back("-e");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005893 CmdArgs.push_back("_start");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005894 }
5895
5896 if (Args.hasArg(options::OPT_static)) {
5897 CmdArgs.push_back("-Bstatic");
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005898 CmdArgs.push_back("-dn");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005899 } else {
Edward O'Callaghand8712d92009-10-15 07:44:07 +00005900// CmdArgs.push_back("--eh-frame-hdr");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005901 CmdArgs.push_back("-Bdynamic");
5902 if (Args.hasArg(options::OPT_shared)) {
5903 CmdArgs.push_back("-shared");
5904 } else {
Edward O'Callaghan7d3c2752009-10-16 19:44:18 +00005905 CmdArgs.push_back("--dynamic-linker");
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005906 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5907 }
5908 }
5909
Daniel Dunbarb440f562010-08-02 02:38:21 +00005910 if (Output.isFilename()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005911 CmdArgs.push_back("-o");
5912 CmdArgs.push_back(Output.getFilename());
5913 } else {
5914 assert(Output.isNothing() && "Invalid output.");
5915 }
5916
5917 if (!Args.hasArg(options::OPT_nostdlib) &&
5918 !Args.hasArg(options::OPT_nostartfiles)) {
5919 if (!Args.hasArg(options::OPT_shared)) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005920 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005921 getToolChain().GetFilePath("crt1.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005922 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005923 getToolChain().GetFilePath("crti.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00005924 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005925 getToolChain().GetFilePath("crtbegin.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005926 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00005927 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005928 getToolChain().GetFilePath("crti.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005929 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00005930 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005931 getToolChain().GetFilePath("crtn.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005932 }
5933
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00005934 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5935 + getToolChain().getTripleString()
Daniel Dunbarb0b18612009-10-29 02:24:37 +00005936 + "/4.2.4"));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005937
5938 Args.AddAllArgs(CmdArgs, options::OPT_L);
5939 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5940 Args.AddAllArgs(CmdArgs, options::OPT_e);
5941
Daniel Dunbar54423b22010-09-17 00:24:54 +00005942 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005943
5944 if (!Args.hasArg(options::OPT_nostdlib) &&
5945 !Args.hasArg(options::OPT_nodefaultlibs)) {
5946 // FIXME: For some reason GCC passes -lgcc before adding
5947 // the default system libraries. Just mimic this for now.
5948 CmdArgs.push_back("-lgcc");
5949
5950 if (Args.hasArg(options::OPT_pthread))
5951 CmdArgs.push_back("-pthread");
5952 if (!Args.hasArg(options::OPT_shared))
5953 CmdArgs.push_back("-lc");
5954 CmdArgs.push_back("-lgcc");
5955 }
5956
5957 if (!Args.hasArg(options::OPT_nostdlib) &&
5958 !Args.hasArg(options::OPT_nostartfiles)) {
5959 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00005960 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00005961 getToolChain().GetFilePath("crtend.o")));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005962 }
5963
Alexey Samsonov7811d192014-02-20 13:57:37 +00005964 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00005965
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005966 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00005967 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005968 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00005969}
5970
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005971void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00005972 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005973 const InputInfoList &Inputs,
5974 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00005975 const char *LinkingOutput) const {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005976 ArgStringList CmdArgs;
Rafael Espindolacc126272014-02-28 01:55:21 +00005977 bool NeedsKPIC = false;
Daniel Dunbar10de9e62009-06-29 20:52:51 +00005978
Rafael Espindolacc126272014-02-28 01:55:21 +00005979 switch (getToolChain().getArch()) {
5980 case llvm::Triple::x86:
5981 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5982 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005983 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00005984 break;
5985
5986 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00005987 CmdArgs.push_back("-mppc");
5988 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00005989 break;
5990
5991 case llvm::Triple::sparc:
5992 CmdArgs.push_back("-32");
5993 NeedsKPIC = true;
5994 break;
5995
5996 case llvm::Triple::sparcv9:
5997 CmdArgs.push_back("-64");
5998 CmdArgs.push_back("-Av9a");
5999 NeedsKPIC = true;
6000 break;
6001
6002 case llvm::Triple::mips64:
6003 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006004 StringRef CPUName;
6005 StringRef ABIName;
6006 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6007
6008 CmdArgs.push_back("-mabi");
6009 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6010
6011 if (getToolChain().getArch() == llvm::Triple::mips64)
6012 CmdArgs.push_back("-EB");
6013 else
6014 CmdArgs.push_back("-EL");
6015
Rafael Espindolacc126272014-02-28 01:55:21 +00006016 NeedsKPIC = true;
6017 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006018 }
6019
Rafael Espindolacc126272014-02-28 01:55:21 +00006020 default:
6021 break;
6022 }
6023
6024 if (NeedsKPIC)
6025 addAssemblerKPIC(Args, CmdArgs);
6026
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006027 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6028 options::OPT_Xassembler);
6029
6030 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006031 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006032
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006033 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006034 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006035
6036 const char *Exec =
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006037 Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006038 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006039}
6040
6041void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006042 const InputInfo &Output,
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006043 const InputInfoList &Inputs,
6044 const ArgList &Args,
6045 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006046 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006047 ArgStringList CmdArgs;
6048
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006049 // Silence warning for "clang -g foo.o -o foo"
6050 Args.ClaimAllArgs(options::OPT_g_Group);
6051 // and "clang -emit-llvm foo.o -o foo"
6052 Args.ClaimAllArgs(options::OPT_emit_llvm);
6053 // and for "clang -w foo.o -o foo". Other warning options are already
6054 // handled somewhere else.
6055 Args.ClaimAllArgs(options::OPT_w);
6056
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00006057 if (getToolChain().getArch() == llvm::Triple::mips64)
6058 CmdArgs.push_back("-EB");
6059 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6060 CmdArgs.push_back("-EL");
6061
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006062 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006063 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006064 CmdArgs.push_back("-e");
6065 CmdArgs.push_back("__start");
6066 }
6067
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006068 if (Args.hasArg(options::OPT_static)) {
6069 CmdArgs.push_back("-Bstatic");
6070 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006071 if (Args.hasArg(options::OPT_rdynamic))
6072 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006073 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006074 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006075 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006076 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006077 } else {
6078 CmdArgs.push_back("-dynamic-linker");
6079 CmdArgs.push_back("/usr/libexec/ld.so");
6080 }
6081 }
6082
Rafael Espindola044f7832013-06-05 04:28:55 +00006083 if (Args.hasArg(options::OPT_nopie))
6084 CmdArgs.push_back("-nopie");
6085
Daniel Dunbarb440f562010-08-02 02:38:21 +00006086 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006087 CmdArgs.push_back("-o");
6088 CmdArgs.push_back(Output.getFilename());
6089 } else {
6090 assert(Output.isNothing() && "Invalid output.");
6091 }
6092
6093 if (!Args.hasArg(options::OPT_nostdlib) &&
6094 !Args.hasArg(options::OPT_nostartfiles)) {
6095 if (!Args.hasArg(options::OPT_shared)) {
Eli Friedman3715d1f2011-12-15 02:15:56 +00006096 if (Args.hasArg(options::OPT_pg))
6097 CmdArgs.push_back(Args.MakeArgString(
6098 getToolChain().GetFilePath("gcrt0.o")));
6099 else
6100 CmdArgs.push_back(Args.MakeArgString(
6101 getToolChain().GetFilePath("crt0.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00006102 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006103 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006104 } else {
Chris Lattner3e2ee142010-07-07 16:01:42 +00006105 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006106 getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006107 }
6108 }
6109
Edward O'Callaghan5c521462009-10-28 15:13:08 +00006110 std::string Triple = getToolChain().getTripleString();
6111 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00006112 Triple.replace(0, 6, "amd64");
Daniel Dunbarb0b18612009-10-29 02:24:37 +00006113 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006114 "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006115
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006116 Args.AddAllArgs(CmdArgs, options::OPT_L);
6117 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6118 Args.AddAllArgs(CmdArgs, options::OPT_e);
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00006119 Args.AddAllArgs(CmdArgs, options::OPT_s);
6120 Args.AddAllArgs(CmdArgs, options::OPT_t);
6121 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6122 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006123
Daniel Dunbar54423b22010-09-17 00:24:54 +00006124 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006125
6126 if (!Args.hasArg(options::OPT_nostdlib) &&
6127 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006128 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006129 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Eli Friedman3715d1f2011-12-15 02:15:56 +00006130 if (Args.hasArg(options::OPT_pg))
6131 CmdArgs.push_back("-lm_p");
6132 else
6133 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00006134 }
6135
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006136 // FIXME: For some reason GCC passes -lgcc before adding
6137 // the default system libraries. Just mimic this for now.
6138 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006139
Eric Christopher17674ec2012-09-13 06:32:34 +00006140 if (Args.hasArg(options::OPT_pthread)) {
6141 if (!Args.hasArg(options::OPT_shared) &&
6142 Args.hasArg(options::OPT_pg))
6143 CmdArgs.push_back("-lpthread_p");
6144 else
6145 CmdArgs.push_back("-lpthread");
6146 }
6147
Chandler Carruth45661652011-12-17 22:32:42 +00006148 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00006149 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00006150 CmdArgs.push_back("-lc_p");
6151 else
6152 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00006153 }
Eric Christopher17674ec2012-09-13 06:32:34 +00006154
Daniel Dunbara8888ac2009-08-03 01:28:59 +00006155 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006156 }
6157
6158 if (!Args.hasArg(options::OPT_nostdlib) &&
6159 !Args.hasArg(options::OPT_nostartfiles)) {
6160 if (!Args.hasArg(options::OPT_shared))
Chris Lattner3e2ee142010-07-07 16:01:42 +00006161 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006162 getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006163 else
Chris Lattner3e2ee142010-07-07 16:01:42 +00006164 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00006165 getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006166 }
6167
6168 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006169 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006170 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00006171}
Ed Schoutene33194b2009-04-02 19:13:12 +00006172
Eli Friedman9fa28852012-08-08 23:57:20 +00006173void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6174 const InputInfo &Output,
6175 const InputInfoList &Inputs,
6176 const ArgList &Args,
6177 const char *LinkingOutput) const {
6178 ArgStringList CmdArgs;
6179
6180 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6181 options::OPT_Xassembler);
6182
6183 CmdArgs.push_back("-o");
6184 CmdArgs.push_back(Output.getFilename());
6185
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006186 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00006187 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00006188
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006189 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Eli Friedman9fa28852012-08-08 23:57:20 +00006190 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6191}
6192
6193void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
6194 const InputInfo &Output,
6195 const InputInfoList &Inputs,
6196 const ArgList &Args,
6197 const char *LinkingOutput) const {
6198 const Driver &D = getToolChain().getDriver();
6199 ArgStringList CmdArgs;
6200
6201 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6202 (!Args.hasArg(options::OPT_shared))) {
6203 CmdArgs.push_back("-e");
6204 CmdArgs.push_back("__start");
6205 }
6206
6207 if (Args.hasArg(options::OPT_static)) {
6208 CmdArgs.push_back("-Bstatic");
6209 } else {
6210 if (Args.hasArg(options::OPT_rdynamic))
6211 CmdArgs.push_back("-export-dynamic");
6212 CmdArgs.push_back("--eh-frame-hdr");
6213 CmdArgs.push_back("-Bdynamic");
6214 if (Args.hasArg(options::OPT_shared)) {
6215 CmdArgs.push_back("-shared");
6216 } else {
6217 CmdArgs.push_back("-dynamic-linker");
6218 CmdArgs.push_back("/usr/libexec/ld.so");
6219 }
6220 }
6221
6222 if (Output.isFilename()) {
6223 CmdArgs.push_back("-o");
6224 CmdArgs.push_back(Output.getFilename());
6225 } else {
6226 assert(Output.isNothing() && "Invalid output.");
6227 }
6228
6229 if (!Args.hasArg(options::OPT_nostdlib) &&
6230 !Args.hasArg(options::OPT_nostartfiles)) {
6231 if (!Args.hasArg(options::OPT_shared)) {
6232 if (Args.hasArg(options::OPT_pg))
6233 CmdArgs.push_back(Args.MakeArgString(
6234 getToolChain().GetFilePath("gcrt0.o")));
6235 else
6236 CmdArgs.push_back(Args.MakeArgString(
6237 getToolChain().GetFilePath("crt0.o")));
6238 CmdArgs.push_back(Args.MakeArgString(
6239 getToolChain().GetFilePath("crtbegin.o")));
6240 } else {
6241 CmdArgs.push_back(Args.MakeArgString(
6242 getToolChain().GetFilePath("crtbeginS.o")));
6243 }
6244 }
6245
6246 Args.AddAllArgs(CmdArgs, options::OPT_L);
6247 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6248 Args.AddAllArgs(CmdArgs, options::OPT_e);
6249
6250 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6251
6252 if (!Args.hasArg(options::OPT_nostdlib) &&
6253 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006254 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00006255 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6256 if (Args.hasArg(options::OPT_pg))
6257 CmdArgs.push_back("-lm_p");
6258 else
6259 CmdArgs.push_back("-lm");
6260 }
6261
Rafael Espindola1ad26f02012-10-23 17:07:31 +00006262 if (Args.hasArg(options::OPT_pthread)) {
6263 if (!Args.hasArg(options::OPT_shared) &&
6264 Args.hasArg(options::OPT_pg))
6265 CmdArgs.push_back("-lpthread_p");
6266 else
6267 CmdArgs.push_back("-lpthread");
6268 }
6269
Eli Friedman9fa28852012-08-08 23:57:20 +00006270 if (!Args.hasArg(options::OPT_shared)) {
6271 if (Args.hasArg(options::OPT_pg))
6272 CmdArgs.push_back("-lc_p");
6273 else
6274 CmdArgs.push_back("-lc");
6275 }
6276
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00006277 StringRef MyArch;
6278 switch (getToolChain().getTriple().getArch()) {
6279 case llvm::Triple::arm:
6280 MyArch = "arm";
6281 break;
6282 case llvm::Triple::x86:
6283 MyArch = "i386";
6284 break;
6285 case llvm::Triple::x86_64:
6286 MyArch = "amd64";
6287 break;
6288 default:
6289 llvm_unreachable("Unsupported architecture");
6290 }
6291 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00006292 }
6293
6294 if (!Args.hasArg(options::OPT_nostdlib) &&
6295 !Args.hasArg(options::OPT_nostartfiles)) {
6296 if (!Args.hasArg(options::OPT_shared))
6297 CmdArgs.push_back(Args.MakeArgString(
6298 getToolChain().GetFilePath("crtend.o")));
6299 else
6300 CmdArgs.push_back(Args.MakeArgString(
6301 getToolChain().GetFilePath("crtendS.o")));
6302 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006303
6304 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006305 Args.MakeArgString(getToolChain().GetLinkerPath());
Eli Friedman5bb2ba02012-08-09 22:42:04 +00006306 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eli Friedman9fa28852012-08-08 23:57:20 +00006307}
6308
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006309void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006310 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006311 const InputInfoList &Inputs,
6312 const ArgList &Args,
Mike Stump11289f42009-09-09 15:08:12 +00006313 const char *LinkingOutput) const {
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006314 ArgStringList CmdArgs;
6315
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006316 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6317 // instruct as in the base system to assemble 32-bit code.
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006318 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006319 CmdArgs.push_back("--32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006320 else if (getToolChain().getArch() == llvm::Triple::ppc)
Roman Divacky00859c22011-06-04 07:37:31 +00006321 CmdArgs.push_back("-a32");
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006322 else if (getToolChain().getArch() == llvm::Triple::mips ||
6323 getToolChain().getArch() == llvm::Triple::mipsel ||
6324 getToolChain().getArch() == llvm::Triple::mips64 ||
6325 getToolChain().getArch() == llvm::Triple::mips64el) {
6326 StringRef CPUName;
6327 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006328 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006329
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006330 CmdArgs.push_back("-march");
6331 CmdArgs.push_back(CPUName.data());
6332
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006333 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006334 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006335
6336 if (getToolChain().getArch() == llvm::Triple::mips ||
6337 getToolChain().getArch() == llvm::Triple::mips64)
6338 CmdArgs.push_back("-EB");
6339 else
6340 CmdArgs.push_back("-EL");
6341
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006342 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006343 } else if (getToolChain().getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006344 getToolChain().getArch() == llvm::Triple::armeb ||
6345 getToolChain().getArch() == llvm::Triple::thumb ||
6346 getToolChain().getArch() == llvm::Triple::thumbeb) {
Renato Golinf4421f72014-02-19 10:44:07 +00006347 const Driver &D = getToolChain().getDriver();
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006348 const llvm::Triple &Triple = getToolChain().getTriple();
Renato Golinf4421f72014-02-19 10:44:07 +00006349 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6350
6351 if (FloatABI == "hard") {
6352 CmdArgs.push_back("-mfpu=vfp");
6353 } else {
6354 CmdArgs.push_back("-mfpu=softvfp");
6355 }
6356
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006357 switch(getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00006358 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006359 case llvm::Triple::GNUEABI:
6360 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00006361 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00006362 break;
6363
6364 default:
6365 CmdArgs.push_back("-matpcs");
6366 }
Roman Divacky47f4ff82014-01-02 15:13:18 +00006367 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
Roman Divackyfeb5e632014-01-02 15:34:59 +00006368 getToolChain().getArch() == llvm::Triple::sparcv9) {
Roman Divacky9f779402014-02-25 18:45:49 +00006369 if (getToolChain().getArch() == llvm::Triple::sparc)
6370 CmdArgs.push_back("-Av8plusa");
6371 else
6372 CmdArgs.push_back("-Av9a");
6373
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006374 addAssemblerKPIC(Args, CmdArgs);
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00006375 }
Eric Christopher0b26a612010-03-02 02:41:08 +00006376
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006377 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6378 options::OPT_Xassembler);
6379
6380 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00006381 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006382
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006383 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00006384 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006385
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006386 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006387 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00006388}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006389
6390void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006391 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006392 const InputInfoList &Inputs,
6393 const ArgList &Args,
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006394 const char *LinkingOutput) const {
Roman Divackyafe2f232012-08-28 15:09:03 +00006395 const toolchains::FreeBSD& ToolChain =
6396 static_cast<const toolchains::FreeBSD&>(getToolChain());
6397 const Driver &D = ToolChain.getDriver();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006398 const bool IsPIE =
6399 !Args.hasArg(options::OPT_shared) &&
6400 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006401 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00006402
6403 // Silence warning for "clang -g foo.o -o foo"
6404 Args.ClaimAllArgs(options::OPT_g_Group);
6405 // and "clang -emit-llvm foo.o -o foo"
6406 Args.ClaimAllArgs(options::OPT_emit_llvm);
6407 // and for "clang -w foo.o -o foo". Other warning options are already
6408 // handled somewhere else.
6409 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006410
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006411 if (!D.SysRoot.empty())
6412 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6413
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006414 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006415 CmdArgs.push_back("-pie");
6416
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006417 if (Args.hasArg(options::OPT_static)) {
6418 CmdArgs.push_back("-Bstatic");
6419 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00006420 if (Args.hasArg(options::OPT_rdynamic))
6421 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006422 CmdArgs.push_back("--eh-frame-hdr");
6423 if (Args.hasArg(options::OPT_shared)) {
6424 CmdArgs.push_back("-Bshareable");
6425 } else {
6426 CmdArgs.push_back("-dynamic-linker");
6427 CmdArgs.push_back("/libexec/ld-elf.so.1");
6428 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006429 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
6430 llvm::Triple::ArchType Arch = ToolChain.getArch();
David Chisnall5f99f482012-07-29 15:24:44 +00006431 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
6432 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
6433 CmdArgs.push_back("--hash-style=both");
6434 }
6435 }
6436 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006437 }
6438
6439 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
6440 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006441 if (ToolChain.getArch() == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006442 CmdArgs.push_back("-m");
6443 CmdArgs.push_back("elf_i386_fbsd");
6444 }
6445
Rafael Espindola35ca7d92012-10-07 04:44:33 +00006446 if (ToolChain.getArch() == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00006447 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00006448 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00006449 }
6450
Daniel Dunbarb440f562010-08-02 02:38:21 +00006451 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006452 CmdArgs.push_back("-o");
6453 CmdArgs.push_back(Output.getFilename());
6454 } else {
6455 assert(Output.isNothing() && "Invalid output.");
6456 }
6457
6458 if (!Args.hasArg(options::OPT_nostdlib) &&
6459 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00006460 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006461 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006462 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00006463 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006464 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006465 crt1 = "Scrt1.o";
6466 else
6467 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006468 }
Roman Divackyafe2f232012-08-28 15:09:03 +00006469 if (crt1)
6470 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6471
6472 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6473
Craig Topper92fc2df2014-05-17 16:56:41 +00006474 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00006475 if (Args.hasArg(options::OPT_static))
6476 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006477 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006478 crtbegin = "crtbeginS.o";
6479 else
6480 crtbegin = "crtbegin.o";
6481
6482 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006483 }
6484
6485 Args.AddAllArgs(CmdArgs, options::OPT_L);
Roman Divackyafe2f232012-08-28 15:09:03 +00006486 const ToolChain::path_list Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006487 for (const auto &Path : Paths)
6488 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006489 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6490 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00006491 Args.AddAllArgs(CmdArgs, options::OPT_s);
6492 Args.AddAllArgs(CmdArgs, options::OPT_t);
6493 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6494 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006495
Alp Tokerce365ca2013-12-02 12:43:03 +00006496 if (D.IsUsingLTO(Args))
6497 AddGoldPlugin(ToolChain, Args, CmdArgs);
Roman Divackyf0d7f942013-11-10 09:31:43 +00006498
Roman Divackyafe2f232012-08-28 15:09:03 +00006499 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006500
6501 if (!Args.hasArg(options::OPT_nostdlib) &&
6502 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006503 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00006504 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00006505 if (Args.hasArg(options::OPT_pg))
6506 CmdArgs.push_back("-lm_p");
6507 else
6508 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00006509 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006510 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
6511 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00006512 if (Args.hasArg(options::OPT_pg))
6513 CmdArgs.push_back("-lgcc_p");
6514 else
6515 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006516 if (Args.hasArg(options::OPT_static)) {
6517 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006518 } else if (Args.hasArg(options::OPT_pg)) {
6519 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006520 } else {
6521 CmdArgs.push_back("--as-needed");
6522 CmdArgs.push_back("-lgcc_s");
6523 CmdArgs.push_back("--no-as-needed");
6524 }
6525
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006526 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00006527 if (Args.hasArg(options::OPT_pg))
6528 CmdArgs.push_back("-lpthread_p");
6529 else
6530 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00006531 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006532
Roman Divacky66f22762011-02-10 16:59:40 +00006533 if (Args.hasArg(options::OPT_pg)) {
6534 if (Args.hasArg(options::OPT_shared))
6535 CmdArgs.push_back("-lc");
6536 else
6537 CmdArgs.push_back("-lc_p");
6538 CmdArgs.push_back("-lgcc_p");
6539 } else {
6540 CmdArgs.push_back("-lc");
6541 CmdArgs.push_back("-lgcc");
6542 }
6543
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006544 if (Args.hasArg(options::OPT_static)) {
6545 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00006546 } else if (Args.hasArg(options::OPT_pg)) {
6547 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006548 } else {
6549 CmdArgs.push_back("--as-needed");
6550 CmdArgs.push_back("-lgcc_s");
6551 CmdArgs.push_back("--no-as-needed");
6552 }
6553 }
6554
6555 if (!Args.hasArg(options::OPT_nostdlib) &&
6556 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00006557 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00006558 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00006559 else
6560 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00006561 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006562 }
6563
Viktor Kutuzovaa5b5f72014-03-18 09:36:50 +00006564 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6565
Alexey Samsonov7811d192014-02-20 13:57:37 +00006566 addProfileRT(ToolChain, Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006567
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006568 const char *Exec =
Logan Chieneb9162f2014-06-26 14:23:45 +00006569 Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006570 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00006571}
Daniel Dunbarcc912342009-05-02 18:28:39 +00006572
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006573void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6574 const InputInfo &Output,
6575 const InputInfoList &Inputs,
6576 const ArgList &Args,
6577 const char *LinkingOutput) const {
6578 ArgStringList CmdArgs;
6579
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006580 // GNU as needs different flags for creating the correct output format
6581 // on architectures with different ABIs or optional feature sets.
6582 switch (getToolChain().getArch()) {
6583 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006584 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006585 break;
6586 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006587 case llvm::Triple::armeb:
6588 case llvm::Triple::thumb:
6589 case llvm::Triple::thumbeb: {
Bernard Ogden31561762013-12-12 13:27:11 +00006590 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006591 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006592 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00006593 }
6594
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006595 case llvm::Triple::mips:
6596 case llvm::Triple::mipsel:
6597 case llvm::Triple::mips64:
6598 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006599 StringRef CPUName;
6600 StringRef ABIName;
6601 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6602
6603 CmdArgs.push_back("-march");
6604 CmdArgs.push_back(CPUName.data());
6605
6606 CmdArgs.push_back("-mabi");
6607 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6608
6609 if (getToolChain().getArch() == llvm::Triple::mips ||
6610 getToolChain().getArch() == llvm::Triple::mips64)
6611 CmdArgs.push_back("-EB");
6612 else
6613 CmdArgs.push_back("-EL");
6614
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006615 addAssemblerKPIC(Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006616 break;
6617 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006618
6619 case llvm::Triple::sparc:
6620 CmdArgs.push_back("-32");
6621 addAssemblerKPIC(Args, CmdArgs);
6622 break;
6623
6624 case llvm::Triple::sparcv9:
6625 CmdArgs.push_back("-64");
6626 CmdArgs.push_back("-Av9");
6627 addAssemblerKPIC(Args, CmdArgs);
6628 break;
6629
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00006630 default:
6631 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00006632 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006633
6634 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6635 options::OPT_Xassembler);
6636
6637 CmdArgs.push_back("-o");
6638 CmdArgs.push_back(Output.getFilename());
6639
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006640 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006641 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006642
David Chisnallddbd68f2011-09-27 22:03:18 +00006643 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006644 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6645}
6646
6647void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6648 const InputInfo &Output,
6649 const InputInfoList &Inputs,
6650 const ArgList &Args,
6651 const char *LinkingOutput) const {
6652 const Driver &D = getToolChain().getDriver();
6653 ArgStringList CmdArgs;
6654
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00006655 if (!D.SysRoot.empty())
6656 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6657
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00006658 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006659 if (Args.hasArg(options::OPT_static)) {
6660 CmdArgs.push_back("-Bstatic");
6661 } else {
6662 if (Args.hasArg(options::OPT_rdynamic))
6663 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006664 if (Args.hasArg(options::OPT_shared)) {
6665 CmdArgs.push_back("-Bshareable");
6666 } else {
6667 CmdArgs.push_back("-dynamic-linker");
6668 CmdArgs.push_back("/libexec/ld.elf_so");
6669 }
6670 }
6671
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006672 // Many NetBSD architectures support more than one ABI.
6673 // Determine the correct emulation for ld.
6674 switch (getToolChain().getArch()) {
6675 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006676 CmdArgs.push_back("-m");
6677 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006678 break;
6679 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006680 case llvm::Triple::armeb:
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006681 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006682 case llvm::Triple::thumbeb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006683 CmdArgs.push_back("-m");
6684 switch (getToolChain().getTriple().getEnvironment()) {
6685 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006686 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006687 CmdArgs.push_back("armelf_nbsd_eabi");
6688 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00006689 case llvm::Triple::EABIHF:
6690 case llvm::Triple::GNUEABIHF:
6691 CmdArgs.push_back("armelf_nbsd_eabihf");
6692 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006693 default:
6694 CmdArgs.push_back("armelf_nbsd");
6695 break;
6696 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006697 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006698 case llvm::Triple::mips64:
6699 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006700 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006701 CmdArgs.push_back("-m");
6702 if (getToolChain().getArch() == llvm::Triple::mips64)
6703 CmdArgs.push_back("elf32btsmip");
6704 else
6705 CmdArgs.push_back("elf32ltsmip");
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006706 } else if (mips::hasMipsAbiArg(Args, "64")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00006707 CmdArgs.push_back("-m");
6708 if (getToolChain().getArch() == llvm::Triple::mips64)
6709 CmdArgs.push_back("elf64btsmip");
6710 else
6711 CmdArgs.push_back("elf64ltsmip");
6712 }
6713 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00006714
6715 case llvm::Triple::sparc:
6716 CmdArgs.push_back("-m");
6717 CmdArgs.push_back("elf32_sparc");
6718 break;
6719
6720 case llvm::Triple::sparcv9:
6721 CmdArgs.push_back("-m");
6722 CmdArgs.push_back("elf64_sparc");
6723 break;
6724
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00006725 default:
6726 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00006727 }
6728
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006729 if (Output.isFilename()) {
6730 CmdArgs.push_back("-o");
6731 CmdArgs.push_back(Output.getFilename());
6732 } else {
6733 assert(Output.isNothing() && "Invalid output.");
6734 }
6735
6736 if (!Args.hasArg(options::OPT_nostdlib) &&
6737 !Args.hasArg(options::OPT_nostartfiles)) {
6738 if (!Args.hasArg(options::OPT_shared)) {
6739 CmdArgs.push_back(Args.MakeArgString(
6740 getToolChain().GetFilePath("crt0.o")));
6741 CmdArgs.push_back(Args.MakeArgString(
6742 getToolChain().GetFilePath("crti.o")));
6743 CmdArgs.push_back(Args.MakeArgString(
6744 getToolChain().GetFilePath("crtbegin.o")));
6745 } else {
6746 CmdArgs.push_back(Args.MakeArgString(
6747 getToolChain().GetFilePath("crti.o")));
6748 CmdArgs.push_back(Args.MakeArgString(
6749 getToolChain().GetFilePath("crtbeginS.o")));
6750 }
6751 }
6752
6753 Args.AddAllArgs(CmdArgs, options::OPT_L);
6754 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6755 Args.AddAllArgs(CmdArgs, options::OPT_e);
6756 Args.AddAllArgs(CmdArgs, options::OPT_s);
6757 Args.AddAllArgs(CmdArgs, options::OPT_t);
6758 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6759 Args.AddAllArgs(CmdArgs, options::OPT_r);
6760
6761 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6762
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006763 unsigned Major, Minor, Micro;
6764 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6765 bool useLibgcc = true;
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006766 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 40) || Major == 0) {
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006767 switch(getToolChain().getArch()) {
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00006768 case llvm::Triple::arm:
6769 case llvm::Triple::armeb:
6770 case llvm::Triple::thumb:
6771 case llvm::Triple::thumbeb:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006772 case llvm::Triple::x86:
6773 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006774 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00006775 break;
6776 default:
6777 break;
6778 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006779 }
6780
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006781 if (!Args.hasArg(options::OPT_nostdlib) &&
6782 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006783 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006784 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6785 CmdArgs.push_back("-lm");
6786 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006787 if (Args.hasArg(options::OPT_pthread))
6788 CmdArgs.push_back("-lpthread");
6789 CmdArgs.push_back("-lc");
6790
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00006791 if (useLibgcc) {
6792 if (Args.hasArg(options::OPT_static)) {
6793 // libgcc_eh depends on libc, so resolve as much as possible,
6794 // pull in any new requirements from libc and then get the rest
6795 // of libgcc.
6796 CmdArgs.push_back("-lgcc_eh");
6797 CmdArgs.push_back("-lc");
6798 CmdArgs.push_back("-lgcc");
6799 } else {
6800 CmdArgs.push_back("-lgcc");
6801 CmdArgs.push_back("--as-needed");
6802 CmdArgs.push_back("-lgcc_s");
6803 CmdArgs.push_back("--no-as-needed");
6804 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006805 }
6806 }
6807
6808 if (!Args.hasArg(options::OPT_nostdlib) &&
6809 !Args.hasArg(options::OPT_nostartfiles)) {
6810 if (!Args.hasArg(options::OPT_shared))
6811 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6812 "crtend.o")));
6813 else
6814 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6815 "crtendS.o")));
6816 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6817 "crtn.o")));
6818 }
6819
Alexey Samsonov7811d192014-02-20 13:57:37 +00006820 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00006821
Logan Chieneb9162f2014-06-26 14:23:45 +00006822 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00006823 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6824}
6825
Thomas Schwinge4e555262013-03-28 19:04:25 +00006826void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6827 const InputInfo &Output,
6828 const InputInfoList &Inputs,
6829 const ArgList &Args,
6830 const char *LinkingOutput) const {
Rafael Espindola92b00932010-08-10 00:25:48 +00006831 ArgStringList CmdArgs;
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006832 bool NeedsKPIC = false;
Rafael Espindola92b00932010-08-10 00:25:48 +00006833
6834 // Add --32/--64 to make sure we get the format we want.
6835 // This is incomplete
6836 if (getToolChain().getArch() == llvm::Triple::x86) {
6837 CmdArgs.push_back("--32");
6838 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6839 CmdArgs.push_back("--64");
Eli Friedman4a4932c2011-11-28 23:46:52 +00006840 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6841 CmdArgs.push_back("-a32");
6842 CmdArgs.push_back("-mppc");
6843 CmdArgs.push_back("-many");
6844 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6845 CmdArgs.push_back("-a64");
6846 CmdArgs.push_back("-mppc64");
6847 CmdArgs.push_back("-many");
Bill Schmidt778d3872013-07-26 01:36:11 +00006848 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6849 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006850 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00006851 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00006852 CmdArgs.push_back("-mlittle-endian");
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006853 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6854 CmdArgs.push_back("-32");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006855 CmdArgs.push_back("-Av8plusa");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006856 NeedsKPIC = true;
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00006857 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6858 CmdArgs.push_back("-64");
Jakob Stoklund Olesen58801bf2014-01-11 18:25:01 +00006859 CmdArgs.push_back("-Av9a");
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006860 NeedsKPIC = true;
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006861 } else if (getToolChain().getArch() == llvm::Triple::arm ||
6862 getToolChain().getArch() == llvm::Triple::armeb) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006863 StringRef MArch = getToolChain().getArchName();
Rafael Espindola92b00932010-08-10 00:25:48 +00006864 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6865 CmdArgs.push_back("-mfpu=neon");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006866 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
6867 MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
Bernard Ogdena58ef052013-10-24 18:32:41 +00006868 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006869
Tim Northover9c7e0352013-12-12 11:55:52 +00006870 StringRef ARMFloatABI = tools::arm::getARMFloatABI(
6871 getToolChain().getDriver(), Args, getToolChain().getTriple());
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00006872 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006873
6874 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00006875
6876 // FIXME: remove krait check when GNU tools support krait cpu
6877 // for now replace it with -march=armv7-a to avoid a lower
6878 // march from being picked in the absence of a cpu flag.
6879 Arg *A;
6880 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6881 StringRef(A->getValue()) == "krait")
6882 CmdArgs.push_back("-march=armv7-a");
6883 else
6884 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00006885 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006886 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6887 getToolChain().getArch() == llvm::Triple::mipsel ||
6888 getToolChain().getArch() == llvm::Triple::mips64 ||
6889 getToolChain().getArch() == llvm::Triple::mips64el) {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006890 StringRef CPUName;
6891 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006892 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00006893
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006894 CmdArgs.push_back("-march");
6895 CmdArgs.push_back(CPUName.data());
6896
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00006897 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006898 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Simon Atanasyan2390aa12012-04-06 19:15:24 +00006899
6900 if (getToolChain().getArch() == llvm::Triple::mips ||
6901 getToolChain().getArch() == llvm::Triple::mips64)
6902 CmdArgs.push_back("-EB");
6903 else
6904 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00006905
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006906 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6907 if (StringRef(A->getValue()) == "2008")
6908 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6909 }
6910
Simon Atanasyan8cc7c122013-11-26 11:57:58 +00006911 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
Simon Atanasyan036d16d2013-04-30 07:47:13 +00006912 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6913 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6914 options::OPT_mno_micromips);
6915 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6916 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6917
Simon Atanasyanbd986632013-11-26 11:58:04 +00006918 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6919 // Do not use AddLastArg because not all versions of MIPS assembler
6920 // support -mmsa / -mno-msa options.
6921 if (A->getOption().matches(options::OPT_mmsa))
6922 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6923 }
6924
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00006925 NeedsKPIC = true;
6926 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6927 // Always pass an -march option, since our default of z10 is later
6928 // than the GNU assembler's default.
6929 StringRef CPUName = getSystemZTargetCPU(Args);
6930 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6931 }
6932
Joerg Sonnenbergerc151b022014-02-19 21:58:52 +00006933 if (NeedsKPIC)
6934 addAssemblerKPIC(Args, CmdArgs);
Rafael Espindola92b00932010-08-10 00:25:48 +00006935
6936 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6937 options::OPT_Xassembler);
6938
6939 CmdArgs.push_back("-o");
6940 CmdArgs.push_back(Output.getFilename());
6941
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006942 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00006943 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00006944
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006945 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Rafael Espindola92b00932010-08-10 00:25:48 +00006946 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00006947
6948 // Handle the debug info splitting at object creation time if we're
6949 // creating an object.
6950 // TODO: Currently only works on linux with newer objcopy.
6951 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006952 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00006953 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6954 SplitDebugName(Args, Inputs));
Rafael Espindola92b00932010-08-10 00:25:48 +00006955}
6956
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00006957static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006958 ArgStringList &CmdArgs, const ArgList &Args) {
Logan Chienc6fd8202012-09-02 09:30:11 +00006959 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
Chandler Carruth58d6eb62013-03-04 02:07:55 +00006960 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6961 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00006962 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006963 CmdArgs.push_back("-lgcc");
6964
Logan Chien3d3373c2012-11-19 12:04:11 +00006965 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006966 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006967 CmdArgs.push_back("-lgcc");
6968 } else {
Hans Wennborg70850d82013-07-18 20:29:38 +00006969 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006970 CmdArgs.push_back("--as-needed");
6971 CmdArgs.push_back("-lgcc_s");
Hans Wennborg70850d82013-07-18 20:29:38 +00006972 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006973 CmdArgs.push_back("--no-as-needed");
6974 }
6975
Evgeniy Stepanov77866712012-04-25 08:59:22 +00006976 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00006977 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00006978 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00006979 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00006980
6981 // According to Android ABI, we have to link with libdl if we are
6982 // linking with non-static libgcc.
6983 //
6984 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6985 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6986 if (isAndroid && !StaticLibgcc)
6987 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00006988}
6989
Simon Atanasyan14ce18d2014-06-25 05:00:59 +00006990static StringRef getLinuxDynamicLinker(const ArgList &Args,
6991 const toolchains::Linux &ToolChain) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00006992 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
6993 if (ToolChain.getTriple().isArch64Bit())
6994 return "/system/bin/linker64";
6995 else
6996 return "/system/bin/linker";
6997 } else if (ToolChain.getArch() == llvm::Triple::x86 ||
6998 ToolChain.getArch() == llvm::Triple::sparc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00006999 return "/lib/ld-linux.so.2";
Tim Northovera2ee4332014-03-29 15:09:45 +00007000 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7001 ToolChain.getArch() == llvm::Triple::arm64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007002 return "/lib/ld-linux-aarch64.so.1";
James Molloy2b24fc42014-04-17 12:51:23 +00007003 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7004 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007005 return "/lib/ld-linux-aarch64_be.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007006 else if (ToolChain.getArch() == llvm::Triple::arm ||
7007 ToolChain.getArch() == llvm::Triple::thumb) {
7008 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7009 return "/lib/ld-linux-armhf.so.3";
7010 else
7011 return "/lib/ld-linux.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007012 } else if (ToolChain.getArch() == llvm::Triple::armeb ||
7013 ToolChain.getArch() == llvm::Triple::thumbeb) {
7014 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7015 return "/lib/ld-linux-armhf.so.3"; /* TODO: check which dynamic linker name. */
7016 else
7017 return "/lib/ld-linux.so.3"; /* TODO: check which dynamic linker name. */
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007018 } else if (ToolChain.getArch() == llvm::Triple::mips ||
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007019 ToolChain.getArch() == llvm::Triple::mipsel) {
7020 if (mips::isNaN2008(Args))
7021 return "/lib/ld-linux-mipsn8.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007022 return "/lib/ld.so.1";
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007023 } else if (ToolChain.getArch() == llvm::Triple::mips64 ||
NAKAMURA Takumid3235e02014-06-25 04:34:00 +00007024 ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007025 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan14ce18d2014-06-25 05:00:59 +00007026 return mips::isNaN2008(Args) ? "/lib32/ld-linux-mipsn8.so.1"
7027 : "/lib32/ld.so.1";
7028 return mips::isNaN2008(Args) ? "/lib64/ld-linux-mipsn8.so.1"
7029 : "/lib64/ld.so.1";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007030 } else if (ToolChain.getArch() == llvm::Triple::ppc)
7031 return "/lib/ld.so.1";
7032 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
7033 ToolChain.getArch() == llvm::Triple::systemz)
7034 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00007035 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7036 return "/lib64/ld64.so.2";
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00007037 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7038 return "/lib64/ld-linux.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00007039 else
7040 return "/lib64/ld-linux-x86-64.so.2";
7041}
7042
Renato Golinc4b49242014-02-13 10:01:16 +00007043static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7044 ArgStringList &CmdArgs, const ArgList &Args) {
7045 // Make use of compiler-rt if --rtlib option is used
7046 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7047
7048 switch(RLT) {
7049 case ToolChain::RLT_CompilerRT:
7050 addClangRTLinux(TC, Args, CmdArgs);
7051 break;
7052 case ToolChain::RLT_Libgcc:
7053 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7054 break;
Renato Golinc4b49242014-02-13 10:01:16 +00007055 }
7056}
7057
Thomas Schwinge4e555262013-03-28 19:04:25 +00007058void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
7059 const InputInfo &Output,
7060 const InputInfoList &Inputs,
7061 const ArgList &Args,
7062 const char *LinkingOutput) const {
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007063 const toolchains::Linux& ToolChain =
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007064 static_cast<const toolchains::Linux&>(getToolChain());
7065 const Driver &D = ToolChain.getDriver();
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007066 const bool isAndroid =
7067 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007068 const bool IsPIE =
7069 !Args.hasArg(options::OPT_shared) &&
Alexey Volkov06921032014-04-29 10:25:20 +00007070 !Args.hasArg(options::OPT_static) &&
7071 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7072 // On Android every code is PIC so every executable is PIE
Alexey Volkov6468f5d2014-04-29 12:07:34 +00007073 // Cannot use isPIEDefault here since otherwise
7074 // PIE only logic will be enabled during compilation
Alexey Volkov06921032014-04-29 10:25:20 +00007075 isAndroid);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007076
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007077 ArgStringList CmdArgs;
7078
Rafael Espindolad1002f62010-11-15 18:28:16 +00007079 // Silence warning for "clang -g foo.o -o foo"
7080 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00007081 // and "clang -emit-llvm foo.o -o foo"
7082 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00007083 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00007084 // handled somewhere else.
7085 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00007086
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007087 if (!D.SysRoot.empty())
7088 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007089
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007090 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00007091 CmdArgs.push_back("-pie");
7092
Rafael Espindola1c76c592010-11-07 22:57:16 +00007093 if (Args.hasArg(options::OPT_rdynamic))
7094 CmdArgs.push_back("-export-dynamic");
7095
Rafael Espindola34d77dc2010-11-11 19:34:42 +00007096 if (Args.hasArg(options::OPT_s))
7097 CmdArgs.push_back("-s");
7098
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007099 for (const auto &Opt : ToolChain.ExtraOpts)
7100 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007101
7102 if (!Args.hasArg(options::OPT_static)) {
7103 CmdArgs.push_back("--eh-frame-hdr");
7104 }
7105
7106 CmdArgs.push_back("-m");
7107 if (ToolChain.getArch() == llvm::Triple::x86)
7108 CmdArgs.push_back("elf_i386");
Tim Northovera2ee4332014-03-29 15:09:45 +00007109 else if (ToolChain.getArch() == llvm::Triple::aarch64 ||
7110 ToolChain.getArch() == llvm::Triple::arm64)
Tim Northover9bb857a2013-01-31 12:13:10 +00007111 CmdArgs.push_back("aarch64linux");
James Molloy2b24fc42014-04-17 12:51:23 +00007112 else if (ToolChain.getArch() == llvm::Triple::aarch64_be ||
7113 ToolChain.getArch() == llvm::Triple::arm64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00007114 CmdArgs.push_back("aarch64_be_linux");
Eric Christopher84fbdb42011-08-19 00:30:14 +00007115 else if (ToolChain.getArch() == llvm::Triple::arm
Douglas Gregord9bb1522011-03-06 19:11:49 +00007116 || ToolChain.getArch() == llvm::Triple::thumb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007117 CmdArgs.push_back("armelf_linux_eabi");
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007118 else if (ToolChain.getArch() == llvm::Triple::armeb
7119 || ToolChain.getArch() == llvm::Triple::thumbeb)
7120 CmdArgs.push_back("armebelf_linux_eabi"); /* TODO: check which NAME. */
Ted Kremenek43d47cc2011-04-05 22:04:27 +00007121 else if (ToolChain.getArch() == llvm::Triple::ppc)
7122 CmdArgs.push_back("elf32ppclinux");
7123 else if (ToolChain.getArch() == llvm::Triple::ppc64)
7124 CmdArgs.push_back("elf64ppc");
Will Schmidtc1fc1902014-03-24 17:10:37 +00007125 else if (ToolChain.getArch() == llvm::Triple::ppc64le)
7126 CmdArgs.push_back("elf64lppc");
Jakob Stoklund Olesen91a8e032014-01-10 03:51:33 +00007127 else if (ToolChain.getArch() == llvm::Triple::sparc)
7128 CmdArgs.push_back("elf32_sparc");
7129 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
7130 CmdArgs.push_back("elf64_sparc");
Eli Friedman27b8c4f2011-11-08 19:43:37 +00007131 else if (ToolChain.getArch() == llvm::Triple::mips)
7132 CmdArgs.push_back("elf32btsmip");
7133 else if (ToolChain.getArch() == llvm::Triple::mipsel)
7134 CmdArgs.push_back("elf32ltsmip");
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007135 else if (ToolChain.getArch() == llvm::Triple::mips64) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007136 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007137 CmdArgs.push_back("elf32btsmipn32");
7138 else
7139 CmdArgs.push_back("elf64btsmip");
7140 }
7141 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007142 if (mips::hasMipsAbiArg(Args, "n32"))
Simon Atanasyan2d1b1ad2012-10-21 11:44:57 +00007143 CmdArgs.push_back("elf32ltsmipn32");
7144 else
7145 CmdArgs.push_back("elf64ltsmip");
7146 }
Ulrich Weigand47445072013-05-06 16:26:41 +00007147 else if (ToolChain.getArch() == llvm::Triple::systemz)
7148 CmdArgs.push_back("elf64_s390");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007149 else
7150 CmdArgs.push_back("elf_x86_64");
7151
7152 if (Args.hasArg(options::OPT_static)) {
Joerg Sonnenberger1e205ef2014-02-02 22:36:13 +00007153 if (ToolChain.getArch() == llvm::Triple::arm ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007154 ToolChain.getArch() == llvm::Triple::armeb ||
7155 ToolChain.getArch() == llvm::Triple::thumb ||
7156 ToolChain.getArch() == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007157 CmdArgs.push_back("-Bstatic");
7158 else
7159 CmdArgs.push_back("-static");
7160 } else if (Args.hasArg(options::OPT_shared)) {
7161 CmdArgs.push_back("-shared");
Rafael Espindola7df35012012-11-02 20:41:30 +00007162 if (isAndroid) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007163 CmdArgs.push_back("-Bsymbolic");
7164 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007165 }
7166
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007167 if (ToolChain.getArch() == llvm::Triple::arm ||
7168 ToolChain.getArch() == llvm::Triple::armeb ||
7169 ToolChain.getArch() == llvm::Triple::thumb ||
7170 ToolChain.getArch() == llvm::Triple::thumbeb ||
7171 (!Args.hasArg(options::OPT_static) &&
7172 !Args.hasArg(options::OPT_shared))) {
7173 CmdArgs.push_back("-dynamic-linker");
7174 CmdArgs.push_back(Args.MakeArgString(
7175 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7176 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007177
7178 CmdArgs.push_back("-o");
7179 CmdArgs.push_back(Output.getFilename());
7180
Rafael Espindola81937ec2010-12-01 01:52:43 +00007181 if (!Args.hasArg(options::OPT_nostdlib) &&
7182 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007183 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007184 const char *crt1 = nullptr;
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007185 if (!Args.hasArg(options::OPT_shared)){
Eric Christopherac021742013-06-07 23:25:01 +00007186 if (Args.hasArg(options::OPT_pg))
7187 crt1 = "gcrt1.o";
7188 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007189 crt1 = "Scrt1.o";
7190 else
7191 crt1 = "crt1.o";
7192 }
7193 if (crt1)
7194 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007195
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007196 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7197 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007198
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007199 const char *crtbegin;
7200 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007201 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007202 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007203 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007204 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007205 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007206 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007207 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007208 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00007209
7210 // Add crtfastmath.o if available and fast math is enabled.
7211 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007212 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007213
7214 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00007215 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007216
7217 const ToolChain::path_list Paths = ToolChain.getFilePaths();
7218
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007219 for (const auto &Path : Paths)
7220 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007221
Alp Tokerce365ca2013-12-02 12:43:03 +00007222 if (D.IsUsingLTO(Args))
7223 AddGoldPlugin(ToolChain, Args, CmdArgs);
Chandler Carruth953fb082013-01-13 11:46:33 +00007224
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00007225 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7226 CmdArgs.push_back("--no-demangle");
7227
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007228 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7229
Alexey Samsonovce8ab102014-02-25 12:43:43 +00007230 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007231 // The profile runtime also needs access to system libraries.
Alexey Samsonov7811d192014-02-20 13:57:37 +00007232 addProfileRT(getToolChain(), Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00007233
Hans Wennborg70850d82013-07-18 20:29:38 +00007234 if (D.CCCIsCXX() &&
Chandler Carruth94a32012012-05-14 18:31:18 +00007235 !Args.hasArg(options::OPT_nostdlib) &&
7236 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00007237 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7238 !Args.hasArg(options::OPT_static);
7239 if (OnlyLibstdcxxStatic)
7240 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007241 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00007242 if (OnlyLibstdcxxStatic)
7243 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007244 CmdArgs.push_back("-lm");
7245 }
7246
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007247 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00007248 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7249 if (Args.hasArg(options::OPT_static))
7250 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00007251
Alexey Bataev186b28a2014-03-06 05:43:53 +00007252 LibOpenMP UsedOpenMPLib = LibUnknown;
7253 if (Args.hasArg(options::OPT_fopenmp)) {
7254 UsedOpenMPLib = LibGOMP;
7255 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7256 UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
7257 .Case("libgomp", LibGOMP)
7258 .Case("libiomp5", LibIOMP5)
7259 .Default(LibUnknown);
7260 if (UsedOpenMPLib == LibUnknown)
7261 D.Diag(diag::err_drv_unsupported_option_argument)
7262 << A->getOption().getName() << A->getValue();
7263 }
7264 switch (UsedOpenMPLib) {
7265 case LibGOMP:
Chandler Carruth01538002013-01-17 13:19:29 +00007266 CmdArgs.push_back("-lgomp");
7267
Alp Tokerf6a24ce2013-12-05 16:25:25 +00007268 // FIXME: Exclude this for platforms with libgomp that don't require
7269 // librt. Most modern Linux platforms require it, but some may not.
Chandler Carruth01538002013-01-17 13:19:29 +00007270 CmdArgs.push_back("-lrt");
Alexey Bataev186b28a2014-03-06 05:43:53 +00007271 break;
7272 case LibIOMP5:
7273 CmdArgs.push_back("-liomp5");
7274 break;
7275 case LibUnknown:
7276 break;
Chandler Carruth01538002013-01-17 13:19:29 +00007277 }
Renato Golinc4b49242014-02-13 10:01:16 +00007278 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007279
Evgeniy Stepanovdad92062014-06-05 11:41:39 +00007280 if ((Args.hasArg(options::OPT_pthread) ||
7281 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7282 !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00007283 CmdArgs.push_back("-lpthread");
7284
7285 CmdArgs.push_back("-lc");
7286
7287 if (Args.hasArg(options::OPT_static))
7288 CmdArgs.push_back("--end-group");
7289 else
Renato Golinc4b49242014-02-13 10:01:16 +00007290 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00007291 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00007292
Rafael Espindola81937ec2010-12-01 01:52:43 +00007293 if (!Args.hasArg(options::OPT_nostartfiles)) {
7294 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007295 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007296 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00007297 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00007298 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00007299 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007300 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00007301
Rafael Espindola81937ec2010-12-01 01:52:43 +00007302 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00007303 if (!isAndroid)
7304 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00007305 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00007306 }
7307
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00007308 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00007309}
7310
Chris Lattner3e2ee142010-07-07 16:01:42 +00007311void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007312 const InputInfo &Output,
7313 const InputInfoList &Inputs,
7314 const ArgList &Args,
7315 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007316 ArgStringList CmdArgs;
7317
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007318 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007319
7320 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007321 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007322
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007323 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007324 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00007325
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007326 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007327 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007328}
7329
7330void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007331 const InputInfo &Output,
7332 const InputInfoList &Inputs,
7333 const ArgList &Args,
7334 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007335 const Driver &D = getToolChain().getDriver();
7336 ArgStringList CmdArgs;
7337
Daniel Dunbarb440f562010-08-02 02:38:21 +00007338 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00007339 CmdArgs.push_back("-o");
7340 CmdArgs.push_back(Output.getFilename());
7341 } else {
7342 assert(Output.isNothing() && "Invalid output.");
7343 }
7344
7345 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00007346 !Args.hasArg(options::OPT_nostartfiles)) {
7347 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7348 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7349 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7350 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7351 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007352
7353 Args.AddAllArgs(CmdArgs, options::OPT_L);
7354 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7355 Args.AddAllArgs(CmdArgs, options::OPT_e);
7356
Daniel Dunbar54423b22010-09-17 00:24:54 +00007357 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007358
Alexey Samsonov7811d192014-02-20 13:57:37 +00007359 addProfileRT(getToolChain(), Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00007360
Chris Lattner3e2ee142010-07-07 16:01:42 +00007361 if (!Args.hasArg(options::OPT_nostdlib) &&
7362 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007363 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007364 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007365 CmdArgs.push_back("-lm");
7366 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00007367 }
7368
7369 if (!Args.hasArg(options::OPT_nostdlib) &&
7370 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00007371 if (Args.hasArg(options::OPT_pthread))
7372 CmdArgs.push_back("-lpthread");
7373 CmdArgs.push_back("-lc");
7374 CmdArgs.push_back("-lCompilerRT-Generic");
7375 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
7376 CmdArgs.push_back(
Eric Christopher45f2e712012-12-18 00:31:10 +00007377 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007378 }
7379
Logan Chieneb9162f2014-06-26 14:23:45 +00007380 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007381 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007382}
7383
Daniel Dunbarcc912342009-05-02 18:28:39 +00007384/// DragonFly Tools
7385
7386// For now, DragonFly Assemble does just about the same as for
7387// FreeBSD, but this may change soon.
7388void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007389 const InputInfo &Output,
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007390 const InputInfoList &Inputs,
7391 const ArgList &Args,
7392 const char *LinkingOutput) const {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007393 ArgStringList CmdArgs;
7394
7395 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7396 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007397 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00007398 CmdArgs.push_back("--32");
7399
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007400 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007401
7402 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007403 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007404
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007405 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007406 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00007407
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007408 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007409 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007410}
7411
7412void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007413 const InputInfo &Output,
7414 const InputInfoList &Inputs,
7415 const ArgList &Args,
7416 const char *LinkingOutput) const {
John McCall65b8da02013-04-11 22:55:55 +00007417 bool UseGCC47 = false;
Daniel Dunbar083edf72009-12-21 18:54:17 +00007418 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00007419 ArgStringList CmdArgs;
7420
John McCall65b8da02013-04-11 22:55:55 +00007421 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
7422 UseGCC47 = false;
7423
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007424 if (!D.SysRoot.empty())
7425 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7426
John McCall65b8da02013-04-11 22:55:55 +00007427 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007428 if (Args.hasArg(options::OPT_static)) {
7429 CmdArgs.push_back("-Bstatic");
7430 } else {
John McCall65b8da02013-04-11 22:55:55 +00007431 if (Args.hasArg(options::OPT_rdynamic))
7432 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007433 if (Args.hasArg(options::OPT_shared))
7434 CmdArgs.push_back("-Bshareable");
7435 else {
7436 CmdArgs.push_back("-dynamic-linker");
7437 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
7438 }
John McCall65b8da02013-04-11 22:55:55 +00007439 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007440 }
7441
7442 // When building 32-bit code on DragonFly/pc64, we have to explicitly
7443 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00007444 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007445 CmdArgs.push_back("-m");
7446 CmdArgs.push_back("elf_i386");
7447 }
7448
Daniel Dunbarb440f562010-08-02 02:38:21 +00007449 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00007450 CmdArgs.push_back("-o");
7451 CmdArgs.push_back(Output.getFilename());
7452 } else {
7453 assert(Output.isNothing() && "Invalid output.");
7454 }
7455
7456 if (!Args.hasArg(options::OPT_nostdlib) &&
7457 !Args.hasArg(options::OPT_nostartfiles)) {
7458 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00007459 if (Args.hasArg(options::OPT_pg))
7460 CmdArgs.push_back(Args.MakeArgString(
7461 getToolChain().GetFilePath("gcrt1.o")));
7462 else {
7463 if (Args.hasArg(options::OPT_pie))
7464 CmdArgs.push_back(Args.MakeArgString(
7465 getToolChain().GetFilePath("Scrt1.o")));
7466 else
7467 CmdArgs.push_back(Args.MakeArgString(
7468 getToolChain().GetFilePath("crt1.o")));
7469 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007470 }
John McCall65b8da02013-04-11 22:55:55 +00007471 CmdArgs.push_back(Args.MakeArgString(
7472 getToolChain().GetFilePath("crti.o")));
7473 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7474 CmdArgs.push_back(Args.MakeArgString(
7475 getToolChain().GetFilePath("crtbeginS.o")));
7476 else
7477 CmdArgs.push_back(Args.MakeArgString(
7478 getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007479 }
7480
7481 Args.AddAllArgs(CmdArgs, options::OPT_L);
7482 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7483 Args.AddAllArgs(CmdArgs, options::OPT_e);
7484
Daniel Dunbar54423b22010-09-17 00:24:54 +00007485 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00007486
7487 if (!Args.hasArg(options::OPT_nostdlib) &&
7488 !Args.hasArg(options::OPT_nodefaultlibs)) {
7489 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
7490 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00007491 if (UseGCC47)
7492 CmdArgs.push_back("-L/usr/lib/gcc47");
7493 else
7494 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007495
7496 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00007497 if (UseGCC47) {
7498 CmdArgs.push_back("-rpath");
7499 CmdArgs.push_back("/usr/lib/gcc47");
7500 } else {
7501 CmdArgs.push_back("-rpath");
7502 CmdArgs.push_back("/usr/lib/gcc44");
7503 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007504 }
7505
Hans Wennborg70850d82013-07-18 20:29:38 +00007506 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007507 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00007508 CmdArgs.push_back("-lm");
7509 }
7510
Daniel Dunbarcc912342009-05-02 18:28:39 +00007511 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00007512 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00007513
7514 if (!Args.hasArg(options::OPT_nolibc)) {
7515 CmdArgs.push_back("-lc");
7516 }
7517
John McCall65b8da02013-04-11 22:55:55 +00007518 if (UseGCC47) {
7519 if (Args.hasArg(options::OPT_static) ||
7520 Args.hasArg(options::OPT_static_libgcc)) {
7521 CmdArgs.push_back("-lgcc");
7522 CmdArgs.push_back("-lgcc_eh");
7523 } else {
7524 if (Args.hasArg(options::OPT_shared_libgcc)) {
7525 CmdArgs.push_back("-lgcc_pic");
7526 if (!Args.hasArg(options::OPT_shared))
7527 CmdArgs.push_back("-lgcc");
7528 } else {
7529 CmdArgs.push_back("-lgcc");
7530 CmdArgs.push_back("--as-needed");
7531 CmdArgs.push_back("-lgcc_pic");
7532 CmdArgs.push_back("--no-as-needed");
7533 }
7534 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007535 } else {
John McCall65b8da02013-04-11 22:55:55 +00007536 if (Args.hasArg(options::OPT_shared)) {
7537 CmdArgs.push_back("-lgcc_pic");
7538 } else {
7539 CmdArgs.push_back("-lgcc");
7540 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00007541 }
7542 }
7543
7544 if (!Args.hasArg(options::OPT_nostdlib) &&
7545 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00007546 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Chris Lattner3e2ee142010-07-07 16:01:42 +00007547 CmdArgs.push_back(Args.MakeArgString(
Daniel Dunbar9c3ed5f2010-07-14 18:46:23 +00007548 getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00007549 else
7550 CmdArgs.push_back(Args.MakeArgString(
7551 getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00007552 CmdArgs.push_back(Args.MakeArgString(
John McCall65b8da02013-04-11 22:55:55 +00007553 getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007554 }
7555
Alexey Samsonov7811d192014-02-20 13:57:37 +00007556 addProfileRT(getToolChain(), Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007557
Logan Chieneb9162f2014-06-26 14:23:45 +00007558 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007559 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00007560}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007561
Alexey Samsonov6424e022014-05-12 20:20:20 +00007562static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7563 ArgStringList &CmdArgs,
7564 const StringRef RTName) {
7565 SmallString<128> LibSanitizer(getCompilerRTLibDir(TC));
7566 llvm::sys::path::append(LibSanitizer,
7567 Twine("clang_rt.") + RTName + ".lib");
7568 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7569}
7570
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007571void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
7572 const InputInfo &Output,
7573 const InputInfoList &Inputs,
7574 const ArgList &Args,
7575 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007576 ArgStringList CmdArgs;
7577
7578 if (Output.isFilename()) {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +00007579 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7580 Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007581 } else {
7582 assert(Output.isNothing() && "Invalid output.");
7583 }
7584
7585 if (!Args.hasArg(options::OPT_nostdlib) &&
Hans Wennborg32e3b722013-08-09 17:38:42 +00007586 !Args.hasArg(options::OPT_nostartfiles) &&
7587 !C.getDriver().IsCLMode()) {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007588 CmdArgs.push_back("-defaultlib:libcmt");
7589 }
7590
7591 CmdArgs.push_back("-nologo");
7592
Hans Wennborgbbb5f072014-04-25 16:24:19 +00007593 if (Args.hasArg(options::OPT_g_Group)) {
7594 CmdArgs.push_back("-debug");
7595 }
7596
Hans Wennborgf1a74252013-09-10 20:18:04 +00007597 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7598
7599 if (DLL) {
7600 CmdArgs.push_back(Args.MakeArgString("-dll"));
7601
7602 SmallString<128> ImplibName(Output.getFilename());
7603 llvm::sys::path::replace_extension(ImplibName, "lib");
7604 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7605 ImplibName.str()));
7606 }
7607
Peter Collingbourne32701642013-11-01 18:16:25 +00007608 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00007609 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00007610 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Hans Wennborgf1a74252013-09-10 20:18:04 +00007611 // FIXME: Handle 64-bit.
Alexey Samsonov6424e022014-05-12 20:20:20 +00007612 if (DLL) {
7613 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7614 "asan_dll_thunk-i386");
7615 } else {
7616 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7617 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7618 }
Hans Wennborg65f17522013-08-27 18:10:21 +00007619 }
7620
Michael J. Spencere2f49362012-06-18 16:56:04 +00007621 Args.AddAllArgValues(CmdArgs, options::OPT_l);
Hans Wennborg2e274592013-08-13 23:38:57 +00007622 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00007623
7624 // Add filenames immediately.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007625 for (const auto &Input : Inputs)
7626 if (Input.isFilename())
7627 CmdArgs.push_back(Input.getFilename());
Hans Wennborgbe4a6762013-08-14 01:24:35 +00007628 else
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007629 Input.getInputArg().renderAsInput(Args, CmdArgs);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007630
7631 const char *Exec =
Daniel Dunbar54423b22010-09-17 00:24:54 +00007632 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00007633 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7634}
Hans Wennborg87cfa712013-09-19 20:32:16 +00007635
7636void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7637 const InputInfo &Output,
7638 const InputInfoList &Inputs,
7639 const ArgList &Args,
7640 const char *LinkingOutput) const {
7641 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7642}
7643
Hans Wennborg188382e2013-09-20 18:16:35 +00007644// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7645// If one cannot be found, return FallbackName.
7646// We do this special search to prevent clang-cl from falling back onto itself
7647// if it's available as cl.exe on the path.
7648static std::string FindFallback(const char *FallbackName,
7649 const char *ClangProgramPath) {
7650 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7651 if (!OptPath.hasValue())
7652 return FallbackName;
7653
7654#ifdef LLVM_ON_WIN32
7655 const StringRef PathSeparators = ";";
7656#else
7657 const StringRef PathSeparators = ":";
7658#endif
7659
7660 SmallVector<StringRef, 8> PathSegments;
7661 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7662
7663 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7664 const StringRef &PathSegment = PathSegments[i];
7665 if (PathSegment.empty())
7666 continue;
7667
7668 SmallString<128> FilePath(PathSegment);
7669 llvm::sys::path::append(FilePath, FallbackName);
7670 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7671 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7672 return FilePath.str();
7673 }
7674
7675 return FallbackName;
7676}
7677
Hans Wennborg87cfa712013-09-19 20:32:16 +00007678Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7679 const InputInfo &Output,
7680 const InputInfoList &Inputs,
7681 const ArgList &Args,
7682 const char *LinkingOutput) const {
7683 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00007684 CmdArgs.push_back("/nologo");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007685 CmdArgs.push_back("/c"); // Compile only.
7686 CmdArgs.push_back("/W0"); // No warnings.
7687
7688 // The goal is to be able to invoke this tool correctly based on
7689 // any flag accepted by clang-cl.
7690
7691 // These are spelled the same way in clang and cl.exe,.
7692 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7693 Args.AddAllArgs(CmdArgs, options::OPT_I);
Hans Wennborgb6331dc2013-09-24 18:17:21 +00007694
7695 // Optimization level.
7696 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7697 if (A->getOption().getID() == options::OPT_O0) {
7698 CmdArgs.push_back("/Od");
7699 } else {
7700 StringRef OptLevel = A->getValue();
7701 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7702 A->render(Args, CmdArgs);
7703 else if (OptLevel == "3")
7704 CmdArgs.push_back("/Ox");
7705 }
7706 }
Hans Wennborg87cfa712013-09-19 20:32:16 +00007707
7708 // Flags for which clang-cl have an alias.
7709 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7710
7711 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7712 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7713 : "/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00007714 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7715 options::OPT_fno_function_sections))
7716 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
7717 ? "/Gy"
7718 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00007719 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7720 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00007721 CmdArgs.push_back(
7722 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007723 if (Args.hasArg(options::OPT_fsyntax_only))
7724 CmdArgs.push_back("/Zs");
Reid Klecknerc688daf2014-02-19 22:05:59 +00007725 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7726 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00007727
Hans Wennborg260ff402013-09-27 17:54:18 +00007728 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007729 for (const auto &Include : Includes)
7730 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00007731
Hans Wennborg87cfa712013-09-19 20:32:16 +00007732 // Flags that can simply be passed through.
7733 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7734 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00007735 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007736
7737 // The order of these flags is relevant, so pick the last one.
7738 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7739 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7740 A->render(Args, CmdArgs);
7741
7742
7743 // Input filename.
7744 assert(Inputs.size() == 1);
7745 const InputInfo &II = Inputs[0];
7746 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7747 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7748 if (II.isFilename())
7749 CmdArgs.push_back(II.getFilename());
7750 else
7751 II.getInputArg().renderAsInput(Args, CmdArgs);
7752
7753 // Output filename.
7754 assert(Output.getType() == types::TY_Object);
7755 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7756 Output.getFilename());
7757 CmdArgs.push_back(Fo);
7758
Hans Wennborg188382e2013-09-20 18:16:35 +00007759 const Driver &D = getToolChain().getDriver();
7760 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
Hans Wennborg188382e2013-09-20 18:16:35 +00007761 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00007762}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007763
7764
7765/// XCore Tools
7766// We pass assemble and link construction to the xcc tool.
7767
7768void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7769 const InputInfo &Output,
7770 const InputInfoList &Inputs,
7771 const ArgList &Args,
7772 const char *LinkingOutput) const {
7773 ArgStringList CmdArgs;
7774
7775 CmdArgs.push_back("-o");
7776 CmdArgs.push_back(Output.getFilename());
7777
7778 CmdArgs.push_back("-c");
7779
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007780 if (Args.hasArg(options::OPT_v))
7781 CmdArgs.push_back("-v");
7782
Robert Lytton894d25c2014-05-02 09:33:25 +00007783 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7784 if (!A->getOption().matches(options::OPT_g0))
7785 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007786
Robert Lytton8e95d4e2014-02-11 10:34:45 +00007787 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7788 false))
7789 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007790
7791 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7792 options::OPT_Xassembler);
7793
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007794 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007795 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007796
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007797 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007798 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7799}
7800
7801void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7802 const InputInfo &Output,
7803 const InputInfoList &Inputs,
7804 const ArgList &Args,
7805 const char *LinkingOutput) const {
7806 ArgStringList CmdArgs;
7807
7808 if (Output.isFilename()) {
7809 CmdArgs.push_back("-o");
7810 CmdArgs.push_back(Output.getFilename());
7811 } else {
7812 assert(Output.isNothing() && "Invalid output.");
7813 }
7814
Robert Lytton9e8c1a42014-02-13 10:40:12 +00007815 if (Args.hasArg(options::OPT_v))
7816 CmdArgs.push_back("-v");
7817
Robert Lyttonf7e03c12014-02-13 10:34:44 +00007818 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7819 if (EH.ShouldUseExceptionTables)
7820 CmdArgs.push_back("-fexceptions");
7821
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007822 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7823
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007824 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00007825 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7826}