blob: bcc2af8fc002043b26cba8c47d981d2ac662ecef [file] [log] [blame]
Eugene Zelenkod4304d22015-11-04 21:37:17 +00001//===--- Tools.cpp - Tools Implementations ----------------------*- C++ -*-===//
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000012#include "ToolChains.h"
Ben Langmuire056ec32015-02-04 18:34:23 +000013#include "clang/Basic/CharInfo.h"
Josh Mageee0fc1a82014-02-11 01:35:14 +000014#include "clang/Basic/LangOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000015#include "clang/Basic/ObjCRuntime.h"
Kevin Enderbyae2ec472013-01-17 21:38:06 +000016#include "clang/Basic/Version.h"
Rafael Espindola3e34e652015-02-03 16:33:53 +000017#include "clang/Config/config.h"
Daniel Dunbara2aedc62009-03-18 10:01:51 +000018#include "clang/Driver/Action.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000019#include "clang/Driver/Compilation.h"
Daniel Dunbar1a8a2e82009-10-29 02:39:57 +000020#include "clang/Driver/Driver.h"
21#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000022#include "clang/Driver/Job.h"
Daniel Dunbarda13faf2009-11-19 04:25:22 +000023#include "clang/Driver/Options.h"
Alexey Samsonov609213f92013-08-19 09:14:21 +000024#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbara3246a02009-03-18 08:07:30 +000025#include "clang/Driver/ToolChain.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000026#include "clang/Driver/Util.h"
Benjamin Kramer33335df2015-03-01 21:36:40 +000027#include "llvm/ADT/STLExtras.h"
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +000028#include "llvm/ADT/SmallString.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000029#include "llvm/ADT/StringExtras.h"
Douglas Gregorf7b87cb2009-10-29 00:41:01 +000030#include "llvm/ADT/StringSwitch.h"
Daniel Dunbarb4a3e432009-09-09 22:32:34 +000031#include "llvm/ADT/Twine.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000032#include "llvm/Option/Arg.h"
33#include "llvm/Option/ArgList.h"
34#include "llvm/Option/Option.h"
James Y Knight5bdf7ab2015-08-19 15:12:02 +000035#include "llvm/Support/CodeGen.h"
David Blaikie24bbfed22014-03-31 23:29:38 +000036#include "llvm/Support/Compression.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000037#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf6efe582011-01-10 02:34:13 +000038#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000039#include "llvm/Support/Host.h"
Hans Wennborg188382e2013-09-20 18:16:35 +000040#include "llvm/Support/Path.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000041#include "llvm/Support/Process.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000042#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000043#include "llvm/Support/raw_ostream.h"
James Y Knight5bdf7ab2015-08-19 15:12:02 +000044#include "llvm/Support/TargetParser.h"
Daniel Dunbar04c4c2c2009-03-18 07:06:02 +000045
Ben Langmuir3b7b5402015-02-03 19:28:37 +000046#ifdef LLVM_ON_UNIX
47#include <unistd.h> // For getuid().
48#endif
49
Daniel Dunbar1a093d22009-03-18 06:00:36 +000050using namespace clang::driver;
51using namespace clang::driver::tools;
Chris Lattner0e62c1c2011-07-23 10:55:15 +000052using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000053using namespace llvm::opt;
Daniel Dunbar1a093d22009-03-18 06:00:36 +000054
Eric Christopher49062a52015-12-22 03:12:34 +000055static void handleTargetFeaturesGroup(const ArgList &Args,
56 std::vector<const char *> &Features,
57 OptSpecifier Group) {
58 for (const Arg *A : Args.filtered(Group)) {
59 StringRef Name = A->getOption().getName();
60 A->claim();
61
62 // Skip over "-m".
63 assert(Name.startswith("m") && "Invalid feature name.");
64 Name = Name.substr(1);
65
66 bool IsNegative = Name.startswith("no-");
67 if (IsNegative)
68 Name = Name.substr(3);
69 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
70 }
71}
72
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +000073static const char *getSparcAsmModeForCPU(StringRef Name,
74 const llvm::Triple &Triple) {
75 if (Triple.getArch() == llvm::Triple::sparcv9) {
76 return llvm::StringSwitch<const char *>(Name)
77 .Case("niagara", "-Av9b")
78 .Case("niagara2", "-Av9b")
79 .Case("niagara3", "-Av9d")
80 .Case("niagara4", "-Av9d")
81 .Default("-Av9");
82 } else {
83 return llvm::StringSwitch<const char *>(Name)
84 .Case("v8", "-Av8")
85 .Case("supersparc", "-Av8")
86 .Case("sparclite", "-Asparclite")
87 .Case("f934", "-Asparclite")
88 .Case("hypersparc", "-Av8")
89 .Case("sparclite86x", "-Asparclite")
90 .Case("sparclet", "-Asparclet")
91 .Case("tsc701", "-Asparclet")
92 .Case("v9", "-Av8plus")
93 .Case("ultrasparc", "-Av8plus")
94 .Case("ultrasparc3", "-Av8plus")
95 .Case("niagara", "-Av8plusb")
96 .Case("niagara2", "-Av8plusb")
97 .Case("niagara3", "-Av8plusd")
98 .Case("niagara4", "-Av8plusd")
99 .Default("-Av8");
100 }
101}
102
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000103/// CheckPreprocessingOptions - Perform some validation of preprocessing
104/// arguments that is shared with gcc.
105static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +0000106 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
107 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
108 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000109 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +0000110 << A->getBaseArg().getAsString(Args)
111 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
112 }
113 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000114}
115
Daniel Dunbar4eadb602009-09-10 01:21:12 +0000116/// CheckCodeGenerationOptions - Perform some validation of code generation
117/// arguments that is shared with gcc.
118static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
119 // In gcc, only ARM checks this, but it seems reasonable to check universally.
120 if (Args.hasArg(options::OPT_static))
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000121 if (const Arg *A =
122 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
123 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
124 << "-static";
Daniel Dunbar4eadb602009-09-10 01:21:12 +0000125}
126
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000127// Add backslashes to escape spaces and other backslashes.
128// This is used for the space-separated argument list specified with
129// the -dwarf-debug-flags option.
130static void EscapeSpacesAndBackslashes(const char *Arg,
131 SmallVectorImpl<char> &Res) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000132 for (; *Arg; ++Arg) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000133 switch (*Arg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000134 default:
135 break;
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000136 case ' ':
137 case '\\':
138 Res.push_back('\\');
139 break;
140 }
141 Res.push_back(*Arg);
142 }
143}
144
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000145// Quote target names for inclusion in GNU Make dependency files.
146// Only the characters '$', '#', ' ', '\t' are quoted.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000147static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000148 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
149 switch (Target[i]) {
150 case ' ':
151 case '\t':
152 // Escape the preceding backslashes
153 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
154 Res.push_back('\\');
155
156 // Escape the space/tab
157 Res.push_back('\\');
158 break;
159 case '$':
160 Res.push_back('$');
161 break;
162 case '#':
163 Res.push_back('\\');
164 break;
165 default:
166 break;
167 }
168
169 Res.push_back(Target[i]);
170 }
171}
172
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000173static void addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
174 const char *ArgName, const char *EnvVar) {
Bill Wendlingc0938f32012-03-12 22:10:06 +0000175 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000176 bool CombinedArg = false;
177
Bill Wendling281ca292012-03-12 21:22:35 +0000178 if (!DirList)
179 return; // Nothing to do.
180
Chad Rosier616e8a52012-10-30 21:42:09 +0000181 StringRef Name(ArgName);
182 if (Name.equals("-I") || Name.equals("-L"))
183 CombinedArg = true;
184
Bill Wendling281ca292012-03-12 21:22:35 +0000185 StringRef Dirs(DirList);
186 if (Dirs.empty()) // Empty string should not add '.'.
187 return;
188
189 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000190 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000191 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000192 if (CombinedArg) {
193 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
194 } else {
195 CmdArgs.push_back(ArgName);
196 CmdArgs.push_back(".");
197 }
Bill Wendling281ca292012-03-12 21:22:35 +0000198 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000199 if (CombinedArg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000200 CmdArgs.push_back(
201 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
Chad Rosier616e8a52012-10-30 21:42:09 +0000202 } else {
203 CmdArgs.push_back(ArgName);
204 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
205 }
Bill Wendling281ca292012-03-12 21:22:35 +0000206 }
Nico Weber89355782012-03-19 15:00:03 +0000207 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000208 }
209
210 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000211 if (CombinedArg) {
212 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
213 } else {
214 CmdArgs.push_back(ArgName);
215 CmdArgs.push_back(".");
216 }
Bill Wendling281ca292012-03-12 21:22:35 +0000217 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000218 if (CombinedArg) {
219 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
220 } else {
221 CmdArgs.push_back(ArgName);
222 CmdArgs.push_back(Args.MakeArgString(Dirs));
223 }
Bill Wendling281ca292012-03-12 21:22:35 +0000224 }
225}
226
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000227static void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
228 const ArgList &Args, ArgStringList &CmdArgs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000229 const Driver &D = TC.getDriver();
230
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000231 // Add extra linker input arguments which are not treated as inputs
232 // (constructed via -Xarch_).
233 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
234
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000235 for (const auto &II : Inputs) {
Eric Christopherc1984072015-12-08 02:10:19 +0000236 if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(II.getType()))
Daniel Dunbar54423b22010-09-17 00:24:54 +0000237 // Don't try to pass LLVM inputs unless we have native support.
Eric Christopherc1984072015-12-08 02:10:19 +0000238 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
Daniel Dunbar54423b22010-09-17 00:24:54 +0000239
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000240 // Add filenames immediately.
241 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000242 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000243 continue;
244 }
245
246 // Otherwise, this is a linker input argument.
247 const Arg &A = II.getInputArg();
248
249 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000250 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000251 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000252 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000253 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000254 else if (A.getOption().matches(options::OPT_z)) {
255 // Pass -z prefix for gcc linker compatibility.
256 A.claim();
257 A.render(Args, CmdArgs);
258 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000259 A.renderAsInput(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000260 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000261 }
Bill Wendling281ca292012-03-12 21:22:35 +0000262
263 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000264 // and only supported on native toolchains.
265 if (!TC.isCrossCompiling())
266 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000267}
268
John McCall31168b02011-06-15 23:02:42 +0000269/// \brief Determine whether Objective-C automated reference counting is
270/// enabled.
271static bool isObjCAutoRefCount(const ArgList &Args) {
272 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
273}
274
Ted Kremeneke65b0862012-03-06 20:05:56 +0000275/// \brief Determine whether we are linking the ObjC runtime.
276static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000277 if (isObjCAutoRefCount(Args)) {
278 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000279 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000280 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000281 return Args.hasArg(options::OPT_fobjc_link_runtime);
282}
283
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000284static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000285 // Don't forward inputs from the original command line. They are added from
286 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000287 return O.getKind() != Option::InputClass &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000288 !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000289}
290
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000291void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
292 const Driver &D, const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000293 ArgStringList &CmdArgs,
294 const InputInfo &Output,
Artem Belevichfa11ab52015-11-17 22:28:46 +0000295 const InputInfoList &Inputs,
296 const ToolChain *AuxToolChain) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000297 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000298
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000299 CheckPreprocessingOptions(D, Args);
300
301 Args.AddLastArg(CmdArgs, options::OPT_C);
302 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000303
304 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000305 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000306 (A = Args.getLastArg(options::OPT_MD)) ||
307 (A = Args.getLastArg(options::OPT_MMD))) {
308 // Determine the output location.
309 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000310 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000311 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000312 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000313 } else if (Output.getType() == types::TY_Dependencies) {
314 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000315 } else if (A->getOption().matches(options::OPT_M) ||
316 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000317 DepFile = "-";
318 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000319 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000320 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000321 }
322 CmdArgs.push_back("-dependency-file");
323 CmdArgs.push_back(DepFile);
324
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000325 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000326 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
327 const char *DepTarget;
328
329 // If user provided -o, that is the dependency target, except
330 // when we are only generating a dependency file.
331 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
332 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000333 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000334 } else {
335 // Otherwise derive from the base input.
336 //
337 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000338 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000339 llvm::sys::path::replace_extension(P, "o");
340 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000341 }
342
343 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000344 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000345 QuoteTarget(DepTarget, Quoted);
346 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000347 }
348
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000349 if (A->getOption().matches(options::OPT_M) ||
350 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000351 CmdArgs.push_back("-sys-header-deps");
Manuel Klimekc68aa162015-03-19 12:00:22 +0000352 if ((isa<PrecompileJobAction>(JA) &&
353 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
354 Args.hasArg(options::OPT_fmodule_file_deps))
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000355 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000356 }
357
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000358 if (Args.hasArg(options::OPT_MG)) {
359 if (!A || A->getOption().matches(options::OPT_MD) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000360 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000361 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000362 CmdArgs.push_back("-MG");
363 }
364
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000365 Args.AddLastArg(CmdArgs, options::OPT_MP);
Paul Robinsond7214a72015-04-27 18:14:32 +0000366 Args.AddLastArg(CmdArgs, options::OPT_MV);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000367
368 // Convert all -MQ <target> args to -MT <quoted target>
Sean Silva14facf32015-06-09 01:57:17 +0000369 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000370 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000371
Daniel Dunbara442fd52010-06-11 22:00:13 +0000372 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000373 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000374 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000375 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000376 CmdArgs.push_back(Args.MakeArgString(Quoted));
377
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000378 // -MT flag - no change
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000379 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000380 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000381 }
382 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000383
Douglas Gregor111af7d2009-04-18 00:34:01 +0000384 // Add -i* options, and automatically translate to
385 // -include-pch/-include-pth for transparent PCH support. It's
386 // wonky, but we include looking for .gch so we can support seamless
387 // replacement into a build system already set up to be generating
388 // .gch files.
Nico Weber2ca4be92016-03-01 23:16:44 +0000389 int YcIndex = -1, YuIndex = -1;
390 {
391 int AI = -1;
392 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
393 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
394 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
395 // Walk the whole i_Group and skip non "-include" flags so that the index
396 // here matches the index in the next loop below.
397 ++AI;
398 if (!A->getOption().matches(options::OPT_include))
399 continue;
400 if (YcArg && strcmp(A->getValue(), YcArg->getValue()) == 0)
401 YcIndex = AI;
402 if (YuArg && strcmp(A->getValue(), YuArg->getValue()) == 0)
403 YuIndex = AI;
404 }
405 }
406 if (isa<PrecompileJobAction>(JA) && YcIndex != -1) {
407 Driver::InputList Inputs;
408 D.BuildInputs(getToolChain(), C.getArgs(), Inputs);
409 assert(Inputs.size() == 1 && "Need one input when building pch");
410 CmdArgs.push_back(Args.MakeArgString(Twine("-find-pch-source=") +
411 Inputs[0].second->getValue()));
412 }
413
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000414 bool RenderedImplicitInclude = false;
Nico Weber2ca4be92016-03-01 23:16:44 +0000415 int AI = -1;
Sean Silva14facf32015-06-09 01:57:17 +0000416 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
Nico Weber2ca4be92016-03-01 23:16:44 +0000417 ++AI;
418
Nico Weberd8ff0ee2016-04-02 19:10:07 +0000419 if (getToolChain().getDriver().IsCLMode() &&
420 A->getOption().matches(options::OPT_include)) {
Junmo Parke19d6792016-03-17 06:41:27 +0000421 // In clang-cl mode, /Ycfoo.h means that all code up to a foo.h
Nico Weber2ca4be92016-03-01 23:16:44 +0000422 // include is compiled into foo.h, and everything after goes into
423 // the .obj file. /Yufoo.h means that all includes prior to and including
424 // foo.h are completely skipped and replaced with a use of the pch file
425 // for foo.h. (Each flag can have at most one value, multiple /Yc flags
426 // just mean that the last one wins.) If /Yc and /Yu are both present
427 // and refer to the same file, /Yc wins.
428 // Note that OPT__SLASH_FI gets mapped to OPT_include.
429 // FIXME: The code here assumes that /Yc and /Yu refer to the same file.
430 // cl.exe seems to support both flags with different values, but that
431 // seems strange (which flag does /Fp now refer to?), so don't implement
Nico Weberd1728f02016-03-23 18:17:02 +0000432 // that until someone needs it.
Nico Weber2ca4be92016-03-01 23:16:44 +0000433 int PchIndex = YcIndex != -1 ? YcIndex : YuIndex;
434 if (PchIndex != -1) {
435 if (isa<PrecompileJobAction>(JA)) {
436 // When building the pch, skip all includes after the pch.
437 assert(YcIndex != -1 && PchIndex == YcIndex);
438 if (AI >= YcIndex)
439 continue;
440 } else {
441 // When using the pch, skip all includes prior to the pch.
Nico Weberd1728f02016-03-23 18:17:02 +0000442 if (AI < PchIndex) {
443 A->claim();
Nico Weber2ca4be92016-03-01 23:16:44 +0000444 continue;
Nico Weberd1728f02016-03-23 18:17:02 +0000445 }
Nico Weber2ca4be92016-03-01 23:16:44 +0000446 if (AI == PchIndex) {
447 A->claim();
448 CmdArgs.push_back("-include-pch");
449 CmdArgs.push_back(
450 Args.MakeArgString(D.GetClPchPath(C, A->getValue())));
451 continue;
452 }
453 }
454 }
455 } else if (A->getOption().matches(options::OPT_include)) {
456 // Handling of gcc-style gch precompiled headers.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000457 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
458 RenderedImplicitInclude = true;
459
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000460 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000461 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000462
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000463 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000464 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000465 SmallString<128> P(A->getValue());
466 // We want the files to have a name like foo.h.pch. Add a dummy extension
467 // so that replace_extension does the right thing.
468 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000469 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000470 llvm::sys::path::replace_extension(P, "pch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000471 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000472 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000473 }
474
Douglas Gregor111af7d2009-04-18 00:34:01 +0000475 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000476 llvm::sys::path::replace_extension(P, "pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000477 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000478 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000479 }
480
Douglas Gregor111af7d2009-04-18 00:34:01 +0000481 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000482 llvm::sys::path::replace_extension(P, "gch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000483 if (llvm::sys::fs::exists(P)) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000484 FoundPCH = UsePCH;
485 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000486 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000487 }
488
489 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000490 if (IsFirstImplicitInclude) {
491 A->claim();
492 if (UsePCH)
493 CmdArgs.push_back("-include-pch");
494 else
495 CmdArgs.push_back("-include-pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000496 CmdArgs.push_back(Args.MakeArgString(P));
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000497 continue;
498 } else {
499 // Ignore the PCH if not first on command line and emit warning.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000500 D.Diag(diag::warn_drv_pch_not_first_include) << P
501 << A->getAsString(Args);
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000502 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000503 }
504 }
505
506 // Not translated, render as usual.
507 A->claim();
508 A->render(Args, CmdArgs);
509 }
510
Douglas Katzman57a9c7e2015-07-29 18:39:14 +0000511 Args.AddAllArgs(CmdArgs,
512 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
513 options::OPT_F, options::OPT_index_header_map});
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000514
Douglas Katzman9dc81a42015-10-02 14:41:38 +0000515 // Add -Wp, and -Xpreprocessor if using the preprocessor.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000516
517 // FIXME: There is a very unfortunate problem here, some troubled
518 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
519 // really support that we would have to parse and then translate
520 // those options. :(
521 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
522 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000523
524 // -I- is a deprecated GCC feature, reject it.
525 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000526 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000527
528 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
529 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000530 StringRef sysroot = C.getSysRoot();
531 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000532 if (!Args.hasArg(options::OPT_isysroot)) {
533 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000534 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000535 }
536 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000537
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000538 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000539 // FIXME: We should probably sink the logic for handling these from the
540 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000541 // CPATH - included following the user specified includes (but prior to
542 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000543 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000544 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000545 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000546 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000547 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000548 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000549 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000550 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000551 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000552
Artem Belevichfa11ab52015-11-17 22:28:46 +0000553 // Optional AuxToolChain indicates that we need to include headers
554 // for more than one target. If that's the case, add include paths
555 // from AuxToolChain right after include paths of the same kind for
556 // the current target.
557
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000558 // Add C++ include arguments, if needed.
Artem Belevichfa11ab52015-11-17 22:28:46 +0000559 if (types::isCXX(Inputs[0].getType())) {
Chandler Carruth491db322011-11-04 07:34:47 +0000560 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Artem Belevichfa11ab52015-11-17 22:28:46 +0000561 if (AuxToolChain)
562 AuxToolChain->AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
563 }
Chandler Carrutha796f532011-11-05 20:17:13 +0000564
565 // Add system include arguments.
566 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Artem Belevichfa11ab52015-11-17 22:28:46 +0000567 if (AuxToolChain)
568 AuxToolChain->AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
569
570 // Add CUDA include arguments, if needed.
571 if (types::isCuda(Inputs[0].getType()))
572 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000573}
574
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000575// FIXME: Move to target hook.
576static bool isSignedCharDefault(const llvm::Triple &Triple) {
577 switch (Triple.getArch()) {
578 default:
579 return true;
580
Tim Northover9bb857a2013-01-31 12:13:10 +0000581 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000582 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000583 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000584 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000585 case llvm::Triple::thumb:
586 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000587 if (Triple.isOSDarwin() || Triple.isOSWindows())
588 return true;
589 return false;
590
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000591 case llvm::Triple::ppc:
592 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000593 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000594 return true;
595 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000596
David Majnemerdcecd932015-05-23 19:23:55 +0000597 case llvm::Triple::hexagon:
Bill Schmidt778d3872013-07-26 01:36:11 +0000598 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000599 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000600 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000601 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000602 }
603}
604
Robert Lytton0e076492013-08-13 09:43:10 +0000605static bool isNoCommonDefault(const llvm::Triple &Triple) {
606 switch (Triple.getArch()) {
607 default:
608 return false;
609
610 case llvm::Triple::xcore:
Dan Gohmanc2853072015-09-03 22:51:53 +0000611 case llvm::Triple::wasm32:
612 case llvm::Triple::wasm64:
Robert Lytton0e076492013-08-13 09:43:10 +0000613 return true;
614 }
615}
616
Renato Goline17c5802015-07-27 23:44:42 +0000617// ARM tools start.
618
619// Get SubArch (vN).
620static int getARMSubArchVersionNumber(const llvm::Triple &Triple) {
621 llvm::StringRef Arch = Triple.getArchName();
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000622 return llvm::ARM::parseArchVersion(Arch);
Renato Goline17c5802015-07-27 23:44:42 +0000623}
624
625// True if M-profile.
626static bool isARMMProfile(const llvm::Triple &Triple) {
627 llvm::StringRef Arch = Triple.getArchName();
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000628 unsigned Profile = llvm::ARM::parseArchProfile(Arch);
Renato Goline17c5802015-07-27 23:44:42 +0000629 return Profile == llvm::ARM::PK_M;
630}
631
632// Get Arch/CPU from args.
Renato Golin7c542b42015-07-27 23:44:45 +0000633static void getARMArchCPUFromArgs(const ArgList &Args, llvm::StringRef &Arch,
634 llvm::StringRef &CPU, bool FromAs = false) {
Renato Goline17c5802015-07-27 23:44:42 +0000635 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
636 CPU = A->getValue();
637 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
638 Arch = A->getValue();
Renato Golin7c542b42015-07-27 23:44:45 +0000639 if (!FromAs)
640 return;
641
642 for (const Arg *A :
643 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
644 StringRef Value = A->getValue();
645 if (Value.startswith("-mcpu="))
646 CPU = Value.substr(6);
647 if (Value.startswith("-march="))
648 Arch = Value.substr(7);
649 }
Renato Goline17c5802015-07-27 23:44:42 +0000650}
651
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000652// Handle -mhwdiv=.
Renato Golin7c542b42015-07-27 23:44:45 +0000653// FIXME: Use ARMTargetParser.
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000654static void getARMHWDivFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000655 const ArgList &Args, StringRef HWDiv,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000656 std::vector<const char *> &Features) {
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000657 unsigned HWDivID = llvm::ARM::parseHWDiv(HWDiv);
658 if (!llvm::ARM::getHWDivFeatures(HWDivID, Features))
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000659 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
660}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000661
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000662// Handle -mfpu=.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000663static void getARMFPUFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000664 const ArgList &Args, StringRef FPU,
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000665 std::vector<const char *> &Features) {
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000666 unsigned FPUID = llvm::ARM::parseFPU(FPU);
667 if (!llvm::ARM::getFPUFeatures(FPUID, Features))
Chad Rosiercfbfc582012-04-04 20:51:35 +0000668 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
669}
670
Bradley Smithbbf5a002015-11-18 16:33:48 +0000671// Decode ARM features from string like +[no]featureA+[no]featureB+...
672static bool DecodeARMFeatures(const Driver &D, StringRef text,
673 std::vector<const char *> &Features) {
674 SmallVector<StringRef, 8> Split;
675 text.split(Split, StringRef("+"), -1, false);
676
677 for (StringRef Feature : Split) {
678 const char *FeatureName = llvm::ARM::getArchExtFeature(Feature);
679 if (FeatureName)
680 Features.push_back(FeatureName);
681 else
682 return false;
683 }
684 return true;
685}
686
Renato Golin7c542b42015-07-27 23:44:45 +0000687// Check if -march is valid by checking if it can be canonicalised and parsed.
688// getARMArch is used here instead of just checking the -march value in order
689// to handle -march=native correctly.
690static void checkARMArchName(const Driver &D, const Arg *A, const ArgList &Args,
Renato Goline17c5802015-07-27 23:44:42 +0000691 llvm::StringRef ArchName,
Bradley Smithbbf5a002015-11-18 16:33:48 +0000692 std::vector<const char *> &Features,
Renato Goline17c5802015-07-27 23:44:42 +0000693 const llvm::Triple &Triple) {
Bradley Smithbbf5a002015-11-18 16:33:48 +0000694 std::pair<StringRef, StringRef> Split = ArchName.split("+");
695
Renato Goline17c5802015-07-27 23:44:42 +0000696 std::string MArch = arm::getARMArch(ArchName, Triple);
Bradley Smithbbf5a002015-11-18 16:33:48 +0000697 if (llvm::ARM::parseArch(MArch) == llvm::ARM::AK_INVALID ||
698 (Split.second.size() && !DecodeARMFeatures(D, Split.second, Features)))
Renato Goline17c5802015-07-27 23:44:42 +0000699 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000700}
701
Renato Golin7c542b42015-07-27 23:44:45 +0000702// Check -mcpu=. Needs ArchName to handle -mcpu=generic.
703static void checkARMCPUName(const Driver &D, const Arg *A, const ArgList &Args,
704 llvm::StringRef CPUName, llvm::StringRef ArchName,
Bradley Smithbbf5a002015-11-18 16:33:48 +0000705 std::vector<const char *> &Features,
Renato Goline17c5802015-07-27 23:44:42 +0000706 const llvm::Triple &Triple) {
Bradley Smithbbf5a002015-11-18 16:33:48 +0000707 std::pair<StringRef, StringRef> Split = CPUName.split("+");
708
Renato Goline17c5802015-07-27 23:44:42 +0000709 std::string CPU = arm::getARMTargetCPU(CPUName, ArchName, Triple);
Bradley Smithbbf5a002015-11-18 16:33:48 +0000710 if (arm::getLLVMArchSuffixForARM(CPU, ArchName, Triple).empty() ||
711 (Split.second.size() && !DecodeARMFeatures(D, Split.second, Features)))
Renato Goline17c5802015-07-27 23:44:42 +0000712 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000713}
714
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000715static bool useAAPCSForMachO(const llvm::Triple &T) {
716 // The backend is hardwired to assume AAPCS for M-class processors, ensure
717 // the frontend matches that.
718 return T.getEnvironment() == llvm::Triple::EABI ||
719 T.getOS() == llvm::Triple::UnknownOS || isARMMProfile(T);
720}
721
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000722// Select the float ABI as determined by -msoft-float, -mhard-float, and
723// -mfloat-abi=.
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000724arm::FloatABI arm::getARMFloatABI(const ToolChain &TC, const ArgList &Args) {
725 const Driver &D = TC.getDriver();
726 const llvm::Triple Triple(TC.ComputeEffectiveClangTriple(Args));
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000727 auto SubArch = getARMSubArchVersionNumber(Triple);
728 arm::FloatABI ABI = FloatABI::Invalid;
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000729 if (Arg *A =
730 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
731 options::OPT_mfloat_abi_EQ)) {
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000732 if (A->getOption().matches(options::OPT_msoft_float)) {
733 ABI = FloatABI::Soft;
734 } else if (A->getOption().matches(options::OPT_mhard_float)) {
735 ABI = FloatABI::Hard;
736 } else {
737 ABI = llvm::StringSwitch<arm::FloatABI>(A->getValue())
738 .Case("soft", FloatABI::Soft)
739 .Case("softfp", FloatABI::SoftFP)
740 .Case("hard", FloatABI::Hard)
741 .Default(FloatABI::Invalid);
742 if (ABI == FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000743 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000744 ABI = FloatABI::Soft;
Daniel Dunbar78485922009-09-10 23:00:09 +0000745 }
746 }
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000747
748 // It is incorrect to select hard float ABI on MachO platforms if the ABI is
749 // "apcs-gnu".
750 if (Triple.isOSBinFormatMachO() && !useAAPCSForMachO(Triple) &&
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000751 ABI == FloatABI::Hard) {
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000752 D.Diag(diag::err_drv_unsupported_opt_for_target) << A->getAsString(Args)
753 << Triple.getArchName();
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000754 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000755 }
756
757 // If unspecified, choose the default based on the platform.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000758 if (ABI == FloatABI::Invalid) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000759 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000760 case llvm::Triple::Darwin:
761 case llvm::Triple::MacOSX:
Tim Northover756447a2015-10-30 16:30:36 +0000762 case llvm::Triple::IOS:
763 case llvm::Triple::TvOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000764 // Darwin defaults to "softfp" for v6 and v7.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000765 ABI = (SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
Tim Northoverd88ecb32016-01-27 19:32:40 +0000766 ABI = Triple.isWatchABI() ? FloatABI::Hard : ABI;
Daniel Dunbar78485922009-09-10 23:00:09 +0000767 break;
768 }
Tim Northover756447a2015-10-30 16:30:36 +0000769 case llvm::Triple::WatchOS:
770 ABI = FloatABI::Hard;
771 break;
Daniel Dunbar78485922009-09-10 23:00:09 +0000772
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000773 // FIXME: this is invalid for WindowsCE
774 case llvm::Triple::Win32:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000775 ABI = FloatABI::Hard;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000776 break;
777
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000778 case llvm::Triple::FreeBSD:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000779 switch (Triple.getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +0000780 case llvm::Triple::GNUEABIHF:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000781 ABI = FloatABI::Hard;
Renato Golinf4421f72014-02-19 10:44:07 +0000782 break;
783 default:
784 // FreeBSD defaults to soft float
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000785 ABI = FloatABI::Soft;
Renato Golinf4421f72014-02-19 10:44:07 +0000786 break;
787 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000788 break;
789
Daniel Dunbar78485922009-09-10 23:00:09 +0000790 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000791 switch (Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000792 case llvm::Triple::GNUEABIHF:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000793 case llvm::Triple::EABIHF:
794 ABI = FloatABI::Hard;
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000795 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000796 case llvm::Triple::GNUEABI:
Bob Wilsond1447c42011-02-04 17:59:28 +0000797 case llvm::Triple::EABI:
798 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000799 ABI = FloatABI::SoftFP;
Bob Wilsond1447c42011-02-04 17:59:28 +0000800 break;
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000801 case llvm::Triple::Android:
802 ABI = (SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000803 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000804 default:
805 // Assume "soft", but warn the user we are guessing.
Tim Northover99694fe2016-04-13 17:08:51 +0000806 if (Triple.isOSBinFormatMachO() &&
807 Triple.getSubArch() == llvm::Triple::ARMSubArch_v7em)
808 ABI = FloatABI::Hard;
809 else
810 ABI = FloatABI::Soft;
811
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000812 if (Triple.getOS() != llvm::Triple::UnknownOS ||
813 !Triple.isOSBinFormatMachO())
814 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000815 break;
816 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000817 }
818 }
819
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000820 assert(ABI != FloatABI::Invalid && "must select an ABI");
821 return ABI;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000822}
823
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000824static void getARMTargetFeatures(const ToolChain &TC,
825 const llvm::Triple &Triple,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000826 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000827 std::vector<const char *> &Features,
828 bool ForAS) {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000829 const Driver &D = TC.getDriver();
830
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000831 bool KernelOrKext =
832 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000833 arm::FloatABI ABI = arm::getARMFloatABI(TC, Args);
Renato Golin7c542b42015-07-27 23:44:45 +0000834 const Arg *WaCPU = nullptr, *WaFPU = nullptr;
835 const Arg *WaHDiv = nullptr, *WaArch = nullptr;
836
Nico Weber6e0ebae2015-04-29 21:16:40 +0000837 if (!ForAS) {
838 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
839 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
840 // stripped out by the ARM target. We should probably pass this a new
841 // -target-option, which is handled by the -cc1/-cc1as invocation.
842 //
843 // FIXME2: For consistency, it would be ideal if we set up the target
844 // machine state the same when using the frontend or the assembler. We don't
845 // currently do that for the assembler, we pass the options directly to the
846 // backend and never even instantiate the frontend TargetInfo. If we did,
847 // and used its handleTargetFeatures hook, then we could ensure the
848 // assembler and the frontend behave the same.
849
850 // Use software floating point operations?
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000851 if (ABI == arm::FloatABI::Soft)
Nico Weber6e0ebae2015-04-29 21:16:40 +0000852 Features.push_back("+soft-float");
853
854 // Use software floating point argument passing?
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000855 if (ABI != arm::FloatABI::Hard)
Nico Weber6e0ebae2015-04-29 21:16:40 +0000856 Features.push_back("+soft-float-abi");
Renato Golin7c542b42015-07-27 23:44:45 +0000857 } else {
858 // Here, we make sure that -Wa,-mfpu/cpu/arch/hwdiv will be passed down
859 // to the assembler correctly.
860 for (const Arg *A :
861 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
862 StringRef Value = A->getValue();
863 if (Value.startswith("-mfpu=")) {
864 WaFPU = A;
865 } else if (Value.startswith("-mcpu=")) {
866 WaCPU = A;
867 } else if (Value.startswith("-mhwdiv=")) {
868 WaHDiv = A;
869 } else if (Value.startswith("-march=")) {
870 WaArch = A;
871 }
872 }
Nico Weber6e0ebae2015-04-29 21:16:40 +0000873 }
874
Renato Golin7c542b42015-07-27 23:44:45 +0000875 // Check -march. ClangAs gives preference to -Wa,-march=.
876 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000877 StringRef ArchName;
Renato Golin7c542b42015-07-27 23:44:45 +0000878 if (WaArch) {
879 if (ArchArg)
880 D.Diag(clang::diag::warn_drv_unused_argument)
881 << ArchArg->getAsString(Args);
882 ArchName = StringRef(WaArch->getValue()).substr(7);
Bradley Smithbbf5a002015-11-18 16:33:48 +0000883 checkARMArchName(D, WaArch, Args, ArchName, Features, Triple);
Renato Golin7c542b42015-07-27 23:44:45 +0000884 // FIXME: Set Arch.
885 D.Diag(clang::diag::warn_drv_unused_argument) << WaArch->getAsString(Args);
886 } else if (ArchArg) {
887 ArchName = ArchArg->getValue();
Bradley Smithbbf5a002015-11-18 16:33:48 +0000888 checkARMArchName(D, ArchArg, Args, ArchName, Features, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000889 }
890
Renato Golin7c542b42015-07-27 23:44:45 +0000891 // Check -mcpu. ClangAs gives preference to -Wa,-mcpu=.
892 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000893 StringRef CPUName;
Renato Golin7c542b42015-07-27 23:44:45 +0000894 if (WaCPU) {
895 if (CPUArg)
896 D.Diag(clang::diag::warn_drv_unused_argument)
897 << CPUArg->getAsString(Args);
898 CPUName = StringRef(WaCPU->getValue()).substr(6);
Bradley Smithbbf5a002015-11-18 16:33:48 +0000899 checkARMCPUName(D, WaCPU, Args, CPUName, ArchName, Features, Triple);
Renato Golin7c542b42015-07-27 23:44:45 +0000900 } else if (CPUArg) {
901 CPUName = CPUArg->getValue();
Bradley Smithbbf5a002015-11-18 16:33:48 +0000902 checkARMCPUName(D, CPUArg, Args, CPUName, ArchName, Features, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000903 }
John Brawna95c1a82015-05-08 12:52:18 +0000904
Renato Golin23459c62015-07-30 16:40:17 +0000905 // Add CPU features for generic CPUs
906 if (CPUName == "native") {
907 llvm::StringMap<bool> HostFeatures;
908 if (llvm::sys::getHostCPUFeatures(HostFeatures))
909 for (auto &F : HostFeatures)
910 Features.push_back(
911 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
912 }
913
914 // Honor -mfpu=. ClangAs gives preference to -Wa,-mfpu=.
915 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
916 if (WaFPU) {
917 if (FPUArg)
918 D.Diag(clang::diag::warn_drv_unused_argument)
919 << FPUArg->getAsString(Args);
920 getARMFPUFeatures(D, WaFPU, Args, StringRef(WaFPU->getValue()).substr(6),
921 Features);
922 } else if (FPUArg) {
923 getARMFPUFeatures(D, FPUArg, Args, FPUArg->getValue(), Features);
924 }
925
926 // Honor -mhwdiv=. ClangAs gives preference to -Wa,-mhwdiv=.
927 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
928 if (WaHDiv) {
929 if (HDivArg)
930 D.Diag(clang::diag::warn_drv_unused_argument)
931 << HDivArg->getAsString(Args);
932 getARMHWDivFeatures(D, WaHDiv, Args,
933 StringRef(WaHDiv->getValue()).substr(8), Features);
934 } else if (HDivArg)
935 getARMHWDivFeatures(D, HDivArg, Args, HDivArg->getValue(), Features);
936
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000937 // Setting -msoft-float effectively disables NEON because of the GCC
938 // implementation, although the same isn't true of VFP or VFP3.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000939 if (ABI == arm::FloatABI::Soft) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000940 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000941 // Also need to explicitly disable features which imply NEON.
942 Features.push_back("-crypto");
943 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000944
Eric Christopher269c2a22015-04-04 03:34:43 +0000945 // En/disable crc code generation.
946 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bernard Ogden18b57012013-10-29 09:47:51 +0000947 if (A->getOption().matches(options::OPT_mcrc))
948 Features.push_back("+crc");
949 else
950 Features.push_back("-crc");
951 }
Vladimir Sukharevc6dab752015-05-14 08:25:18 +0000952
Akira Hatanakac2694822015-07-07 08:28:42 +0000953 // Look for the last occurrence of -mlong-calls or -mno-long-calls. If
954 // neither options are specified, see if we are compiling for kernel/kext and
955 // decide whether to pass "+long-calls" based on the OS and its version.
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000956 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
957 options::OPT_mno_long_calls)) {
958 if (A->getOption().matches(options::OPT_mlong_calls))
959 Features.push_back("+long-calls");
Tim Northover756447a2015-10-30 16:30:36 +0000960 } else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
961 !Triple.isWatchOS()) {
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000962 Features.push_back("+long-calls");
963 }
Akira Hatanaka580efb22015-07-16 00:43:00 +0000964
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000965 // Kernel code has more strict alignment requirements.
966 if (KernelOrKext)
967 Features.push_back("+strict-align");
968 else if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
969 options::OPT_munaligned_access)) {
970 if (A->getOption().matches(options::OPT_munaligned_access)) {
971 // No v6M core supports unaligned memory access (v6M ARM ARM A3.2).
972 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
973 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
Bradley Smithf4affc12016-03-03 13:52:22 +0000974 // v8M Baseline follows on from v6M, so doesn't support unaligned memory
975 // access either.
976 else if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8m_baseline)
977 D.Diag(diag::err_target_unsupported_unaligned) << "v8m.base";
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000978 } else
979 Features.push_back("+strict-align");
980 } else {
981 // Assume pre-ARMv6 doesn't support unaligned accesses.
982 //
983 // ARMv6 may or may not support unaligned accesses depending on the
984 // SCTLR.U bit, which is architecture-specific. We assume ARMv6
985 // Darwin and NetBSD targets support unaligned accesses, and others don't.
986 //
987 // ARMv7 always has SCTLR.U set to 1, but it has a new SCTLR.A bit
988 // which raises an alignment fault on unaligned accesses. Linux
989 // defaults this bit to 0 and handles it as a system-wide (not
990 // per-process) setting. It is therefore safe to assume that ARMv7+
991 // Linux targets support unaligned accesses. The same goes for NaCl.
992 //
993 // The above behavior is consistent with GCC.
994 int VersionNum = getARMSubArchVersionNumber(Triple);
995 if (Triple.isOSDarwin() || Triple.isOSNetBSD()) {
Alexandros Lamprineaseda554a2015-10-05 12:45:10 +0000996 if (VersionNum < 6 ||
997 Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000998 Features.push_back("+strict-align");
999 } else if (Triple.isOSLinux() || Triple.isOSNaCl()) {
1000 if (VersionNum < 7)
1001 Features.push_back("+strict-align");
1002 } else
1003 Features.push_back("+strict-align");
1004 }
1005
Akira Hatanaka0a23fac2015-07-21 01:41:08 +00001006 // llvm does not support reserving registers in general. There is support
1007 // for reserving r9 on ARM though (defined as a platform-specific register
1008 // in ARM EABI).
1009 if (Args.hasArg(options::OPT_ffixed_r9))
1010 Features.push_back("+reserve-r9");
1011
Dimitry Andric08107392016-01-06 07:42:18 +00001012 // The kext linker doesn't know how to deal with movw/movt.
1013 if (KernelOrKext || Args.hasArg(options::OPT_mno_movt))
Akira Hatanaka580efb22015-07-16 00:43:00 +00001014 Features.push_back("+no-movt");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001015}
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001016
Saleem Abdulrasoolce63ce92015-09-19 18:19:44 +00001017void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
1018 ArgStringList &CmdArgs, bool KernelOrKext) const {
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001019 // Select the ABI to use.
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001020 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +00001021 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +00001022 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001023 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001024 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +00001025 } else if (Triple.isOSBinFormatMachO()) {
Akira Hatanaka9d99bb52015-08-26 19:00:11 +00001026 if (useAAPCSForMachO(Triple)) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +00001027 ABIName = "aapcs";
Tim Northoverd88ecb32016-01-27 19:32:40 +00001028 } else if (Triple.isWatchABI()) {
Tim Northover756447a2015-10-30 16:30:36 +00001029 ABIName = "aapcs16";
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +00001030 } else {
1031 ABIName = "apcs-gnu";
1032 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00001033 } else if (Triple.isOSWindows()) {
1034 // FIXME: this is invalid for WindowsCE
1035 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001036 } else {
1037 // Select the default based on the platform.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001038 switch (Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +00001039 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001040 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +00001041 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001042 ABIName = "aapcs-linux";
1043 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +00001044 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001045 case llvm::Triple::EABI:
1046 ABIName = "aapcs";
1047 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +00001048 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +00001049 if (Triple.getOS() == llvm::Triple::NetBSD)
1050 ABIName = "apcs-gnu";
1051 else
1052 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +00001053 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001054 }
1055 }
1056 CmdArgs.push_back("-target-abi");
1057 CmdArgs.push_back(ABIName);
1058
Anton Korobeynikova29e4622012-04-09 13:38:30 +00001059 // Determine floating point ABI from the options & target defaults.
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00001060 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00001061 if (ABI == arm::FloatABI::Soft) {
Daniel Dunbar78485922009-09-10 23:00:09 +00001062 // Floating point operations and argument passing are soft.
Daniel Dunbar78485922009-09-10 23:00:09 +00001063 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +00001064 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +00001065 CmdArgs.push_back("-mfloat-abi");
1066 CmdArgs.push_back("soft");
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00001067 } else if (ABI == arm::FloatABI::SoftFP) {
Daniel Dunbar78485922009-09-10 23:00:09 +00001068 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +00001069 CmdArgs.push_back("-mfloat-abi");
1070 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +00001071 } else {
1072 // Floating point operations and argument passing are hard.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00001073 assert(ABI == arm::FloatABI::Hard && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +00001074 CmdArgs.push_back("-mfloat-abi");
1075 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +00001076 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00001077
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001078 // Forward the -mglobal-merge option for explicit control over the pass.
Chad Rosierba3df1d2011-08-26 00:26:29 +00001079 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1080 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001081 CmdArgs.push_back("-backend-option");
Chad Rosierba3df1d2011-08-26 00:26:29 +00001082 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001083 CmdArgs.push_back("-arm-global-merge=false");
1084 else
1085 CmdArgs.push_back("-arm-global-merge=true");
Chad Rosierba3df1d2011-08-26 00:26:29 +00001086 }
Chad Rosierf1985d22012-05-16 20:40:09 +00001087
Bob Wilson9c8af452013-04-11 18:53:25 +00001088 if (!Args.hasFlag(options::OPT_mimplicit_float,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001089 options::OPT_mno_implicit_float, true))
Chad Rosierf1985d22012-05-16 20:40:09 +00001090 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00001091}
Renato Goline17c5802015-07-27 23:44:42 +00001092// ARM tools end.
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00001093
Tim Northover573cbee2014-05-24 12:52:07 +00001094/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
1095/// targeting.
1096static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +00001097 Arg *A;
1098 std::string CPU;
1099 // If we have -mtune or -mcpu, use that.
1100 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00001101 CPU = StringRef(A->getValue()).lower();
Kevin Qin110db6f2014-07-18 07:03:22 +00001102 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
Renato Golin4045f662015-05-08 15:44:36 +00001103 StringRef Mcpu = A->getValue();
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00001104 CPU = Mcpu.split("+").first.lower();
Tim Northovera2ee4332014-03-29 15:09:45 +00001105 }
1106
Kevin Qin110db6f2014-07-18 07:03:22 +00001107 // Handle CPU name is 'native'.
1108 if (CPU == "native")
1109 return llvm::sys::getHostCPUName();
1110 else if (CPU.size())
1111 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +00001112
James Molloy9b1586b2014-04-17 12:51:17 +00001113 // Make sure we pick "cyclone" if -arch is used.
1114 // FIXME: Should this be picked by checking the target triple instead?
1115 if (Args.getLastArg(options::OPT_arch))
1116 return "cyclone";
1117
1118 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +00001119}
1120
Tim Northover573cbee2014-05-24 12:52:07 +00001121void Clang::AddAArch64TargetArgs(const ArgList &Args,
1122 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +00001123 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1124 llvm::Triple Triple(TripleStr);
1125
1126 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1127 Args.hasArg(options::OPT_mkernel) ||
1128 Args.hasArg(options::OPT_fapple_kext))
1129 CmdArgs.push_back("-disable-red-zone");
1130
1131 if (!Args.hasFlag(options::OPT_mimplicit_float,
1132 options::OPT_mno_implicit_float, true))
1133 CmdArgs.push_back("-no-implicit-float");
1134
Craig Topper92fc2df2014-05-17 16:56:41 +00001135 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +00001136 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1137 ABIName = A->getValue();
1138 else if (Triple.isOSDarwin())
1139 ABIName = "darwinpcs";
1140 else
1141 ABIName = "aapcs";
1142
1143 CmdArgs.push_back("-target-abi");
1144 CmdArgs.push_back(ABIName);
1145
Bradley Smith9ff64332014-10-13 10:16:06 +00001146 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1147 options::OPT_mno_fix_cortex_a53_835769)) {
1148 CmdArgs.push_back("-backend-option");
1149 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1150 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
1151 else
1152 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001153 } else if (Triple.isAndroid()) {
Bradley Smith04ee8aa2014-10-16 16:35:14 +00001154 // Enabled A53 errata (835769) workaround by default on android
1155 CmdArgs.push_back("-backend-option");
1156 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +00001157 }
1158
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001159 // Forward the -mglobal-merge option for explicit control over the pass.
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001160 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1161 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001162 CmdArgs.push_back("-backend-option");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001163 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001164 CmdArgs.push_back("-aarch64-global-merge=false");
1165 else
1166 CmdArgs.push_back("-aarch64-global-merge=true");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001167 }
Tim Northovera2ee4332014-03-29 15:09:45 +00001168}
1169
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001170// Get CPU and ABI names. They are not independent
1171// so we have to calculate them together.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001172void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple,
1173 StringRef &CPUName, StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00001174 const char *DefMips32CPU = "mips32r2";
1175 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +00001176
Daniel Sanders2bf13662014-07-10 14:40:57 +00001177 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
1178 // default for mips64(el)?-img-linux-gnu.
1179 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1180 Triple.getEnvironment() == llvm::Triple::GNU) {
1181 DefMips32CPU = "mips32r6";
1182 DefMips64CPU = "mips64r6";
1183 }
Renato Golin7c542b42015-07-27 23:44:45 +00001184
Petar Jovanovic9fe32cd2015-07-17 12:57:30 +00001185 // MIPS64r6 is the default for Android MIPS64 (mips64el-linux-android).
Petar Jovanovic009494f2016-05-17 10:46:10 +00001186 if (Triple.isAndroid()) {
1187 DefMips32CPU = "mips32";
Petar Jovanovic9fe32cd2015-07-17 12:57:30 +00001188 DefMips64CPU = "mips64r6";
Petar Jovanovic009494f2016-05-17 10:46:10 +00001189 }
Daniel Sanders2bf13662014-07-10 14:40:57 +00001190
Brad Smithba26f582015-01-06 02:53:17 +00001191 // MIPS3 is the default for mips64*-unknown-openbsd.
1192 if (Triple.getOS() == llvm::Triple::OpenBSD)
1193 DefMips64CPU = "mips3";
1194
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001195 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
Simon Atanasyane0cc7c72013-10-09 12:12:24 +00001196 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001197
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001198 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001199 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001200 // Convert a GNU style Mips ABI name to the name
1201 // accepted by LLVM Mips backend.
1202 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001203 .Case("32", "o32")
1204 .Case("64", "n64")
1205 .Default(ABIName);
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001206 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001207
1208 // Setup default CPU and ABI names.
1209 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001210 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001211 default:
1212 llvm_unreachable("Unexpected triple arch name");
1213 case llvm::Triple::mips:
1214 case llvm::Triple::mipsel:
1215 CPUName = DefMips32CPU;
1216 break;
1217 case llvm::Triple::mips64:
1218 case llvm::Triple::mips64el:
1219 CPUName = DefMips64CPU;
1220 break;
1221 }
1222 }
1223
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001224 if (ABIName.empty()) {
1225 // Deduce ABI name from the target triple.
1226 if (Triple.getArch() == llvm::Triple::mips ||
1227 Triple.getArch() == llvm::Triple::mipsel)
1228 ABIName = "o32";
1229 else
1230 ABIName = "n64";
1231 }
1232
1233 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001234 // Deduce CPU name from ABI name.
1235 CPUName = llvm::StringSwitch<const char *>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001236 .Cases("o32", "eabi", DefMips32CPU)
1237 .Cases("n32", "n64", DefMips64CPU)
1238 .Default("");
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001239 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001240
1241 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001242}
1243
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00001244std::string mips::getMipsABILibSuffix(const ArgList &Args,
1245 const llvm::Triple &Triple) {
1246 StringRef CPUName, ABIName;
1247 tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1248 return llvm::StringSwitch<std::string>(ABIName)
1249 .Case("o32", "")
1250 .Case("n32", "32")
1251 .Case("n64", "64");
1252}
1253
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001254// Convert ABI name to the GNU tools acceptable variant.
1255static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1256 return llvm::StringSwitch<llvm::StringRef>(ABI)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001257 .Case("o32", "32")
1258 .Case("n64", "64")
1259 .Default(ABI);
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001260}
1261
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001262// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1263// and -mfloat-abi=.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001264static mips::FloatABI getMipsFloatABI(const Driver &D, const ArgList &Args) {
1265 mips::FloatABI ABI = mips::FloatABI::Invalid;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001266 if (Arg *A =
1267 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1268 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001269 if (A->getOption().matches(options::OPT_msoft_float))
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001270 ABI = mips::FloatABI::Soft;
Eric Christopher0b26a612010-03-02 02:41:08 +00001271 else if (A->getOption().matches(options::OPT_mhard_float))
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001272 ABI = mips::FloatABI::Hard;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001273 else {
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001274 ABI = llvm::StringSwitch<mips::FloatABI>(A->getValue())
1275 .Case("soft", mips::FloatABI::Soft)
1276 .Case("hard", mips::FloatABI::Hard)
1277 .Default(mips::FloatABI::Invalid);
1278 if (ABI == mips::FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001279 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001280 ABI = mips::FloatABI::Hard;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001281 }
1282 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001283 }
1284
1285 // If unspecified, choose the default based on the platform.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001286 if (ABI == mips::FloatABI::Invalid) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001287 // Assume "hard", because it's a default value used by gcc.
1288 // When we start to recognize specific target MIPS processors,
1289 // we will be able to select the default more correctly.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001290 ABI = mips::FloatABI::Hard;
Eric Christopher0b26a612010-03-02 02:41:08 +00001291 }
1292
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001293 assert(ABI != mips::FloatABI::Invalid && "must select an ABI");
1294 return ABI;
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001295}
1296
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001297static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001298 std::vector<const char *> &Features,
1299 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001300 StringRef FeatureName) {
1301 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001302 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001303 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001304 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001305 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001306 }
1307}
1308
Daniel Sanders379d44b2014-07-16 11:52:23 +00001309static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1310 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001311 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001312 StringRef CPUName;
1313 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001314 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001315 ABIName = getGnuCompatibleMipsABIName(ABIName);
1316
Daniel Sandersfeb61302014-08-08 15:47:17 +00001317 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1318 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001319
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001320 mips::FloatABI FloatABI = getMipsFloatABI(D, Args);
1321 if (FloatABI == mips::FloatABI::Soft) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001322 // FIXME: Note, this is a hack. We need to pass the selected float
1323 // mode to the MipsTargetInfoBase to define appropriate macros there.
1324 // Now it is the only method.
1325 Features.push_back("+soft-float");
1326 }
1327
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001328 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001329 StringRef Val = StringRef(A->getValue());
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00001330 if (Val == "2008") {
1331 if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1332 Features.push_back("+nan2008");
1333 else {
1334 Features.push_back("-nan2008");
1335 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1336 }
1337 } else if (Val == "legacy") {
1338 if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1339 Features.push_back("-nan2008");
1340 else {
1341 Features.push_back("+nan2008");
1342 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1343 }
1344 } else
Matheus Almeida602bff32014-05-07 16:16:07 +00001345 D.Diag(diag::err_drv_unsupported_option_argument)
1346 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001347 }
1348
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001349 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1350 options::OPT_mdouble_float, "single-float");
1351 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1352 "mips16");
1353 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1354 options::OPT_mno_micromips, "micromips");
1355 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1356 "dsp");
1357 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1358 "dspr2");
1359 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1360 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001361
Petar Jovanovic3ca16222016-05-18 12:46:06 +00001362 // Add the last -mfp32/-mfpxx/-mfp64, if none are given and the ABI is O32
1363 // pass -mfpxx, or if none are given and fp64a is default, pass fp64 and
1364 // nooddspreg.
Daniel Sanders379d44b2014-07-16 11:52:23 +00001365 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1366 options::OPT_mfp64)) {
1367 if (A->getOption().matches(options::OPT_mfp32))
1368 Features.push_back(Args.MakeArgString("-fp64"));
1369 else if (A->getOption().matches(options::OPT_mfpxx)) {
1370 Features.push_back(Args.MakeArgString("+fpxx"));
1371 Features.push_back(Args.MakeArgString("+nooddspreg"));
1372 } else
1373 Features.push_back(Args.MakeArgString("+fp64"));
Toma Tabacu94ea6862015-06-16 13:54:13 +00001374 } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001375 Features.push_back(Args.MakeArgString("+fpxx"));
1376 Features.push_back(Args.MakeArgString("+nooddspreg"));
Petar Jovanovic3ca16222016-05-18 12:46:06 +00001377 } else if (mips::isFP64ADefault(Triple, CPUName)) {
1378 Features.push_back(Args.MakeArgString("+fp64"));
1379 Features.push_back(Args.MakeArgString("+nooddspreg"));
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001380 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001381
Daniel Sanders28e5d392014-07-10 10:39:51 +00001382 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1383 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001384}
1385
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001386void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001387 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001388 const Driver &D = getToolChain().getDriver();
1389 StringRef CPUName;
1390 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001391 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001392 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001393
1394 CmdArgs.push_back("-target-abi");
1395 CmdArgs.push_back(ABIName.data());
1396
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001397 mips::FloatABI ABI = getMipsFloatABI(D, Args);
1398 if (ABI == mips::FloatABI::Soft) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001399 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001400 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001401 CmdArgs.push_back("-mfloat-abi");
1402 CmdArgs.push_back("soft");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001403 } else {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001404 // Floating point operations and argument passing are hard.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001405 assert(ABI == mips::FloatABI::Hard && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001406 CmdArgs.push_back("-mfloat-abi");
1407 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001408 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001409
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001410 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1411 if (A->getOption().matches(options::OPT_mxgot)) {
1412 CmdArgs.push_back("-mllvm");
1413 CmdArgs.push_back("-mxgot");
1414 }
1415 }
1416
Simon Atanasyanc580b322013-05-11 06:33:44 +00001417 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1418 options::OPT_mno_ldc1_sdc1)) {
1419 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1420 CmdArgs.push_back("-mllvm");
1421 CmdArgs.push_back("-mno-ldc1-sdc1");
1422 }
1423 }
1424
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001425 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1426 options::OPT_mno_check_zero_division)) {
1427 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1428 CmdArgs.push_back("-mllvm");
1429 CmdArgs.push_back("-mno-check-zero-division");
1430 }
1431 }
1432
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001433 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001434 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001435 CmdArgs.push_back("-mllvm");
1436 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1437 A->claim();
1438 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001439}
1440
Hal Finkel8eb59282012-06-11 22:35:19 +00001441/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1442static std::string getPPCTargetCPU(const ArgList &Args) {
1443 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001444 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001445
1446 if (CPUName == "native") {
1447 std::string CPU = llvm::sys::getHostCPUName();
1448 if (!CPU.empty() && CPU != "generic")
1449 return CPU;
1450 else
1451 return "";
1452 }
1453
1454 return llvm::StringSwitch<const char *>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001455 .Case("common", "generic")
1456 .Case("440", "440")
1457 .Case("440fp", "440")
1458 .Case("450", "450")
1459 .Case("601", "601")
1460 .Case("602", "602")
1461 .Case("603", "603")
1462 .Case("603e", "603e")
1463 .Case("603ev", "603ev")
1464 .Case("604", "604")
1465 .Case("604e", "604e")
1466 .Case("620", "620")
1467 .Case("630", "pwr3")
1468 .Case("G3", "g3")
1469 .Case("7400", "7400")
1470 .Case("G4", "g4")
1471 .Case("7450", "7450")
1472 .Case("G4+", "g4+")
1473 .Case("750", "750")
1474 .Case("970", "970")
1475 .Case("G5", "g5")
1476 .Case("a2", "a2")
1477 .Case("a2q", "a2q")
1478 .Case("e500mc", "e500mc")
1479 .Case("e5500", "e5500")
1480 .Case("power3", "pwr3")
1481 .Case("power4", "pwr4")
1482 .Case("power5", "pwr5")
1483 .Case("power5x", "pwr5x")
1484 .Case("power6", "pwr6")
1485 .Case("power6x", "pwr6x")
1486 .Case("power7", "pwr7")
1487 .Case("power8", "pwr8")
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001488 .Case("power9", "pwr9")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001489 .Case("pwr3", "pwr3")
1490 .Case("pwr4", "pwr4")
1491 .Case("pwr5", "pwr5")
1492 .Case("pwr5x", "pwr5x")
1493 .Case("pwr6", "pwr6")
1494 .Case("pwr6x", "pwr6x")
1495 .Case("pwr7", "pwr7")
1496 .Case("pwr8", "pwr8")
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001497 .Case("pwr9", "pwr9")
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001498 .Case("powerpc", "ppc")
1499 .Case("powerpc64", "ppc64")
1500 .Case("powerpc64le", "ppc64le")
1501 .Default("");
Hal Finkel8eb59282012-06-11 22:35:19 +00001502 }
1503
1504 return "";
1505}
1506
Petar Jovanovic88a328f2015-12-14 17:51:50 +00001507static void getPPCTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1508 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001509 std::vector<const char *> &Features) {
Eric Christopher49062a52015-12-22 03:12:34 +00001510 handleTargetFeaturesGroup(Args, Features, options::OPT_m_ppc_Features_Group);
Eric Christopher643bb6a2013-10-16 20:40:08 +00001511
Petar Jovanovic88a328f2015-12-14 17:51:50 +00001512 ppc::FloatABI FloatABI = ppc::getPPCFloatABI(D, Args);
1513 if (FloatABI == ppc::FloatABI::Soft &&
1514 !(Triple.getArch() == llvm::Triple::ppc64 ||
1515 Triple.getArch() == llvm::Triple::ppc64le))
1516 Features.push_back("+soft-float");
1517 else if (FloatABI == ppc::FloatABI::Soft &&
1518 (Triple.getArch() == llvm::Triple::ppc64 ||
1519 Triple.getArch() == llvm::Triple::ppc64le))
Eric Christopherbce27882015-12-28 21:57:05 +00001520 D.Diag(diag::err_drv_invalid_mfloat_abi)
Petar Jovanovic88a328f2015-12-14 17:51:50 +00001521 << "soft float is not supported for ppc64";
1522
Eric Christopher643bb6a2013-10-16 20:40:08 +00001523 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001524 AddTargetFeature(Args, Features, options::OPT_faltivec,
1525 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001526}
1527
Petar Jovanovic88a328f2015-12-14 17:51:50 +00001528ppc::FloatABI ppc::getPPCFloatABI(const Driver &D, const ArgList &Args) {
1529 ppc::FloatABI ABI = ppc::FloatABI::Invalid;
1530 if (Arg *A =
1531 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1532 options::OPT_mfloat_abi_EQ)) {
1533 if (A->getOption().matches(options::OPT_msoft_float))
1534 ABI = ppc::FloatABI::Soft;
1535 else if (A->getOption().matches(options::OPT_mhard_float))
1536 ABI = ppc::FloatABI::Hard;
1537 else {
1538 ABI = llvm::StringSwitch<ppc::FloatABI>(A->getValue())
1539 .Case("soft", ppc::FloatABI::Soft)
1540 .Case("hard", ppc::FloatABI::Hard)
1541 .Default(ppc::FloatABI::Invalid);
1542 if (ABI == ppc::FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
1543 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1544 ABI = ppc::FloatABI::Hard;
1545 }
1546 }
1547 }
1548
1549 // If unspecified, choose the default based on the platform.
1550 if (ABI == ppc::FloatABI::Invalid) {
1551 ABI = ppc::FloatABI::Hard;
1552 }
1553
1554 return ABI;
1555}
1556
Ulrich Weigand8afad612014-07-28 13:17:52 +00001557void Clang::AddPPCTargetArgs(const ArgList &Args,
1558 ArgStringList &CmdArgs) const {
1559 // Select the ABI to use.
1560 const char *ABIName = nullptr;
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001561 if (getToolChain().getTriple().isOSLinux())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001562 switch (getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001563 case llvm::Triple::ppc64: {
1564 // When targeting a processor that supports QPX, or if QPX is
1565 // specifically enabled, default to using the ABI that supports QPX (so
1566 // long as it is not specifically disabled).
1567 bool HasQPX = false;
1568 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1569 HasQPX = A->getValue() == StringRef("a2q");
1570 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1571 if (HasQPX) {
1572 ABIName = "elfv1-qpx";
1573 break;
1574 }
1575
Ulrich Weigand8afad612014-07-28 13:17:52 +00001576 ABIName = "elfv1";
1577 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001578 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001579 case llvm::Triple::ppc64le:
1580 ABIName = "elfv2";
1581 break;
1582 default:
1583 break;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001584 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001585
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001586 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1587 // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
1588 // the option if given as we don't have backend support for any targets
1589 // that don't use the altivec abi.
1590 if (StringRef(A->getValue()) != "altivec")
1591 ABIName = A->getValue();
1592
Petar Jovanovic88a328f2015-12-14 17:51:50 +00001593 ppc::FloatABI FloatABI =
1594 ppc::getPPCFloatABI(getToolChain().getDriver(), Args);
1595
1596 if (FloatABI == ppc::FloatABI::Soft) {
1597 // Floating point operations and argument passing are soft.
1598 CmdArgs.push_back("-msoft-float");
1599 CmdArgs.push_back("-mfloat-abi");
1600 CmdArgs.push_back("soft");
1601 } else {
1602 // Floating point operations and argument passing are hard.
1603 assert(FloatABI == ppc::FloatABI::Hard && "Invalid float abi!");
1604 CmdArgs.push_back("-mfloat-abi");
1605 CmdArgs.push_back("hard");
1606 }
1607
Ulrich Weigand8afad612014-07-28 13:17:52 +00001608 if (ABIName) {
1609 CmdArgs.push_back("-target-abi");
1610 CmdArgs.push_back(ABIName);
1611 }
1612}
1613
1614bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1615 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1616 return A && (A->getValue() == StringRef(Value));
1617}
1618
Tom Stellard6674c702013-04-01 20:56:53 +00001619/// Get the (LLVM) name of the R600 gpu we are targeting.
1620static std::string getR600TargetGPU(const ArgList &Args) {
1621 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001622 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001623 return llvm::StringSwitch<const char *>(GPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001624 .Cases("rv630", "rv635", "r600")
1625 .Cases("rv610", "rv620", "rs780", "rs880")
1626 .Case("rv740", "rv770")
1627 .Case("palm", "cedar")
1628 .Cases("sumo", "sumo2", "sumo")
1629 .Case("hemlock", "cypress")
1630 .Case("aruba", "cayman")
1631 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001632 }
1633 return "";
1634}
1635
Jacques Pienaard964cc22016-03-28 21:02:54 +00001636static std::string getLanaiTargetCPU(const ArgList &Args) {
1637 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1638 return A->getValue();
1639 }
1640 return "";
1641}
1642
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001643void Clang::AddSparcTargetArgs(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001644 ArgStringList &CmdArgs) const {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001645 const Driver &D = getToolChain().getDriver();
James Y Knightb2406522015-06-15 20:51:24 +00001646 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001647
James Y Knightb2406522015-06-15 20:51:24 +00001648 bool SoftFloatABI = false;
1649 if (Arg *A =
1650 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001651 if (A->getOption().matches(options::OPT_msoft_float))
James Y Knightb2406522015-06-15 20:51:24 +00001652 SoftFloatABI = true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001653 }
1654
James Y Knightb2406522015-06-15 20:51:24 +00001655 // Only the hard-float ABI on Sparc is standardized, and it is the
1656 // default. GCC also supports a nonstandard soft-float ABI mode, and
1657 // perhaps LLVM should implement that, too. However, since llvm
1658 // currently does not support Sparc soft-float, at all, display an
1659 // error if it's requested.
1660 if (SoftFloatABI) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001661 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-msoft-float"
1662 << Triple;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001663 }
1664}
1665
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +00001666void Clang::AddSystemZTargetArgs(const ArgList &Args,
1667 ArgStringList &CmdArgs) const {
1668 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false))
1669 CmdArgs.push_back("-mbackchain");
1670}
1671
Richard Sandiford4652d892013-07-19 16:51:51 +00001672static const char *getSystemZTargetCPU(const ArgList &Args) {
1673 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1674 return A->getValue();
1675 return "z10";
1676}
1677
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001678static void getSystemZTargetFeatures(const ArgList &Args,
1679 std::vector<const char *> &Features) {
1680 // -m(no-)htm overrides use of the transactional-execution facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001681 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001682 if (A->getOption().matches(options::OPT_mhtm))
1683 Features.push_back("+transactional-execution");
1684 else
1685 Features.push_back("-transactional-execution");
1686 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001687 // -m(no-)vx overrides use of the vector facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001688 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001689 if (A->getOption().matches(options::OPT_mvx))
1690 Features.push_back("+vector");
1691 else
1692 Features.push_back("-vector");
1693 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001694}
1695
Chandler Carruth953fb082013-01-13 11:46:33 +00001696static const char *getX86TargetCPU(const ArgList &Args,
1697 const llvm::Triple &Triple) {
1698 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001699 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001700 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001701 return "core-avx2";
1702
Chandler Carruth953fb082013-01-13 11:46:33 +00001703 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001704 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001705
1706 // FIXME: Reject attempts to use -march=native unless the target matches
1707 // the host.
1708 //
1709 // FIXME: We should also incorporate the detected target features for use
1710 // with -native.
1711 std::string CPU = llvm::sys::getHostCPUName();
1712 if (!CPU.empty() && CPU != "generic")
1713 return Args.MakeArgString(CPU);
1714 }
1715
Reid Kleckner3123eff2015-06-30 16:32:04 +00001716 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1717 // Mapping built by referring to X86TargetInfo::getDefaultFeatures().
1718 StringRef Arch = A->getValue();
1719 const char *CPU;
1720 if (Triple.getArch() == llvm::Triple::x86) {
1721 CPU = llvm::StringSwitch<const char *>(Arch)
1722 .Case("IA32", "i386")
1723 .Case("SSE", "pentium3")
1724 .Case("SSE2", "pentium4")
1725 .Case("AVX", "sandybridge")
1726 .Case("AVX2", "haswell")
1727 .Default(nullptr);
1728 } else {
1729 CPU = llvm::StringSwitch<const char *>(Arch)
1730 .Case("AVX", "sandybridge")
1731 .Case("AVX2", "haswell")
1732 .Default(nullptr);
1733 }
1734 if (CPU)
1735 return CPU;
1736 }
1737
Chandler Carruth953fb082013-01-13 11:46:33 +00001738 // Select the default CPU if none was given (or detection failed).
1739
1740 if (Triple.getArch() != llvm::Triple::x86_64 &&
1741 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001742 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001743
1744 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1745
1746 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001747 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001748 if (Triple.getArchName() == "x86_64h")
1749 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001750 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001751 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001752
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001753 // Set up default CPU name for PS4 compilers.
1754 if (Triple.isPS4CPU())
1755 return "btver2";
1756
Alexey Bataev286d1b92014-01-31 04:07:13 +00001757 // On Android use targets compatible with gcc
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001758 if (Triple.isAndroid())
Alexey Bataev286d1b92014-01-31 04:07:13 +00001759 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001760
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001761 // Everything else goes to x86-64 in 64-bit mode.
1762 if (Is64Bit)
1763 return "x86-64";
1764
1765 switch (Triple.getOS()) {
1766 case llvm::Triple::FreeBSD:
1767 case llvm::Triple::NetBSD:
1768 case llvm::Triple::OpenBSD:
1769 return "i486";
1770 case llvm::Triple::Haiku:
1771 return "i586";
1772 case llvm::Triple::Bitrig:
1773 return "i686";
1774 default:
1775 // Fallback to p4.
1776 return "pentium4";
1777 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001778}
1779
Dan Gohmanc2853072015-09-03 22:51:53 +00001780/// Get the (LLVM) name of the WebAssembly cpu we are targeting.
1781static StringRef getWebAssemblyTargetCPU(const ArgList &Args) {
1782 // If we have -mcpu=, use that.
1783 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1784 StringRef CPU = A->getValue();
1785
1786#ifdef __wasm__
1787 // Handle "native" by examining the host. "native" isn't meaningful when
1788 // cross compiling, so only support this when the host is also WebAssembly.
1789 if (CPU == "native")
1790 return llvm::sys::getHostCPUName();
1791#endif
1792
1793 return CPU;
1794 }
1795
1796 return "generic";
1797}
1798
Renato Golin7c542b42015-07-27 23:44:45 +00001799static std::string getCPUName(const ArgList &Args, const llvm::Triple &T,
1800 bool FromAs = false) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001801 switch (T.getArch()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001802 default:
1803 return "";
1804
Amara Emerson703da2e2013-10-31 09:32:33 +00001805 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001806 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001807 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001808
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001809 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001810 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001811 case llvm::Triple::thumb:
Renato Goline17c5802015-07-27 23:44:42 +00001812 case llvm::Triple::thumbeb: {
1813 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00001814 getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs);
Renato Goline17c5802015-07-27 23:44:42 +00001815 return arm::getARMTargetCPU(MCPU, MArch, T);
1816 }
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001817 case llvm::Triple::mips:
1818 case llvm::Triple::mipsel:
1819 case llvm::Triple::mips64:
1820 case llvm::Triple::mips64el: {
1821 StringRef CPUName;
1822 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001823 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001824 return CPUName;
1825 }
1826
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001827 case llvm::Triple::nvptx:
1828 case llvm::Triple::nvptx64:
1829 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1830 return A->getValue();
1831 return "";
1832
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001833 case llvm::Triple::ppc:
1834 case llvm::Triple::ppc64:
1835 case llvm::Triple::ppc64le: {
1836 std::string TargetCPUName = getPPCTargetCPU(Args);
1837 // LLVM may default to generating code for the native CPU,
1838 // but, like gcc, we default to a more generic option for
1839 // each architecture. (except on Darwin)
1840 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1841 if (T.getArch() == llvm::Triple::ppc64)
1842 TargetCPUName = "ppc64";
1843 else if (T.getArch() == llvm::Triple::ppc64le)
1844 TargetCPUName = "ppc64le";
1845 else
1846 TargetCPUName = "ppc";
1847 }
1848 return TargetCPUName;
1849 }
1850
1851 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001852 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001853 case llvm::Triple::sparcv9:
1854 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001855 return A->getValue();
1856 return "";
1857
1858 case llvm::Triple::x86:
1859 case llvm::Triple::x86_64:
1860 return getX86TargetCPU(Args, T);
1861
1862 case llvm::Triple::hexagon:
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00001863 return "hexagon" +
1864 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001865
Jacques Pienaard964cc22016-03-28 21:02:54 +00001866 case llvm::Triple::lanai:
1867 return getLanaiTargetCPU(Args);
1868
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001869 case llvm::Triple::systemz:
1870 return getSystemZTargetCPU(Args);
1871
1872 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001873 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001874 return getR600TargetGPU(Args);
Dan Gohmanc2853072015-09-03 22:51:53 +00001875
1876 case llvm::Triple::wasm32:
1877 case llvm::Triple::wasm64:
1878 return getWebAssemblyTargetCPU(Args);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001879 }
1880}
1881
Alp Tokerce365ca2013-12-02 12:43:03 +00001882static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
Teresa Johnson945bc502015-10-15 20:35:53 +00001883 ArgStringList &CmdArgs, bool IsThinLTO) {
Alp Tokerce365ca2013-12-02 12:43:03 +00001884 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1885 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1886 // forward.
1887 CmdArgs.push_back("-plugin");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001888 std::string Plugin =
1889 ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001890 CmdArgs.push_back(Args.MakeArgString(Plugin));
1891
1892 // Try to pass driver level flags relevant to LTO code generation down to
1893 // the plugin.
1894
1895 // Handle flags for selecting CPU variants.
1896 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1897 if (!CPU.empty())
1898 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
Teresa Johnson945bc502015-10-15 20:35:53 +00001899
James Molloyf97fdae2015-12-21 10:44:36 +00001900 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1901 StringRef OOpt;
1902 if (A->getOption().matches(options::OPT_O4) ||
1903 A->getOption().matches(options::OPT_Ofast))
1904 OOpt = "3";
1905 else if (A->getOption().matches(options::OPT_O))
1906 OOpt = A->getValue();
1907 else if (A->getOption().matches(options::OPT_O0))
1908 OOpt = "0";
1909 if (!OOpt.empty())
1910 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=O") + OOpt));
1911 }
1912
Teresa Johnson6ef80dc2015-11-02 18:03:12 +00001913 if (IsThinLTO)
1914 CmdArgs.push_back("-plugin-opt=thinlto");
Paul Robinson4391d092016-01-25 19:46:40 +00001915
1916 // If an explicit debugger tuning argument appeared, pass it along.
1917 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
1918 options::OPT_ggdbN_Group)) {
1919 if (A->getOption().matches(options::OPT_glldb))
1920 CmdArgs.push_back("-plugin-opt=-debugger-tune=lldb");
1921 else if (A->getOption().matches(options::OPT_gsce))
1922 CmdArgs.push_back("-plugin-opt=-debugger-tune=sce");
1923 else
1924 CmdArgs.push_back("-plugin-opt=-debugger-tune=gdb");
1925 }
Alp Tokerce365ca2013-12-02 12:43:03 +00001926}
1927
Sanjay Patel2987c292015-06-11 14:53:41 +00001928/// This is a helper function for validating the optional refinement step
1929/// parameter in reciprocal argument strings. Return false if there is an error
1930/// parsing the refinement step. Otherwise, return true and set the Position
1931/// of the refinement step in the input string.
Craig Topper3db9ba42015-09-21 00:20:04 +00001932static bool getRefinementStep(StringRef In, const Driver &D,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001933 const Arg &A, size_t &Position) {
Sanjay Patel2987c292015-06-11 14:53:41 +00001934 const char RefinementStepToken = ':';
1935 Position = In.find(RefinementStepToken);
1936 if (Position != StringRef::npos) {
1937 StringRef Option = A.getOption().getName();
1938 StringRef RefStep = In.substr(Position + 1);
1939 // Allow exactly one numeric character for the additional refinement
1940 // step parameter. This is reasonable for all currently-supported
1941 // operations and architectures because we would expect that a larger value
1942 // of refinement steps would cause the estimate "optimization" to
1943 // under-perform the native operation. Also, if the estimate does not
1944 // converge quickly, it probably will not ever converge, so further
1945 // refinement steps will not produce a better answer.
1946 if (RefStep.size() != 1) {
1947 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1948 return false;
1949 }
1950 char RefStepChar = RefStep[0];
1951 if (RefStepChar < '0' || RefStepChar > '9') {
1952 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1953 return false;
1954 }
1955 }
1956 return true;
1957}
1958
1959/// The -mrecip flag requires processing of many optional parameters.
1960static void ParseMRecip(const Driver &D, const ArgList &Args,
1961 ArgStringList &OutStrings) {
1962 StringRef DisabledPrefixIn = "!";
1963 StringRef DisabledPrefixOut = "!";
1964 StringRef EnabledPrefixOut = "";
1965 StringRef Out = "-mrecip=";
1966
1967 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1968 if (!A)
1969 return;
1970
1971 unsigned NumOptions = A->getNumValues();
1972 if (NumOptions == 0) {
1973 // No option is the same as "all".
1974 OutStrings.push_back(Args.MakeArgString(Out + "all"));
1975 return;
1976 }
1977
1978 // Pass through "all", "none", or "default" with an optional refinement step.
1979 if (NumOptions == 1) {
1980 StringRef Val = A->getValue(0);
1981 size_t RefStepLoc;
1982 if (!getRefinementStep(Val, D, *A, RefStepLoc))
1983 return;
1984 StringRef ValBase = Val.slice(0, RefStepLoc);
1985 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1986 OutStrings.push_back(Args.MakeArgString(Out + Val));
1987 return;
1988 }
1989 }
1990
1991 // Each reciprocal type may be enabled or disabled individually.
1992 // Check each input value for validity, concatenate them all back together,
1993 // and pass through.
1994
1995 llvm::StringMap<bool> OptionStrings;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001996 OptionStrings.insert(std::make_pair("divd", false));
1997 OptionStrings.insert(std::make_pair("divf", false));
1998 OptionStrings.insert(std::make_pair("vec-divd", false));
1999 OptionStrings.insert(std::make_pair("vec-divf", false));
2000 OptionStrings.insert(std::make_pair("sqrtd", false));
2001 OptionStrings.insert(std::make_pair("sqrtf", false));
2002 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
2003 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
Sanjay Patel2987c292015-06-11 14:53:41 +00002004
2005 for (unsigned i = 0; i != NumOptions; ++i) {
2006 StringRef Val = A->getValue(i);
2007
2008 bool IsDisabled = Val.startswith(DisabledPrefixIn);
2009 // Ignore the disablement token for string matching.
2010 if (IsDisabled)
2011 Val = Val.substr(1);
2012
2013 size_t RefStep;
2014 if (!getRefinementStep(Val, D, *A, RefStep))
2015 return;
2016
2017 StringRef ValBase = Val.slice(0, RefStep);
2018 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
2019 if (OptionIter == OptionStrings.end()) {
2020 // Try again specifying float suffix.
2021 OptionIter = OptionStrings.find(ValBase.str() + 'f');
2022 if (OptionIter == OptionStrings.end()) {
2023 // The input name did not match any known option string.
2024 D.Diag(diag::err_drv_unknown_argument) << Val;
2025 return;
2026 }
2027 // The option was specified without a float or double suffix.
2028 // Make sure that the double entry was not already specified.
2029 // The float entry will be checked below.
2030 if (OptionStrings[ValBase.str() + 'd']) {
2031 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
2032 return;
2033 }
2034 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002035
Sanjay Patel2987c292015-06-11 14:53:41 +00002036 if (OptionIter->second == true) {
2037 // Duplicate option specified.
2038 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
2039 return;
2040 }
2041
2042 // Mark the matched option as found. Do not allow duplicate specifiers.
2043 OptionIter->second = true;
2044
2045 // If the precision was not specified, also mark the double entry as found.
2046 if (ValBase.back() != 'f' && ValBase.back() != 'd')
2047 OptionStrings[ValBase.str() + 'd'] = true;
2048
2049 // Build the output string.
2050 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
2051 Out = Args.MakeArgString(Out + Prefix + Val);
2052 if (i != NumOptions - 1)
2053 Out = Args.MakeArgString(Out + ",");
2054 }
2055
2056 OutStrings.push_back(Args.MakeArgString(Out));
2057}
2058
Eric Christopherc54920a2015-03-23 19:26:05 +00002059static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00002060 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002061 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00002062 // If -march=native, autodetect the feature list.
2063 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
2064 if (StringRef(A->getValue()) == "native") {
2065 llvm::StringMap<bool> HostFeatures;
2066 if (llvm::sys::getHostCPUFeatures(HostFeatures))
2067 for (auto &F : HostFeatures)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002068 Features.push_back(
2069 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
Craig Toppera8bd6002015-03-31 05:45:00 +00002070 }
2071 }
2072
Jim Grosbach82eee262013-11-16 00:53:35 +00002073 if (Triple.getArchName() == "x86_64h") {
2074 // x86_64h implies quite a few of the more modern subtarget features
2075 // for Haswell class CPUs, but not all of them. Opt-out of a few.
2076 Features.push_back("-rdrnd");
2077 Features.push_back("-aes");
2078 Features.push_back("-pclmul");
2079 Features.push_back("-rtm");
2080 Features.push_back("-hle");
2081 Features.push_back("-fsgsbase");
2082 }
2083
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002084 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00002085 // Add features to be compatible with gcc for Android.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00002086 if (Triple.isAndroid()) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002087 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00002088 Features.push_back("+sse4.2");
2089 Features.push_back("+popcnt");
2090 } else
2091 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00002092 }
2093
Eric Christopherc54920a2015-03-23 19:26:05 +00002094 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002095 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
2096 StringRef Arch = A->getValue();
2097 bool ArchUsed = false;
2098 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002099 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002100 if (Arch == "AVX" || Arch == "AVX2") {
2101 ArchUsed = true;
2102 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
2103 }
2104 }
2105 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002106 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002107 if (Arch == "IA32") {
2108 ArchUsed = true;
2109 } else if (Arch == "SSE" || Arch == "SSE2") {
2110 ArchUsed = true;
2111 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
2112 }
2113 }
2114 if (!ArchUsed)
2115 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
2116 }
2117
Jim Grosbach82eee262013-11-16 00:53:35 +00002118 // Now add any that the user explicitly requested on the command line,
2119 // which may override the defaults.
Eric Christopher49062a52015-12-22 03:12:34 +00002120 handleTargetFeaturesGroup(Args, Features, options::OPT_m_x86_Features_Group);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002121}
2122
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002123void Clang::AddX86TargetArgs(const ArgList &Args,
2124 ArgStringList &CmdArgs) const {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002125 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00002126 Args.hasArg(options::OPT_mkernel) ||
2127 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002128 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00002129
Bob Wilson2616e2e2013-02-10 16:01:41 +00002130 // Default to avoid implicit floating-point for kernel/kext code, but allow
2131 // that to be overridden with -mno-soft-float.
2132 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2133 Args.hasArg(options::OPT_fapple_kext));
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002134 if (Arg *A = Args.getLastArg(
2135 options::OPT_msoft_float, options::OPT_mno_soft_float,
2136 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
Bob Wilson2616e2e2013-02-10 16:01:41 +00002137 const Option &O = A->getOption();
2138 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2139 O.matches(options::OPT_msoft_float));
2140 }
2141 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002142 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00002143
2144 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2145 StringRef Value = A->getValue();
2146 if (Value == "intel" || Value == "att") {
2147 CmdArgs.push_back("-mllvm");
2148 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
2149 } else {
2150 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
2151 << A->getOption().getName() << Value;
2152 }
2153 }
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +00002154
2155 // Set flags to support MCU ABI.
2156 if (Args.hasArg(options::OPT_miamcu)) {
2157 CmdArgs.push_back("-mfloat-abi");
2158 CmdArgs.push_back("soft");
2159 CmdArgs.push_back("-mstack-alignment=4");
2160 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002161}
2162
Tony Linthicum76329bf2011-12-12 21:14:55 +00002163void Clang::AddHexagonTargetArgs(const ArgList &Args,
2164 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00002165 CmdArgs.push_back("-mqdsp6-compat");
2166 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00002167
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002168 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
2169 std::string N = llvm::utostr(G.getValue());
2170 std::string Opt = std::string("-hexagon-small-data-threshold=") + N;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002171 CmdArgs.push_back("-mllvm");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002172 CmdArgs.push_back(Args.MakeArgString(Opt));
Tony Linthicum76329bf2011-12-12 21:14:55 +00002173 }
2174
Sirish Pande11ebc4e2012-05-10 20:19:54 +00002175 if (!Args.hasArg(options::OPT_fno_short_enums))
2176 CmdArgs.push_back("-fshort-enums");
2177 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002178 CmdArgs.push_back("-mllvm");
2179 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00002180 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002181 CmdArgs.push_back("-mllvm");
2182 CmdArgs.push_back("-machine-sink-split=0");
Tony Linthicum76329bf2011-12-12 21:14:55 +00002183}
2184
Jacques Pienaard964cc22016-03-28 21:02:54 +00002185void Clang::AddLanaiTargetArgs(const ArgList &Args,
2186 ArgStringList &CmdArgs) const {
2187 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2188 StringRef CPUName = A->getValue();
2189
2190 CmdArgs.push_back("-target-cpu");
2191 CmdArgs.push_back(Args.MakeArgString(CPUName));
2192 }
2193 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2194 StringRef Value = A->getValue();
2195 // Only support mregparm=4 to support old usage. Report error for all other
2196 // cases.
2197 int Mregparm;
2198 if (Value.getAsInteger(10, Mregparm)) {
2199 if (Mregparm != 4) {
2200 getToolChain().getDriver().Diag(
2201 diag::err_drv_unsupported_option_argument)
2202 << A->getOption().getName() << Value;
2203 }
2204 }
2205 }
2206}
2207
Dan Gohmane3d71e12016-01-07 01:00:21 +00002208void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
2209 ArgStringList &CmdArgs) const {
2210 // Default to "hidden" visibility.
2211 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2212 options::OPT_fvisibility_ms_compat)) {
2213 CmdArgs.push_back("-fvisibility");
2214 CmdArgs.push_back("hidden");
2215 }
2216}
2217
Kevin Qin110db6f2014-07-18 07:03:22 +00002218// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00002219static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00002220 std::vector<const char *> &Features) {
2221 SmallVector<StringRef, 8> Split;
2222 text.split(Split, StringRef("+"), -1, false);
2223
Benjamin Kramer72e64312015-09-24 14:48:49 +00002224 for (StringRef Feature : Split) {
Douglas Katzman2675d012015-06-29 19:12:56 +00002225 const char *result = llvm::StringSwitch<const char *>(Feature)
Kevin Qin110db6f2014-07-18 07:03:22 +00002226 .Case("fp", "+fp-armv8")
2227 .Case("simd", "+neon")
2228 .Case("crc", "+crc")
2229 .Case("crypto", "+crypto")
Oliver Stannard76afca72015-11-26 15:36:42 +00002230 .Case("fp16", "+fullfp16")
Oliver Stannard4cc70802015-11-26 15:38:54 +00002231 .Case("profile", "+spe")
Kevin Qin110db6f2014-07-18 07:03:22 +00002232 .Case("nofp", "-fp-armv8")
2233 .Case("nosimd", "-neon")
2234 .Case("nocrc", "-crc")
2235 .Case("nocrypto", "-crypto")
Oliver Stannard76afca72015-11-26 15:36:42 +00002236 .Case("nofp16", "-fullfp16")
Oliver Stannard4cc70802015-11-26 15:38:54 +00002237 .Case("noprofile", "-spe")
Kevin Qin110db6f2014-07-18 07:03:22 +00002238 .Default(nullptr);
2239 if (result)
2240 Features.push_back(result);
Douglas Katzman2675d012015-06-29 19:12:56 +00002241 else if (Feature == "neon" || Feature == "noneon")
Kevin Qin110db6f2014-07-18 07:03:22 +00002242 D.Diag(diag::err_drv_no_neon_modifier);
2243 else
2244 return false;
2245 }
2246 return true;
2247}
2248
2249// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
2250// decode CPU and feature.
2251static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
2252 std::vector<const char *> &Features) {
2253 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
2254 CPU = Split.first;
Tim Northover2279b5f2016-02-24 17:57:48 +00002255 if (CPU == "cortex-a53" || CPU == "cortex-a57" ||
Chad Rosierb0ce1952016-02-11 18:09:31 +00002256 CPU == "cortex-a72" || CPU == "cortex-a35" || CPU == "exynos-m1" ||
2257 CPU == "kryo") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002258 Features.push_back("+neon");
2259 Features.push_back("+crc");
2260 Features.push_back("+crypto");
Tim Northover2279b5f2016-02-24 17:57:48 +00002261 } else if (CPU == "cyclone") {
2262 Features.push_back("+neon");
2263 Features.push_back("+crypto");
Kevin Qin110db6f2014-07-18 07:03:22 +00002264 } else if (CPU == "generic") {
2265 Features.push_back("+neon");
2266 } else {
2267 return false;
2268 }
2269
2270 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
2271 return false;
2272
2273 return true;
2274}
2275
2276static bool
2277getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
2278 const ArgList &Args,
2279 std::vector<const char *> &Features) {
Gabor Ballabas36451492015-06-18 14:23:12 +00002280 std::string MarchLowerCase = March.lower();
2281 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002282
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002283 if (Split.first == "armv8-a" || Split.first == "armv8a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002284 // ok, no additional features.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002285 } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002286 Features.push_back("+v8.1a");
Oliver Stannard76afca72015-11-26 15:36:42 +00002287 } else if (Split.first == "armv8.2-a" || Split.first == "armv8.2a" ) {
2288 Features.push_back("+v8.2a");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002289 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00002290 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002291 }
Kevin Qin110db6f2014-07-18 07:03:22 +00002292
2293 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
2294 return false;
2295
2296 return true;
2297}
2298
2299static bool
2300getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2301 const ArgList &Args,
2302 std::vector<const char *> &Features) {
2303 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002304 std::string McpuLowerCase = Mcpu.lower();
2305 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00002306 return false;
2307
2308 return true;
2309}
2310
2311static bool
2312getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
2313 const ArgList &Args,
2314 std::vector<const char *> &Features) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002315 std::string MtuneLowerCase = Mtune.lower();
Kevin Qin110db6f2014-07-18 07:03:22 +00002316 // Handle CPU name is 'native'.
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002317 if (MtuneLowerCase == "native")
2318 MtuneLowerCase = llvm::sys::getHostCPUName();
2319 if (MtuneLowerCase == "cyclone") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002320 Features.push_back("+zcm");
2321 Features.push_back("+zcz");
2322 }
2323 return true;
2324}
2325
2326static bool
2327getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2328 const ArgList &Args,
2329 std::vector<const char *> &Features) {
2330 StringRef CPU;
2331 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002332 std::string McpuLowerCase = Mcpu.lower();
2333 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00002334 return false;
2335
2336 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
2337}
2338
Justin Bognerf9052562015-11-13 23:07:31 +00002339static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002340 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00002341 Arg *A;
2342 bool success = true;
2343 // Enable NEON by default.
2344 Features.push_back("+neon");
2345 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2346 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
2347 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2348 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002349 else if (Args.hasArg(options::OPT_arch))
2350 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
2351 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002352
2353 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2354 success =
2355 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
2356 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2357 success =
2358 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002359 else if (Args.hasArg(options::OPT_arch))
2360 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
2361 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002362
2363 if (!success)
2364 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00002365
2366 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2367 Features.push_back("-fp-armv8");
2368 Features.push_back("-crypto");
2369 Features.push_back("-neon");
2370 }
Bradley Smith418c5932014-05-02 15:17:51 +00002371
2372 // En/disable crc
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002373 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bradley Smith418c5932014-05-02 15:17:51 +00002374 if (A->getOption().matches(options::OPT_mcrc))
2375 Features.push_back("+crc");
2376 else
2377 Features.push_back("-crc");
2378 }
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002379
Akira Hatanaka085da7e2015-07-29 14:25:58 +00002380 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2381 options::OPT_munaligned_access))
2382 if (A->getOption().matches(options::OPT_mno_unaligned_access))
2383 Features.push_back("+strict-align");
2384
Justin Bognerf9052562015-11-13 23:07:31 +00002385 if (Args.hasArg(options::OPT_ffixed_x18))
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002386 Features.push_back("+reserve-x18");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002387}
2388
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002389static void getHexagonTargetFeatures(const ArgList &Args,
2390 std::vector<const char *> &Features) {
2391 bool HasHVX = false, HasHVXD = false;
2392
Eric Christopher49062a52015-12-22 03:12:34 +00002393 // FIXME: This should be able to use handleTargetFeaturesGroup except it is
2394 // doing dependent option handling here rather than in initFeatureMap or a
2395 // similar handler.
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002396 for (auto &A : Args) {
2397 auto &Opt = A->getOption();
2398 if (Opt.matches(options::OPT_mhexagon_hvx))
2399 HasHVX = true;
2400 else if (Opt.matches(options::OPT_mno_hexagon_hvx))
2401 HasHVXD = HasHVX = false;
2402 else if (Opt.matches(options::OPT_mhexagon_hvx_double))
2403 HasHVXD = HasHVX = true;
2404 else if (Opt.matches(options::OPT_mno_hexagon_hvx_double))
2405 HasHVXD = false;
2406 else
2407 continue;
2408 A->claim();
2409 }
2410
2411 Features.push_back(HasHVX ? "+hvx" : "-hvx");
2412 Features.push_back(HasHVXD ? "+hvx-double" : "-hvx-double");
2413}
2414
Dan Gohmanc2853072015-09-03 22:51:53 +00002415static void getWebAssemblyTargetFeatures(const ArgList &Args,
2416 std::vector<const char *> &Features) {
Eric Christopher49062a52015-12-22 03:12:34 +00002417 handleTargetFeaturesGroup(Args, Features, options::OPT_m_wasm_Features_Group);
Dan Gohmanc2853072015-09-03 22:51:53 +00002418}
2419
Konstantin Zhuravlyov5124bf82016-04-12 21:42:15 +00002420static void getAMDGPUTargetFeatures(const Driver &D, const ArgList &Args,
2421 std::vector<const char *> &Features) {
2422 if (const Arg *dAbi = Args.getLastArg(options::OPT_mamdgpu_debugger_abi)) {
2423 StringRef value = dAbi->getValue();
2424 if (value == "1.0") {
2425 Features.push_back("+amdgpu-debugger-insert-nops");
2426 Features.push_back("+amdgpu-debugger-reserve-trap-regs");
2427 } else {
2428 D.Diag(diag::err_drv_clang_unsupported) << dAbi->getAsString(Args);
2429 }
2430 }
2431
2432 handleTargetFeaturesGroup(
2433 Args, Features, options::OPT_m_amdgpu_Features_Group);
2434}
2435
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002436static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002437 const ArgList &Args, ArgStringList &CmdArgs,
2438 bool ForAS) {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002439 const Driver &D = TC.getDriver();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002440 std::vector<const char *> Features;
2441 switch (Triple.getArch()) {
2442 default:
2443 break;
2444 case llvm::Triple::mips:
2445 case llvm::Triple::mipsel:
2446 case llvm::Triple::mips64:
2447 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00002448 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002449 break;
2450
2451 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002452 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002453 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002454 case llvm::Triple::thumbeb:
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002455 getARMTargetFeatures(TC, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002456 break;
2457
2458 case llvm::Triple::ppc:
2459 case llvm::Triple::ppc64:
2460 case llvm::Triple::ppc64le:
Petar Jovanovic88a328f2015-12-14 17:51:50 +00002461 getPPCTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002462 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00002463 case llvm::Triple::systemz:
2464 getSystemZTargetFeatures(Args, Features);
2465 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002466 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00002467 case llvm::Triple::aarch64_be:
Justin Bognerf9052562015-11-13 23:07:31 +00002468 getAArch64TargetFeatures(D, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002469 break;
2470 case llvm::Triple::x86:
2471 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002472 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002473 break;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002474 case llvm::Triple::hexagon:
2475 getHexagonTargetFeatures(Args, Features);
2476 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00002477 case llvm::Triple::wasm32:
2478 case llvm::Triple::wasm64:
2479 getWebAssemblyTargetFeatures(Args, Features);
2480 break;
Konstantin Zhuravlyov5124bf82016-04-12 21:42:15 +00002481 case llvm::Triple::r600:
2482 case llvm::Triple::amdgcn:
2483 getAMDGPUTargetFeatures(D, Args, Features);
2484 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002485 }
Rafael Espindola43964802013-08-21 17:34:32 +00002486
2487 // Find the last of each feature.
2488 llvm::StringMap<unsigned> LastOpt;
2489 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2490 const char *Name = Features[I];
2491 assert(Name[0] == '-' || Name[0] == '+');
2492 LastOpt[Name + 1] = I;
2493 }
2494
2495 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2496 // If this feature was overridden, ignore it.
2497 const char *Name = Features[I];
2498 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2499 assert(LastI != LastOpt.end());
2500 unsigned Last = LastI->second;
2501 if (Last != I)
2502 continue;
2503
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002504 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002505 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002506 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002507}
2508
David Majnemerae394812014-12-09 00:12:30 +00002509static bool
2510shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2511 const llvm::Triple &Triple) {
2512 // We use the zero-cost exception tables for Objective-C if the non-fragile
2513 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2514 // later.
2515 if (runtime.isNonFragile())
2516 return true;
2517
2518 if (!Triple.isMacOSX())
2519 return false;
2520
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002521 return (!Triple.isMacOSXVersionLT(10, 5) &&
David Majnemerae394812014-12-09 00:12:30 +00002522 (Triple.getArch() == llvm::Triple::x86_64 ||
2523 Triple.getArch() == llvm::Triple::arm));
2524}
2525
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002526/// Adds exception related arguments to the driver command arguments. There's a
2527/// master flag, -fexceptions and also language specific flags to enable/disable
2528/// C++ and Objective-C exceptions. This makes it possible to for example
2529/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002530static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002531 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002532 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002533 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002534 const Driver &D = TC.getDriver();
2535 const llvm::Triple &Triple = TC.getTriple();
2536
Chad Rosier4fab82c2012-03-26 22:04:46 +00002537 if (KernelOrKext) {
2538 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2539 // arguments now to avoid warnings about unused arguments.
2540 Args.ClaimAllArgs(options::OPT_fexceptions);
2541 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2542 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2543 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2544 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2545 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002546 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002547 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002548
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002549 // See if the user explicitly enabled exceptions.
2550 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2551 false);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002552
David Majnemerae394812014-12-09 00:12:30 +00002553 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2554 // is not necessarily sensible, but follows GCC.
2555 if (types::isObjC(InputType) &&
2556 Args.hasFlag(options::OPT_fobjc_exceptions,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002557 options::OPT_fno_objc_exceptions, true)) {
David Majnemerae394812014-12-09 00:12:30 +00002558 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002559
David Majnemerae394812014-12-09 00:12:30 +00002560 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002561 }
2562
2563 if (types::isCXX(InputType)) {
David Majnemer59729392016-02-18 08:15:05 +00002564 // Disable C++ EH by default on XCore and PS4.
2565 bool CXXExceptionsEnabled =
2566 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002567 Arg *ExceptionArg = Args.getLastArg(
2568 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2569 options::OPT_fexceptions, options::OPT_fno_exceptions);
2570 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002571 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002572 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2573 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002574
2575 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002576 if (Triple.isPS4CPU()) {
2577 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2578 assert(ExceptionArg &&
2579 "On the PS4 exceptions should only be enabled if passing "
2580 "an argument");
2581 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2582 const Arg *RTTIArg = TC.getRTTIArg();
2583 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2584 D.Diag(diag::err_drv_argument_not_allowed_with)
2585 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2586 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2587 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2588 } else
2589 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2590
Anders Carlssone96ab552011-02-28 02:27:16 +00002591 CmdArgs.push_back("-fcxx-exceptions");
2592
David Majnemer8de68642014-12-05 08:11:58 +00002593 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002594 }
2595 }
2596
David Majnemer8de68642014-12-05 08:11:58 +00002597 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002598 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002599}
2600
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002601static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) {
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002602 bool Default = true;
2603 if (TC.getTriple().isOSDarwin()) {
2604 // The native darwin assembler doesn't support the linker_option directives,
2605 // so we disable them if we think the .s file will be passed to it.
2606 Default = TC.useIntegratedAs();
2607 }
2608 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2609 Default);
2610}
2611
Ted Kremenek62093662013-03-12 17:02:12 +00002612static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2613 const ToolChain &TC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002614 bool UseDwarfDirectory =
2615 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2616 options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002617 return !UseDwarfDirectory;
2618}
2619
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002620/// \brief Check whether the given input tree contains any compilation actions.
2621static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002622 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002623 return true;
2624
Nico Weber5a459f82016-02-23 19:30:43 +00002625 for (const auto &AI : A->inputs())
2626 if (ContainsCompileAction(AI))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002627 return true;
2628
2629 return false;
2630}
2631
2632/// \brief Check if -relax-all should be passed to the internal assembler.
2633/// This is done by default when compiling non-assembler source with -O0.
2634static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2635 bool RelaxDefault = true;
2636
2637 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2638 RelaxDefault = A->getOption().matches(options::OPT_O0);
2639
2640 if (RelaxDefault) {
2641 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002642 for (const auto &Act : C.getActions()) {
2643 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002644 RelaxDefault = true;
2645 break;
2646 }
2647 }
2648 }
2649
2650 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002651 RelaxDefault);
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002652}
2653
Paul Robinson0334a042015-12-19 19:41:48 +00002654// Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases
2655// to the corresponding DebugInfoKind.
Benjamin Kramer8c305922016-02-02 11:06:51 +00002656static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A) {
Paul Robinson0334a042015-12-19 19:41:48 +00002657 assert(A.getOption().matches(options::OPT_gN_Group) &&
2658 "Not a -g option that specifies a debug-info level");
2659 if (A.getOption().matches(options::OPT_g0) ||
2660 A.getOption().matches(options::OPT_ggdb0))
Benjamin Kramer8c305922016-02-02 11:06:51 +00002661 return codegenoptions::NoDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00002662 if (A.getOption().matches(options::OPT_gline_tables_only) ||
2663 A.getOption().matches(options::OPT_ggdb1))
Benjamin Kramer8c305922016-02-02 11:06:51 +00002664 return codegenoptions::DebugLineTablesOnly;
2665 return codegenoptions::LimitedDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00002666}
2667
Douglas Katzman3459ce22015-10-08 04:24:12 +00002668// Extract the integer N from a string spelled "-dwarf-N", returning 0
2669// on mismatch. The StringRef input (rather than an Arg) allows
2670// for use by the "-Xassembler" option parser.
2671static unsigned DwarfVersionNum(StringRef ArgValue) {
2672 return llvm::StringSwitch<unsigned>(ArgValue)
2673 .Case("-gdwarf-2", 2)
2674 .Case("-gdwarf-3", 3)
2675 .Case("-gdwarf-4", 4)
Eric Christopher3cb592d2015-12-28 19:58:44 +00002676 .Case("-gdwarf-5", 5)
Douglas Katzman3459ce22015-10-08 04:24:12 +00002677 .Default(0);
2678}
2679
2680static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
Benjamin Kramer8c305922016-02-02 11:06:51 +00002681 codegenoptions::DebugInfoKind DebugInfoKind,
Paul Robinson0334a042015-12-19 19:41:48 +00002682 unsigned DwarfVersion,
2683 llvm::DebuggerKind DebuggerTuning) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00002684 switch (DebugInfoKind) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002685 case codegenoptions::DebugLineTablesOnly:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002686 CmdArgs.push_back("-debug-info-kind=line-tables-only");
2687 break;
Benjamin Kramer8c305922016-02-02 11:06:51 +00002688 case codegenoptions::LimitedDebugInfo:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002689 CmdArgs.push_back("-debug-info-kind=limited");
2690 break;
Benjamin Kramer8c305922016-02-02 11:06:51 +00002691 case codegenoptions::FullDebugInfo:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002692 CmdArgs.push_back("-debug-info-kind=standalone");
2693 break;
2694 default:
2695 break;
2696 }
2697 if (DwarfVersion > 0)
2698 CmdArgs.push_back(
Benjamin Kramer32bd3c82015-10-08 10:31:17 +00002699 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
Paul Robinson0334a042015-12-19 19:41:48 +00002700 switch (DebuggerTuning) {
2701 case llvm::DebuggerKind::GDB:
2702 CmdArgs.push_back("-debugger-tuning=gdb");
2703 break;
2704 case llvm::DebuggerKind::LLDB:
2705 CmdArgs.push_back("-debugger-tuning=lldb");
2706 break;
2707 case llvm::DebuggerKind::SCE:
2708 CmdArgs.push_back("-debugger-tuning=sce");
2709 break;
2710 default:
2711 break;
2712 }
Douglas Katzman3459ce22015-10-08 04:24:12 +00002713}
2714
David Blaikie9260ed62013-07-25 21:19:01 +00002715static void CollectArgsForIntegratedAssembler(Compilation &C,
2716 const ArgList &Args,
2717 ArgStringList &CmdArgs,
2718 const Driver &D) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002719 if (UseRelaxAll(C, Args))
2720 CmdArgs.push_back("-mrelax-all");
David Blaikie9260ed62013-07-25 21:19:01 +00002721
David Majnemer2b9349d2015-12-21 22:09:34 +00002722 // Only default to -mincremental-linker-compatible if we think we are
2723 // targeting the MSVC linker.
2724 bool DefaultIncrementalLinkerCompatible =
2725 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2726 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2727 options::OPT_mno_incremental_linker_compatible,
2728 DefaultIncrementalLinkerCompatible))
2729 CmdArgs.push_back("-mincremental-linker-compatible");
2730
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002731 // When passing -I arguments to the assembler we sometimes need to
2732 // unconditionally take the next argument. For example, when parsing
2733 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2734 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2735 // arg after parsing the '-I' arg.
2736 bool TakeNextArg = false;
David Peixottodfb66142013-11-14 22:52:58 +00002737
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002738 // When using an integrated assembler, translate -Wa, and -Xassembler
2739 // options.
2740 bool CompressDebugSections = false;
Scott Egertonb67d4692016-01-14 13:01:48 +00002741 const char *MipsTargetFeature = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002742 for (const Arg *A :
2743 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2744 A->claim();
David Blaikie9260ed62013-07-25 21:19:01 +00002745
Benjamin Kramer72e64312015-09-24 14:48:49 +00002746 for (StringRef Value : A->getValues()) {
Renato Golin7c542b42015-07-27 23:44:45 +00002747 if (TakeNextArg) {
2748 CmdArgs.push_back(Value.data());
2749 TakeNextArg = false;
2750 continue;
2751 }
David Blaikie9260ed62013-07-25 21:19:01 +00002752
Daniel Sanders3d5e5682015-10-27 18:04:42 +00002753 switch (C.getDefaultToolChain().getArch()) {
2754 default:
2755 break;
2756 case llvm::Triple::mips:
2757 case llvm::Triple::mipsel:
2758 case llvm::Triple::mips64:
2759 case llvm::Triple::mips64el:
2760 if (Value == "--trap") {
2761 CmdArgs.push_back("-target-feature");
2762 CmdArgs.push_back("+use-tcc-in-div");
2763 continue;
2764 }
2765 if (Value == "--break") {
2766 CmdArgs.push_back("-target-feature");
2767 CmdArgs.push_back("-use-tcc-in-div");
2768 continue;
2769 }
2770 if (Value.startswith("-msoft-float")) {
2771 CmdArgs.push_back("-target-feature");
2772 CmdArgs.push_back("+soft-float");
2773 continue;
2774 }
2775 if (Value.startswith("-mhard-float")) {
2776 CmdArgs.push_back("-target-feature");
2777 CmdArgs.push_back("-soft-float");
2778 continue;
2779 }
Scott Egertonb67d4692016-01-14 13:01:48 +00002780
2781 MipsTargetFeature = llvm::StringSwitch<const char *>(Value)
2782 .Case("-mips1", "+mips1")
2783 .Case("-mips2", "+mips2")
2784 .Case("-mips3", "+mips3")
2785 .Case("-mips4", "+mips4")
2786 .Case("-mips5", "+mips5")
2787 .Case("-mips32", "+mips32")
2788 .Case("-mips32r2", "+mips32r2")
2789 .Case("-mips32r3", "+mips32r3")
2790 .Case("-mips32r5", "+mips32r5")
2791 .Case("-mips32r6", "+mips32r6")
2792 .Case("-mips64", "+mips64")
2793 .Case("-mips64r2", "+mips64r2")
2794 .Case("-mips64r3", "+mips64r3")
2795 .Case("-mips64r5", "+mips64r5")
2796 .Case("-mips64r6", "+mips64r6")
2797 .Default(nullptr);
2798 if (MipsTargetFeature)
2799 continue;
Daniel Sanders3d5e5682015-10-27 18:04:42 +00002800 }
2801
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002802 if (Value == "-force_cpusubtype_ALL") {
2803 // Do nothing, this is the default and we don't support anything else.
2804 } else if (Value == "-L") {
2805 CmdArgs.push_back("-msave-temp-labels");
2806 } else if (Value == "--fatal-warnings") {
2807 CmdArgs.push_back("-massembler-fatal-warnings");
2808 } else if (Value == "--noexecstack") {
2809 CmdArgs.push_back("-mnoexecstack");
2810 } else if (Value == "-compress-debug-sections" ||
2811 Value == "--compress-debug-sections") {
2812 CompressDebugSections = true;
2813 } else if (Value == "-nocompress-debug-sections" ||
2814 Value == "--nocompress-debug-sections") {
2815 CompressDebugSections = false;
2816 } else if (Value.startswith("-I")) {
2817 CmdArgs.push_back(Value.data());
2818 // We need to consume the next argument if the current arg is a plain
2819 // -I. The next arg will be the include directory.
2820 if (Value == "-I")
2821 TakeNextArg = true;
2822 } else if (Value.startswith("-gdwarf-")) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00002823 // "-gdwarf-N" options are not cc1as options.
2824 unsigned DwarfVersion = DwarfVersionNum(Value);
2825 if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.
2826 CmdArgs.push_back(Value.data());
2827 } else {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002828 RenderDebugEnablingArgs(Args, CmdArgs,
2829 codegenoptions::LimitedDebugInfo,
2830 DwarfVersion, llvm::DebuggerKind::Default);
Douglas Katzman3459ce22015-10-08 04:24:12 +00002831 }
Renato Golin7c542b42015-07-27 23:44:45 +00002832 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
2833 Value.startswith("-mhwdiv") || Value.startswith("-march")) {
2834 // Do nothing, we'll validate it later.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002835 } else {
2836 D.Diag(diag::err_drv_unsupported_option_argument)
David Blaikie9260ed62013-07-25 21:19:01 +00002837 << A->getOption().getName() << Value;
David Blaikie9260ed62013-07-25 21:19:01 +00002838 }
2839 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002840 }
2841 if (CompressDebugSections) {
2842 if (llvm::zlib::isAvailable())
2843 CmdArgs.push_back("-compress-debug-sections");
2844 else
2845 D.Diag(diag::warn_debug_compression_unavailable);
2846 }
Scott Egertonb67d4692016-01-14 13:01:48 +00002847 if (MipsTargetFeature != nullptr) {
2848 CmdArgs.push_back("-target-feature");
2849 CmdArgs.push_back(MipsTargetFeature);
2850 }
David Blaikie9260ed62013-07-25 21:19:01 +00002851}
2852
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002853// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002854// FIXME: Make sure we can also emit shared objects if they're requested
2855// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002856static void addClangRT(const ToolChain &TC, const ArgList &Args,
2857 ArgStringList &CmdArgs) {
Xinliang David Li69306c02015-10-22 06:15:31 +00002858 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins"));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002859}
2860
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002861namespace {
2862enum OpenMPRuntimeKind {
2863 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2864 /// without knowing what runtime to target.
2865 OMPRT_Unknown,
2866
2867 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2868 /// the default for Clang.
2869 OMPRT_OMP,
2870
2871 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2872 /// this runtime but can swallow the pragmas, and find and link against the
2873 /// runtime library itself.
2874 OMPRT_GOMP,
2875
Chandler Carruthc6625c62015-05-28 21:10:31 +00002876 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002877 /// OpenMP runtime. We support this mode for users with existing dependencies
2878 /// on this runtime library name.
2879 OMPRT_IOMP5
2880};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002881}
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002882
2883/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002884static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2885 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002886 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2887
2888 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2889 if (A)
2890 RuntimeName = A->getValue();
2891
2892 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002893 .Case("libomp", OMPRT_OMP)
2894 .Case("libgomp", OMPRT_GOMP)
2895 .Case("libiomp5", OMPRT_IOMP5)
2896 .Default(OMPRT_Unknown);
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002897
2898 if (RT == OMPRT_Unknown) {
2899 if (A)
2900 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002901 << A->getOption().getName() << A->getValue();
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002902 else
2903 // FIXME: We could use a nicer diagnostic here.
2904 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2905 }
2906
2907 return RT;
2908}
2909
Joerg Sonnenberger95a90132015-09-23 14:06:52 +00002910static void addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC,
2911 const ArgList &Args) {
2912 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
2913 options::OPT_fno_openmp, false))
2914 return;
2915
2916 switch (getOpenMPRuntime(TC, Args)) {
2917 case OMPRT_OMP:
2918 CmdArgs.push_back("-lomp");
2919 break;
2920 case OMPRT_GOMP:
2921 CmdArgs.push_back("-lgomp");
2922 break;
2923 case OMPRT_IOMP5:
2924 CmdArgs.push_back("-liomp5");
2925 break;
2926 case OMPRT_Unknown:
2927 // Already diagnosed.
2928 break;
2929 }
2930}
2931
Alexey Samsonov52550342014-09-15 19:58:40 +00002932static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2933 ArgStringList &CmdArgs, StringRef Sanitizer,
Peter Collingbournedc134532016-01-16 00:31:22 +00002934 bool IsShared, bool IsWhole) {
2935 // Wrap any static runtimes that must be forced into executable in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002936 // whole-archive.
Peter Collingbournedc134532016-01-16 00:31:22 +00002937 if (IsWhole) CmdArgs.push_back("-whole-archive");
Xinliang David Li69306c02015-10-22 06:15:31 +00002938 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Sanitizer, IsShared));
Peter Collingbournedc134532016-01-16 00:31:22 +00002939 if (IsWhole) CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002940}
2941
Alexey Samsonov52550342014-09-15 19:58:40 +00002942// Tries to use a file with the list of dynamic symbols that need to be exported
2943// from the runtime library. Returns true if the file was found.
2944static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2945 ArgStringList &CmdArgs,
2946 StringRef Sanitizer) {
Vasileios Kalintiris447e3572015-10-01 16:54:58 +00002947 SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer));
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002948 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2949 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002950 return true;
2951 }
2952 return false;
2953}
2954
2955static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2956 ArgStringList &CmdArgs) {
2957 // Force linking against the system libraries sanitizers depends on
2958 // (see PR15823 why this is necessary).
2959 CmdArgs.push_back("--no-as-needed");
2960 CmdArgs.push_back("-lpthread");
2961 CmdArgs.push_back("-lrt");
2962 CmdArgs.push_back("-lm");
2963 // There's no libdl on FreeBSD.
2964 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2965 CmdArgs.push_back("-ldl");
2966}
2967
2968static void
2969collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2970 SmallVectorImpl<StringRef> &SharedRuntimes,
2971 SmallVectorImpl<StringRef> &StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00002972 SmallVectorImpl<StringRef> &NonWholeStaticRuntimes,
2973 SmallVectorImpl<StringRef> &HelperStaticRuntimes,
2974 SmallVectorImpl<StringRef> &RequiredSymbols) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002975 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2976 // Collect shared runtimes.
2977 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2978 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002979 }
Peter Collingbournedc134532016-01-16 00:31:22 +00002980 // The stats_client library is also statically linked into DSOs.
2981 if (SanArgs.needsStatsRt())
2982 StaticRuntimes.push_back("stats_client");
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002983
Alexey Samsonov52550342014-09-15 19:58:40 +00002984 // Collect static runtimes.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00002985 if (Args.hasArg(options::OPT_shared) || TC.getTriple().isAndroid()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002986 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002987 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002988 }
2989 if (SanArgs.needsAsanRt()) {
2990 if (SanArgs.needsSharedAsanRt()) {
2991 HelperStaticRuntimes.push_back("asan-preinit");
2992 } else {
2993 StaticRuntimes.push_back("asan");
2994 if (SanArgs.linkCXXRuntimes())
2995 StaticRuntimes.push_back("asan_cxx");
2996 }
2997 }
2998 if (SanArgs.needsDfsanRt())
2999 StaticRuntimes.push_back("dfsan");
3000 if (SanArgs.needsLsanRt())
3001 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003002 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003003 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003004 if (SanArgs.linkCXXRuntimes())
3005 StaticRuntimes.push_back("msan_cxx");
3006 }
3007 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003008 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003009 if (SanArgs.linkCXXRuntimes())
3010 StaticRuntimes.push_back("tsan_cxx");
3011 }
Alexey Samsonov52550342014-09-15 19:58:40 +00003012 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00003013 StaticRuntimes.push_back("ubsan_standalone");
3014 if (SanArgs.linkCXXRuntimes())
3015 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00003016 }
Peter Collingbournec4122c12015-06-15 21:08:13 +00003017 if (SanArgs.needsSafeStackRt())
3018 StaticRuntimes.push_back("safestack");
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00003019 if (SanArgs.needsCfiRt())
3020 StaticRuntimes.push_back("cfi");
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00003021 if (SanArgs.needsCfiDiagRt()) {
Evgeniy Stepanove3fb51c2015-12-16 00:38:42 +00003022 StaticRuntimes.push_back("cfi_diag");
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00003023 if (SanArgs.linkCXXRuntimes())
3024 StaticRuntimes.push_back("ubsan_standalone_cxx");
3025 }
Peter Collingbournedc134532016-01-16 00:31:22 +00003026 if (SanArgs.needsStatsRt()) {
3027 NonWholeStaticRuntimes.push_back("stats");
3028 RequiredSymbols.push_back("__sanitizer_stats_register");
3029 }
Derek Bruening256c2e12016-04-21 21:32:04 +00003030 if (SanArgs.needsEsanRt())
3031 StaticRuntimes.push_back("esan");
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00003032}
3033
Alexey Samsonov52550342014-09-15 19:58:40 +00003034// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
3035// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
3036static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00003037 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003038 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00003039 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
Alexey Samsonov52550342014-09-15 19:58:40 +00003040 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00003041 NonWholeStaticRuntimes, HelperStaticRuntimes,
3042 RequiredSymbols);
Alexey Samsonov52550342014-09-15 19:58:40 +00003043 for (auto RT : SharedRuntimes)
Peter Collingbournedc134532016-01-16 00:31:22 +00003044 addSanitizerRuntime(TC, Args, CmdArgs, RT, true, false);
Alexey Samsonov52550342014-09-15 19:58:40 +00003045 for (auto RT : HelperStaticRuntimes)
Peter Collingbournedc134532016-01-16 00:31:22 +00003046 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
Alexey Samsonov52550342014-09-15 19:58:40 +00003047 bool AddExportDynamic = false;
3048 for (auto RT : StaticRuntimes) {
Peter Collingbournedc134532016-01-16 00:31:22 +00003049 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
Alexey Samsonov52550342014-09-15 19:58:40 +00003050 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
3051 }
Peter Collingbournedc134532016-01-16 00:31:22 +00003052 for (auto RT : NonWholeStaticRuntimes) {
3053 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, false);
3054 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
3055 }
3056 for (auto S : RequiredSymbols) {
3057 CmdArgs.push_back("-u");
3058 CmdArgs.push_back(Args.MakeArgString(S));
3059 }
Alexey Samsonov52550342014-09-15 19:58:40 +00003060 // If there is a static runtime with no dynamic list, force all the symbols
3061 // to be dynamic to be sure we export sanitizer interface functions.
3062 if (AddExportDynamic)
3063 CmdArgs.push_back("-export-dynamic");
3064 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00003065}
3066
Reid Kleckner86ea7702015-02-04 23:45:07 +00003067static bool areOptimizationsEnabled(const ArgList &Args) {
3068 // Find the last -O arg and see if it is non-zero.
3069 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
3070 return !A->getOption().matches(options::OPT_O0);
3071 // Defaults to -O0.
3072 return false;
3073}
3074
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003075static bool shouldUseFramePointerForTarget(const ArgList &Args,
3076 const llvm::Triple &Triple) {
Dan Gohmanc2853072015-09-03 22:51:53 +00003077 switch (Triple.getArch()) {
3078 case llvm::Triple::xcore:
3079 case llvm::Triple::wasm32:
3080 case llvm::Triple::wasm64:
3081 // XCore never wants frame pointers, regardless of OS.
3082 // WebAssembly never wants frame pointers.
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003083 return false;
Dan Gohmanc2853072015-09-03 22:51:53 +00003084 default:
3085 break;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003086 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00003087
3088 if (Triple.isOSLinux()) {
3089 switch (Triple.getArch()) {
3090 // Don't use a frame pointer on linux if optimizing for certain targets.
3091 case llvm::Triple::mips64:
3092 case llvm::Triple::mips64el:
3093 case llvm::Triple::mips:
3094 case llvm::Triple::mipsel:
3095 case llvm::Triple::systemz:
3096 case llvm::Triple::x86:
3097 case llvm::Triple::x86_64:
3098 return !areOptimizationsEnabled(Args);
3099 default:
3100 return true;
3101 }
3102 }
3103
3104 if (Triple.isOSWindows()) {
3105 switch (Triple.getArch()) {
3106 case llvm::Triple::x86:
3107 return !areOptimizationsEnabled(Args);
Akira Hatanaka8f5866a2016-02-26 05:07:00 +00003108 case llvm::Triple::x86_64:
3109 return Triple.isOSBinFormatMachO();
Saleem Abdulrasoola8180a22015-10-03 03:39:28 +00003110 case llvm::Triple::arm:
3111 case llvm::Triple::thumb:
3112 // Windows on ARM builds with FPO disabled to aid fast stack walking
3113 return true;
Reid Kleckner86ea7702015-02-04 23:45:07 +00003114 default:
3115 // All other supported Windows ISAs use xdata unwind information, so frame
3116 // pointers are not generally useful.
3117 return false;
3118 }
3119 }
3120
3121 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003122}
3123
Rafael Espindola224dd632011-12-14 21:02:23 +00003124static bool shouldUseFramePointer(const ArgList &Args,
3125 const llvm::Triple &Triple) {
3126 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
3127 options::OPT_fomit_frame_pointer))
3128 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
Xinliang David Li4dff8752015-11-23 17:30:31 +00003129 if (Args.hasArg(options::OPT_pg))
3130 return true;
Rafael Espindola224dd632011-12-14 21:02:23 +00003131
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003132 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00003133}
3134
Eric Christopherb7d97e92013-04-03 01:58:53 +00003135static bool shouldUseLeafFramePointer(const ArgList &Args,
3136 const llvm::Triple &Triple) {
3137 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
3138 options::OPT_momit_leaf_frame_pointer))
3139 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
Xinliang David Li4dff8752015-11-23 17:30:31 +00003140 if (Args.hasArg(options::OPT_pg))
3141 return true;
Eric Christopherb7d97e92013-04-03 01:58:53 +00003142
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00003143 if (Triple.isPS4CPU())
3144 return false;
3145
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003146 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00003147}
3148
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003149/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003150static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00003151 SmallString<128> cwd;
3152 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00003153 CmdArgs.push_back("-fdebug-compilation-dir");
3154 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003155 }
3156}
3157
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003158static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00003159 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
3160 if (FinalOutput && Args.hasArg(options::OPT_c)) {
3161 SmallString<128> T(FinalOutput->getValue());
3162 llvm::sys::path::replace_extension(T, "dwo");
3163 return Args.MakeArgString(T);
3164 } else {
3165 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00003166 SmallString<128> T(
3167 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00003168 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00003169 llvm::sys::path::replace_extension(F, "dwo");
3170 T += F;
3171 return Args.MakeArgString(F);
3172 }
3173}
3174
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003175static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
3176 const JobAction &JA, const ArgList &Args,
3177 const InputInfo &Output, const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00003178 ArgStringList ExtractArgs;
3179 ExtractArgs.push_back("--extract-dwo");
3180
3181 ArgStringList StripArgs;
3182 StripArgs.push_back("--strip-dwo");
3183
3184 // Grabbing the output of the earlier compile step.
3185 StripArgs.push_back(Output.getFilename());
3186 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00003187 ExtractArgs.push_back(OutFile);
3188
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003189 const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
Justin Lebard98cea82016-01-11 23:15:21 +00003190 InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00003191
3192 // First extract the dwo sections.
Justin Bognerd3371d82015-07-17 03:35:54 +00003193 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00003194
3195 // Then remove them from the original .o file.
Justin Bognerd3371d82015-07-17 03:35:54 +00003196 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00003197}
3198
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003199/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003200/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
3201static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003202 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00003203 if (A->getOption().matches(options::OPT_O4) ||
3204 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003205 return true;
3206
3207 if (A->getOption().matches(options::OPT_O0))
3208 return false;
3209
3210 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
3211
Rafael Espindola91780de2013-08-26 14:05:41 +00003212 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003213 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00003214 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003215 return true;
3216
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003217 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003218 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003219 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003220
3221 unsigned OptLevel = 0;
3222 if (S.getAsInteger(10, OptLevel))
3223 return false;
3224
3225 return OptLevel > 1;
3226 }
3227
3228 return false;
3229}
3230
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003231/// Add -x lang to \p CmdArgs for \p Input.
3232static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
3233 ArgStringList &CmdArgs) {
3234 // When using -verify-pch, we don't want to provide the type
3235 // 'precompiled-header' if it was inferred from the file extension
3236 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
3237 return;
3238
3239 CmdArgs.push_back("-x");
3240 if (Args.hasArg(options::OPT_rewrite_objc))
3241 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3242 else
3243 CmdArgs.push_back(types::getTypeName(Input.getType()));
3244}
3245
David Majnemerc371ff02015-03-22 08:39:22 +00003246static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003247 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00003248 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003249
3250 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00003251 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003252
3253 unsigned Build = 0, Factor = 1;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003254 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003255 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00003256 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003257}
3258
Rafael Espindola577637a2015-01-03 00:06:04 +00003259// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00003260// options that build systems might add but are unused when assembling or only
3261// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00003262static void claimNoWarnArgs(const ArgList &Args) {
3263 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00003264 // preprocessing, precompiling or assembling.
Teresa Johnson945bc502015-10-15 20:35:53 +00003265 Args.ClaimAllArgs(options::OPT_flto_EQ);
Rafael Espindola577637a2015-01-03 00:06:04 +00003266 Args.ClaimAllArgs(options::OPT_flto);
3267 Args.ClaimAllArgs(options::OPT_fno_lto);
3268}
3269
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003270static void appendUserToPath(SmallVectorImpl<char> &Result) {
3271#ifdef LLVM_ON_UNIX
3272 const char *Username = getenv("LOGNAME");
3273#else
3274 const char *Username = getenv("USERNAME");
3275#endif
3276 if (Username) {
3277 // Validate that LoginName can be used in a path, and get its length.
3278 size_t Len = 0;
3279 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00003280 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003281 Username = nullptr;
3282 break;
3283 }
3284 }
3285
3286 if (Username && Len > 0) {
3287 Result.append(Username, Username + Len);
3288 return;
3289 }
3290 }
3291
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003292// Fallback to user id.
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003293#ifdef LLVM_ON_UNIX
3294 std::string UID = llvm::utostr(getuid());
3295#else
3296 // FIXME: Windows seems to have an 'SID' that might work.
3297 std::string UID = "9999";
3298#endif
3299 Result.append(UID.begin(), UID.end());
3300}
3301
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00003302VersionTuple visualstudio::getMSVCVersion(const Driver *D, const ToolChain &TC,
David Majnemere11d3732015-06-08 00:22:46 +00003303 const llvm::Triple &Triple,
3304 const llvm::opt::ArgList &Args,
3305 bool IsWindowsMSVC) {
3306 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3307 IsWindowsMSVC) ||
3308 Args.hasArg(options::OPT_fmsc_version) ||
3309 Args.hasArg(options::OPT_fms_compatibility_version)) {
3310 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3311 const Arg *MSCompatibilityVersion =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003312 Args.getLastArg(options::OPT_fms_compatibility_version);
David Majnemere11d3732015-06-08 00:22:46 +00003313
3314 if (MSCVersion && MSCompatibilityVersion) {
3315 if (D)
3316 D->Diag(diag::err_drv_argument_not_allowed_with)
3317 << MSCVersion->getAsString(Args)
3318 << MSCompatibilityVersion->getAsString(Args);
3319 return VersionTuple();
3320 }
3321
3322 if (MSCompatibilityVersion) {
3323 VersionTuple MSVT;
3324 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
3325 D->Diag(diag::err_drv_invalid_value)
3326 << MSCompatibilityVersion->getAsString(Args)
3327 << MSCompatibilityVersion->getValue();
3328 return MSVT;
3329 }
3330
3331 if (MSCVersion) {
3332 unsigned Version = 0;
3333 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
3334 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
3335 << MSCVersion->getValue();
3336 return getMSCompatibilityVersion(Version);
3337 }
3338
3339 unsigned Major, Minor, Micro;
3340 Triple.getEnvironmentVersion(Major, Minor, Micro);
3341 if (Major || Minor || Micro)
3342 return VersionTuple(Major, Minor, Micro);
3343
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00003344 if (IsWindowsMSVC) {
3345 VersionTuple MSVT = TC.getMSVCVersionFromExe();
3346 if (!MSVT.empty())
3347 return MSVT;
3348
3349 // FIXME: Consider bumping this to 19 (MSVC2015) soon.
3350 return VersionTuple(18);
3351 }
David Majnemere11d3732015-06-08 00:22:46 +00003352 }
3353 return VersionTuple();
3354}
3355
Diego Novilloa0545962015-07-10 18:00:07 +00003356static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
3357 const InputInfo &Output, const ArgList &Args,
3358 ArgStringList &CmdArgs) {
3359 auto *ProfileGenerateArg = Args.getLastArg(
3360 options::OPT_fprofile_instr_generate,
3361 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
Diego Novillo758f3f52015-08-05 21:49:51 +00003362 options::OPT_fprofile_generate_EQ,
3363 options::OPT_fno_profile_instr_generate);
3364 if (ProfileGenerateArg &&
3365 ProfileGenerateArg->getOption().matches(
3366 options::OPT_fno_profile_instr_generate))
3367 ProfileGenerateArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00003368
3369 auto *ProfileUseArg = Args.getLastArg(
3370 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
Diego Novillo758f3f52015-08-05 21:49:51 +00003371 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
3372 options::OPT_fno_profile_instr_use);
3373 if (ProfileUseArg &&
3374 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
3375 ProfileUseArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00003376
3377 if (ProfileGenerateArg && ProfileUseArg)
3378 D.Diag(diag::err_drv_argument_not_allowed_with)
Renato Golin7c542b42015-07-27 23:44:45 +00003379 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
Diego Novilloa0545962015-07-10 18:00:07 +00003380
Diego Novillo758f3f52015-08-05 21:49:51 +00003381 if (ProfileGenerateArg) {
3382 if (ProfileGenerateArg->getOption().matches(
3383 options::OPT_fprofile_instr_generate_EQ))
Rong Xu9837ef52016-02-04 18:39:09 +00003384 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
3385 ProfileGenerateArg->getValue()));
Diego Novillo758f3f52015-08-05 21:49:51 +00003386 else if (ProfileGenerateArg->getOption().matches(
3387 options::OPT_fprofile_generate_EQ)) {
3388 SmallString<128> Path(ProfileGenerateArg->getValue());
3389 llvm::sys::path::append(Path, "default.profraw");
3390 CmdArgs.push_back(
Rong Xu9837ef52016-02-04 18:39:09 +00003391 Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
3392 }
3393 // The default is to use Clang Instrumentation.
3394 CmdArgs.push_back("-fprofile-instrument=clang");
Diego Novillo758f3f52015-08-05 21:49:51 +00003395 }
Diego Novilloa0545962015-07-10 18:00:07 +00003396
Diego Novillo758f3f52015-08-05 21:49:51 +00003397 if (ProfileUseArg) {
3398 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
Rong Xu9c6f1532016-03-02 20:59:36 +00003399 CmdArgs.push_back(Args.MakeArgString(
3400 Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
Diego Novillo758f3f52015-08-05 21:49:51 +00003401 else if ((ProfileUseArg->getOption().matches(
3402 options::OPT_fprofile_use_EQ) ||
3403 ProfileUseArg->getOption().matches(
3404 options::OPT_fprofile_instr_use))) {
3405 SmallString<128> Path(
3406 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
3407 if (Path.empty() || llvm::sys::fs::is_directory(Path))
3408 llvm::sys::path::append(Path, "default.profdata");
3409 CmdArgs.push_back(
Rong Xu9c6f1532016-03-02 20:59:36 +00003410 Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
Diego Novillo758f3f52015-08-05 21:49:51 +00003411 }
Diego Novilloa0545962015-07-10 18:00:07 +00003412 }
3413
3414 if (Args.hasArg(options::OPT_ftest_coverage) ||
3415 Args.hasArg(options::OPT_coverage))
3416 CmdArgs.push_back("-femit-coverage-notes");
3417 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3418 false) ||
3419 Args.hasArg(options::OPT_coverage))
3420 CmdArgs.push_back("-femit-coverage-data");
3421
Diego Novilloc4b94da2015-08-05 23:27:40 +00003422 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3423 options::OPT_fno_coverage_mapping, false) &&
3424 !ProfileGenerateArg)
Diego Novilloa0545962015-07-10 18:00:07 +00003425 D.Diag(diag::err_drv_argument_only_allowed_with)
3426 << "-fcoverage-mapping"
3427 << "-fprofile-instr-generate";
3428
Diego Novilloc4b94da2015-08-05 23:27:40 +00003429 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3430 options::OPT_fno_coverage_mapping, false))
Diego Novilloa0545962015-07-10 18:00:07 +00003431 CmdArgs.push_back("-fcoverage-mapping");
3432
3433 if (C.getArgs().hasArg(options::OPT_c) ||
3434 C.getArgs().hasArg(options::OPT_S)) {
3435 if (Output.isFilename()) {
3436 CmdArgs.push_back("-coverage-file");
3437 SmallString<128> CoverageFilename;
3438 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
3439 CoverageFilename = FinalOutput->getValue();
3440 } else {
3441 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3442 }
3443 if (llvm::sys::path::is_relative(CoverageFilename)) {
3444 SmallString<128> Pwd;
3445 if (!llvm::sys::fs::current_path(Pwd)) {
3446 llvm::sys::path::append(Pwd, CoverageFilename);
3447 CoverageFilename.swap(Pwd);
3448 }
3449 }
3450 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
3451 }
3452 }
3453}
3454
Paul Robinsond083b9a2015-12-16 17:25:27 +00003455static void addPS4ProfileRTArgs(const ToolChain &TC, const ArgList &Args,
3456 ArgStringList &CmdArgs) {
3457 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3458 false) ||
3459 Args.hasFlag(options::OPT_fprofile_generate,
3460 options::OPT_fno_profile_instr_generate, false) ||
3461 Args.hasFlag(options::OPT_fprofile_generate_EQ,
3462 options::OPT_fno_profile_instr_generate, false) ||
3463 Args.hasFlag(options::OPT_fprofile_instr_generate,
3464 options::OPT_fno_profile_instr_generate, false) ||
3465 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
3466 options::OPT_fno_profile_instr_generate, false) ||
3467 Args.hasArg(options::OPT_fcreate_profile) ||
3468 Args.hasArg(options::OPT_coverage)))
3469 CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
3470}
3471
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003472/// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
3473/// smooshes them together with platform defaults, to decide whether
3474/// this compile should be using PIC mode or not. Returns a tuple of
3475/// (RelocationModel, PICLevel, IsPIE).
3476static std::tuple<llvm::Reloc::Model, unsigned, bool>
3477ParsePICArgs(const ToolChain &ToolChain, const llvm::Triple &Triple,
3478 const ArgList &Args) {
3479 // FIXME: why does this code...and so much everywhere else, use both
3480 // ToolChain.getTriple() and Triple?
3481 bool PIE = ToolChain.isPIEDefault();
3482 bool PIC = PIE || ToolChain.isPICDefault();
Bob Wilson0a15e6c2016-01-13 01:19:02 +00003483 // The Darwin/MachO default to use PIC does not apply when using -static.
3484 if (ToolChain.getTriple().isOSBinFormatMachO() &&
3485 Args.hasArg(options::OPT_static))
Bob Wilson2b2a0ae2015-12-18 20:37:54 +00003486 PIE = PIC = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003487 bool IsPICLevelTwo = PIC;
3488
3489 bool KernelOrKext =
3490 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3491
3492 // Android-specific defaults for PIC/PIE
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00003493 if (ToolChain.getTriple().isAndroid()) {
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003494 switch (ToolChain.getArch()) {
3495 case llvm::Triple::arm:
3496 case llvm::Triple::armeb:
3497 case llvm::Triple::thumb:
3498 case llvm::Triple::thumbeb:
3499 case llvm::Triple::aarch64:
3500 case llvm::Triple::mips:
3501 case llvm::Triple::mipsel:
3502 case llvm::Triple::mips64:
3503 case llvm::Triple::mips64el:
3504 PIC = true; // "-fpic"
3505 break;
3506
3507 case llvm::Triple::x86:
3508 case llvm::Triple::x86_64:
3509 PIC = true; // "-fPIC"
3510 IsPICLevelTwo = true;
3511 break;
3512
3513 default:
3514 break;
3515 }
3516 }
3517
3518 // OpenBSD-specific defaults for PIE
3519 if (ToolChain.getTriple().getOS() == llvm::Triple::OpenBSD) {
3520 switch (ToolChain.getArch()) {
3521 case llvm::Triple::mips64:
3522 case llvm::Triple::mips64el:
3523 case llvm::Triple::sparcel:
3524 case llvm::Triple::x86:
3525 case llvm::Triple::x86_64:
3526 IsPICLevelTwo = false; // "-fpie"
3527 break;
3528
3529 case llvm::Triple::ppc:
3530 case llvm::Triple::sparc:
3531 case llvm::Triple::sparcv9:
3532 IsPICLevelTwo = true; // "-fPIE"
3533 break;
3534
3535 default:
3536 break;
3537 }
3538 }
3539
3540 // The last argument relating to either PIC or PIE wins, and no
3541 // other argument is used. If the last argument is any flavor of the
3542 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
3543 // option implicitly enables PIC at the same level.
3544 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3545 options::OPT_fpic, options::OPT_fno_pic,
3546 options::OPT_fPIE, options::OPT_fno_PIE,
3547 options::OPT_fpie, options::OPT_fno_pie);
3548 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3549 // is forced, then neither PIC nor PIE flags will have no effect.
3550 if (!ToolChain.isPICDefaultForced()) {
3551 if (LastPICArg) {
3552 Option O = LastPICArg->getOption();
3553 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3554 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3555 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3556 PIC =
3557 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3558 IsPICLevelTwo =
3559 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3560 } else {
3561 PIE = PIC = false;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003562 if (Triple.isPS4CPU()) {
3563 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
3564 StringRef Model = ModelArg ? ModelArg->getValue() : "";
3565 if (Model != "kernel") {
3566 PIC = true;
3567 ToolChain.getDriver().Diag(diag::warn_drv_ps4_force_pic)
3568 << LastPICArg->getSpelling();
3569 }
3570 }
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003571 }
3572 }
3573 }
3574
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003575 // Introduce a Darwin and PS4-specific hack. If the default is PIC, but the
3576 // PIC level would've been set to level 1, force it back to level 2 PIC
3577 // instead.
3578 if (PIC && (ToolChain.getTriple().isOSDarwin() || Triple.isPS4CPU()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003579 IsPICLevelTwo |= ToolChain.isPICDefault();
3580
James Y Knightc4015d32015-08-21 04:14:55 +00003581 // This kernel flags are a trump-card: they will disable PIC/PIE
3582 // generation, independent of the argument order.
Tim Northover6f3ff222015-10-30 16:30:27 +00003583 if (KernelOrKext && ((!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
3584 !Triple.isWatchOS()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003585 PIC = PIE = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003586
3587 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3588 // This is a very special mode. It trumps the other modes, almost no one
3589 // uses it, and it isn't even valid on any OS but Darwin.
3590 if (!ToolChain.getTriple().isOSDarwin())
3591 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
3592 << A->getSpelling() << ToolChain.getTriple().str();
3593
3594 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3595
3596 // Only a forced PIC mode can cause the actual compile to have PIC defines
3597 // etc., no flags are sufficient. This behavior was selected to closely
3598 // match that of llvm-gcc and Apple GCC before that.
3599 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
3600
3601 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2 : 0, false);
3602 }
3603
3604 if (PIC)
3605 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2 : 1, PIE);
3606
3607 return std::make_tuple(llvm::Reloc::Static, 0, false);
3608}
3609
3610static const char *RelocationModelName(llvm::Reloc::Model Model) {
3611 switch (Model) {
3612 case llvm::Reloc::Default:
3613 return nullptr;
3614 case llvm::Reloc::Static:
3615 return "static";
3616 case llvm::Reloc::PIC_:
3617 return "pic";
3618 case llvm::Reloc::DynamicNoPIC:
3619 return "dynamic-no-pic";
3620 }
Aaron Ballman2ec49282015-08-20 13:31:16 +00003621 llvm_unreachable("Unknown Reloc::Model kind");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003622}
3623
3624static void AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
3625 ArgStringList &CmdArgs) {
3626 llvm::Reloc::Model RelocationModel;
3627 unsigned PICLevel;
3628 bool IsPIE;
3629 std::tie(RelocationModel, PICLevel, IsPIE) =
3630 ParsePICArgs(ToolChain, ToolChain.getTriple(), Args);
3631
3632 if (RelocationModel != llvm::Reloc::Static)
3633 CmdArgs.push_back("-KPIC");
3634}
3635
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003636void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003637 const InputInfo &Output, const InputInfoList &Inputs,
3638 const ArgList &Args, const char *LinkingOutput) const {
James Y Knight2db38f32015-08-15 03:45:25 +00003639 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3640 const llvm::Triple Triple(TripleStr);
3641
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003642 bool KernelOrKext =
3643 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00003644 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003645 ArgStringList CmdArgs;
3646
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003647 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00003648 bool IsWindowsCygnus =
3649 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003650 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003651 bool IsPS4CPU = getToolChain().getTriple().isPS4CPU();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003652
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003653 // Check number of inputs for sanity. We need at least one input.
3654 assert(Inputs.size() >= 1 && "Must have at least one input.");
Artem Belevichba558952015-05-06 18:20:23 +00003655 const InputInfo &Input = Inputs[0];
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003656 // CUDA compilation may have multiple inputs (source file + results of
3657 // device-side compilations). All other jobs are expected to have exactly one
3658 // input.
3659 bool IsCuda = types::isCuda(Input.getType());
3660 assert((IsCuda || Inputs.size() == 1) && "Unable to handle multiple inputs.");
Daniel Dunbare521a892009-03-31 20:53:55 +00003661
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003662 // Invoke ourselves in -cc1 mode.
3663 //
3664 // FIXME: Implement custom jobs for internal actions.
3665 CmdArgs.push_back("-cc1");
3666
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003667 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00003668 CmdArgs.push_back("-triple");
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003669 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00003670
Artem Belevichfa11ab52015-11-17 22:28:46 +00003671 const ToolChain *AuxToolChain = nullptr;
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00003672 if (IsCuda) {
3673 // FIXME: We need a (better) way to pass information about
3674 // particular compilation pass we're constructing here. For now we
3675 // can check which toolchain we're using and pick the other one to
3676 // extract the triple.
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00003677 if (&getToolChain() == C.getCudaDeviceToolChain())
3678 AuxToolChain = C.getCudaHostToolChain();
3679 else if (&getToolChain() == C.getCudaHostToolChain())
3680 AuxToolChain = C.getCudaDeviceToolChain();
3681 else
3682 llvm_unreachable("Can't figure out CUDA compilation mode.");
3683 assert(AuxToolChain != nullptr && "No aux toolchain.");
3684 CmdArgs.push_back("-aux-triple");
3685 CmdArgs.push_back(Args.MakeArgString(AuxToolChain->getTriple().str()));
3686 }
3687
James Y Knight2db38f32015-08-15 03:45:25 +00003688 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3689 Triple.getArch() == llvm::Triple::thumb)) {
3690 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003691 unsigned Version;
James Y Knight2db38f32015-08-15 03:45:25 +00003692 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003693 if (Version < 7)
James Y Knight2db38f32015-08-15 03:45:25 +00003694 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
Nico Webere8e53112014-05-11 01:04:02 +00003695 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003696 }
3697
Tim Northover336f1892014-03-29 13:16:12 +00003698 // Push all default warning arguments that are specific to
3699 // the given target. These come before user provided warning options
3700 // are provided.
3701 getToolChain().addClangWarningOptions(CmdArgs);
3702
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003703 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00003704 RewriteKind rewriteKind = RK_None;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003705
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003706 if (isa<AnalyzeJobAction>(JA)) {
3707 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
3708 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003709 } else if (isa<MigrateJobAction>(JA)) {
3710 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003711 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003712 if (Output.getType() == types::TY_Dependencies)
3713 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003714 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003715 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003716 if (Args.hasArg(options::OPT_rewrite_objc) &&
3717 !Args.hasArg(options::OPT_g_Group))
3718 CmdArgs.push_back("-P");
3719 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00003720 } else if (isa<AssembleJobAction>(JA)) {
3721 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003722
David Blaikie9260ed62013-07-25 21:19:01 +00003723 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00003724
3725 // Also ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003726 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003727 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00003728 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003729 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003730
Aaron Ballman1f10cc52012-07-31 01:21:00 +00003731 if (JA.getType() == types::TY_Nothing)
3732 CmdArgs.push_back("-fsyntax-only");
3733 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00003734 CmdArgs.push_back("-emit-pch");
3735 else
3736 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003737 } else if (isa<VerifyPCHJobAction>(JA)) {
3738 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003739 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00003740 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3741 "Invalid action for clang tool.");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003742 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003743 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003744 } else if (JA.getType() == types::TY_LLVM_IR ||
3745 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003746 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003747 } else if (JA.getType() == types::TY_LLVM_BC ||
3748 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003749 CmdArgs.push_back("-emit-llvm-bc");
3750 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00003751 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003752 } else if (JA.getType() == types::TY_AST) {
3753 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00003754 } else if (JA.getType() == types::TY_ModuleFile) {
3755 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003756 } else if (JA.getType() == types::TY_RewrittenObjC) {
3757 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003758 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00003759 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
3760 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003761 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003762 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003763 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003764 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00003765
3766 // Preserve use-list order by default when emitting bitcode, so that
3767 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
3768 // same result as running passes here. For LTO, we don't need to preserve
3769 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00003770 if (JA.getType() == types::TY_LLVM_BC)
3771 CmdArgs.push_back("-emit-llvm-uselists");
Teresa Johnson945bc502015-10-15 20:35:53 +00003772
3773 if (D.isUsingLTO())
3774 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003775 }
3776
Teresa Johnsonaff22322015-12-07 19:21:34 +00003777 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3778 if (!types::isLLVMIR(Input.getType()))
3779 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3780 << "-x ir";
3781 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3782 }
3783
Steven Wu574b0f22016-03-01 01:07:58 +00003784 // Embed-bitcode option.
3785 if (C.getDriver().embedBitcodeEnabled() &&
3786 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
3787 // Add flags implied by -fembed-bitcode.
Steven Wu27fb5222016-05-11 16:26:03 +00003788 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
Steven Wu574b0f22016-03-01 01:07:58 +00003789 // Disable all llvm IR level optimizations.
3790 CmdArgs.push_back("-disable-llvm-optzns");
3791 }
3792 if (C.getDriver().embedBitcodeMarkerOnly())
Steven Wu27fb5222016-05-11 16:26:03 +00003793 CmdArgs.push_back("-fembed-bitcode=marker");
Steven Wu574b0f22016-03-01 01:07:58 +00003794
Justin Bognera88f0122014-06-20 22:59:50 +00003795 // We normally speed up the clang process a bit by skipping destructors at
3796 // exit, but when we're generating diagnostics we can rely on some of the
3797 // cleanup.
3798 if (!C.isForDiagnostics())
3799 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003800
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003801// Disable the verification pass in -asserts builds.
John McCallbb79b5f2010-02-13 03:50:24 +00003802#ifdef NDEBUG
3803 CmdArgs.push_back("-disable-llvm-verifier");
Mehdi Amini557c20a2016-03-13 21:05:23 +00003804 // Discard LLVM value names in -asserts builds.
3805 CmdArgs.push_back("-discard-value-names");
John McCallbb79b5f2010-02-13 03:50:24 +00003806#endif
3807
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003808 // Set the main file name, so that debug info works even with
3809 // -save-temps.
3810 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00003811 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003812
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003813 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00003814 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003815 if (Args.hasArg(options::OPT_static))
3816 CmdArgs.push_back("-static-define");
3817
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003818 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00003819 // Enable region store model by default.
3820 CmdArgs.push_back("-analyzer-store=region");
3821
Ted Kremenek7bea9a12009-12-07 22:26:14 +00003822 // Treat blocks as analysis entry points.
3823 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
3824
Ted Kremenek49c79792011-03-24 00:28:47 +00003825 CmdArgs.push_back("-analyzer-eagerly-assume");
3826
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003827 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003828 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003829 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00003830
Devin Coughlin65c77082016-01-21 20:09:49 +00003831 if (!IsWindowsMSVC) {
3832 CmdArgs.push_back("-analyzer-checker=unix");
3833 } else {
3834 // Enable "unix" checkers that also work on Windows.
3835 CmdArgs.push_back("-analyzer-checker=unix.API");
3836 CmdArgs.push_back("-analyzer-checker=unix.Malloc");
3837 CmdArgs.push_back("-analyzer-checker=unix.MallocSizeof");
3838 CmdArgs.push_back("-analyzer-checker=unix.MismatchedDeallocator");
3839 CmdArgs.push_back("-analyzer-checker=unix.cstring.BadSizeArg");
3840 CmdArgs.push_back("-analyzer-checker=unix.cstring.NullArg");
3841 }
Ted Kremenek49c79792011-03-24 00:28:47 +00003842
Sean Evesonb38c32b2016-01-06 10:03:58 +00003843 // Disable some unix checkers for PS4.
3844 if (IsPS4CPU) {
3845 CmdArgs.push_back("-analyzer-disable-checker=unix.API");
3846 CmdArgs.push_back("-analyzer-disable-checker=unix.Vfork");
3847 }
3848
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003849 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00003850 CmdArgs.push_back("-analyzer-checker=osx");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003851
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00003852 CmdArgs.push_back("-analyzer-checker=deadcode");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003853
Artem Belevichba558952015-05-06 18:20:23 +00003854 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00003855 CmdArgs.push_back("-analyzer-checker=cplusplus");
3856
Sean Evesonb38c32b2016-01-06 10:03:58 +00003857 if (!IsPS4CPU) {
3858 CmdArgs.push_back(
3859 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
3860 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
3861 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
3862 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
3863 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
3864 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
3865 }
Gabor Horvathe3085992015-09-14 20:34:06 +00003866
3867 // Default nullability checks.
3868 CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull");
3869 CmdArgs.push_back(
3870 "-analyzer-checker=nullability.NullReturnedFromNonnull");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003871 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003872
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003873 // Set the output format. The default is plist, for (lame) historical
3874 // reasons.
3875 CmdArgs.push_back("-analyzer-output");
3876 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00003877 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003878 else
3879 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003880
Ted Kremenekfe449a22010-03-22 22:32:05 +00003881 // Disable the presentation of standard compiler warnings when
3882 // using --analyze. We only want to show static analyzer diagnostics
3883 // or frontend errors.
3884 CmdArgs.push_back("-w");
3885
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003886 // Add -Xanalyzer arguments when running as analyzer.
3887 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00003888 }
3889
Daniel Dunbar4eadb602009-09-10 01:21:12 +00003890 CheckCodeGenerationOptions(D, Args);
3891
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003892 llvm::Reloc::Model RelocationModel;
3893 unsigned PICLevel;
3894 bool IsPIE;
3895 std::tie(RelocationModel, PICLevel, IsPIE) =
3896 ParsePICArgs(getToolChain(), Triple, Args);
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003897
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003898 const char *RMName = RelocationModelName(RelocationModel);
3899 if (RMName) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003900 CmdArgs.push_back("-mrelocation-model");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003901 CmdArgs.push_back(RMName);
3902 }
3903 if (PICLevel > 0) {
3904 CmdArgs.push_back("-pic-level");
3905 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
3906 if (IsPIE) {
3907 CmdArgs.push_back("-pie-level");
3908 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003909 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003910 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003911
Renato Golin4854d802015-11-09 12:40:41 +00003912 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3913 CmdArgs.push_back("-meabi");
3914 CmdArgs.push_back(A->getValue());
3915 }
3916
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003917 CmdArgs.push_back("-mthread-model");
3918 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3919 CmdArgs.push_back(A->getValue());
3920 else
3921 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3922
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003923 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3924
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003925 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3926 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003927 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003928
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003929 // LLVM Code Generator Options.
3930
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003931 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3932 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003933 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3934 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003935 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003936 CmdArgs.push_back(A->getValue());
3937 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003938 }
3939 }
3940
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003941 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3942 StringRef v = A->getValue();
3943 CmdArgs.push_back("-mllvm");
3944 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3945 A->claim();
3946 }
3947
Nirav Daved2f44d82016-04-05 17:50:43 +00003948 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
3949 true))
3950 CmdArgs.push_back("-fno-jump-tables");
3951
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003952 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3953 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003954 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003955 }
3956
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003957 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3958 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003959 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00003960 D.Diag(diag::err_drv_unsupported_opt_for_target)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003961 << A->getSpelling() << getToolChain().getTriple().str();
John McCall1fe2a8c2013-06-18 02:46:29 +00003962 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3963 CmdArgs.push_back("-fpcc-struct-return");
3964 } else {
3965 assert(A->getOption().matches(options::OPT_freg_struct_return));
3966 CmdArgs.push_back("-freg-struct-return");
3967 }
3968 }
3969
Roman Divacky65b88cd2011-03-01 17:40:53 +00003970 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
Alexey Bataeva7547182016-05-18 09:06:38 +00003971 CmdArgs.push_back("-fdefault-calling-conv=stdcall");
Roman Divacky65b88cd2011-03-01 17:40:53 +00003972
Rafael Espindola224dd632011-12-14 21:02:23 +00003973 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003974 CmdArgs.push_back("-mdisable-fp-elim");
3975 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3976 options::OPT_fno_zero_initialized_in_bss))
3977 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003978
3979 bool OFastEnabled = isOptimizationLevelFast(Args);
3980 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3981 // enabled. This alias option is being used to simplify the hasFlag logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003982 OptSpecifier StrictAliasingAliasOption =
3983 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003984 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3985 // doesn't do any TBAA.
3986 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003987 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003988 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003989 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003990 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3991 options::OPT_fno_struct_path_tbaa))
3992 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003993 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3994 false))
3995 CmdArgs.push_back("-fstrict-enums");
Piotr Padlewski338c9d02015-09-15 21:46:47 +00003996 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3997 options::OPT_fno_strict_vtable_pointers,
3998 false))
3999 CmdArgs.push_back("-fstrict-vtable-pointers");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00004000 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4001 options::OPT_fno_optimize_sibling_calls))
4002 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004003
Eric Christopher006208c2013-04-04 06:29:47 +00004004 // Handle segmented stacks.
4005 if (Args.hasArg(options::OPT_fsplit_stack))
4006 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004007
4008 // If -Ofast is the optimization level, then -ffast-math should be enabled.
4009 // This alias option is being used to simplify the getLastArg logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004010 OptSpecifier FastMathAliasOption =
4011 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
4012
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004013 // Handle various floating point optimization flags, mapping them to the
4014 // appropriate LLVM code generation flags. The pattern for all of these is to
4015 // default off the codegen optimizations, and if any flag enables them and no
4016 // flag disables them after the flag enabling them, enable the codegen
4017 // optimization. This is complicated by several "umbrella" flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004018 if (Arg *A = Args.getLastArg(
4019 options::OPT_ffast_math, FastMathAliasOption,
4020 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
4021 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
4022 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004023 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4024 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004025 A->getOption().getID() != options::OPT_fhonor_infinities)
4026 CmdArgs.push_back("-menable-no-infs");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004027 if (Arg *A = Args.getLastArg(
4028 options::OPT_ffast_math, FastMathAliasOption,
4029 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
4030 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
4031 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004032 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4033 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004034 A->getOption().getID() != options::OPT_fhonor_nans)
4035 CmdArgs.push_back("-menable-no-nans");
4036
Benjamin Kramerc242ef22012-05-02 14:55:48 +00004037 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
4038 bool MathErrno = getToolChain().IsMathErrnoDefault();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004039 if (Arg *A =
4040 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
4041 options::OPT_fno_fast_math, options::OPT_fmath_errno,
4042 options::OPT_fno_math_errno)) {
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00004043 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
4044 // However, turning *off* -ffast_math merely restores the toolchain default
4045 // (which may be false).
4046 if (A->getOption().getID() == options::OPT_fno_math_errno ||
4047 A->getOption().getID() == options::OPT_ffast_math ||
4048 A->getOption().getID() == options::OPT_Ofast)
4049 MathErrno = false;
4050 else if (A->getOption().getID() == options::OPT_fmath_errno)
4051 MathErrno = true;
4052 }
Chandler Carruth3634c662012-04-26 02:10:51 +00004053 if (MathErrno)
4054 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004055
4056 // There are several flags which require disabling very specific
4057 // optimizations. Any of these being disabled forces us to turn off the
4058 // entire set of LLVM optimizations, so collect them through all the flag
4059 // madness.
4060 bool AssociativeMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004061 if (Arg *A = Args.getLastArg(
4062 options::OPT_ffast_math, FastMathAliasOption,
4063 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4064 options::OPT_fno_unsafe_math_optimizations,
4065 options::OPT_fassociative_math, options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004066 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4067 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004068 A->getOption().getID() != options::OPT_fno_associative_math)
4069 AssociativeMath = true;
4070 bool ReciprocalMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004071 if (Arg *A = Args.getLastArg(
4072 options::OPT_ffast_math, FastMathAliasOption,
4073 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4074 options::OPT_fno_unsafe_math_optimizations,
4075 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004076 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4077 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004078 A->getOption().getID() != options::OPT_fno_reciprocal_math)
4079 ReciprocalMath = true;
4080 bool SignedZeros = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004081 if (Arg *A = Args.getLastArg(
4082 options::OPT_ffast_math, FastMathAliasOption,
4083 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4084 options::OPT_fno_unsafe_math_optimizations,
4085 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004086 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4087 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004088 A->getOption().getID() != options::OPT_fsigned_zeros)
4089 SignedZeros = false;
4090 bool TrappingMath = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004091 if (Arg *A = Args.getLastArg(
4092 options::OPT_ffast_math, FastMathAliasOption,
4093 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4094 options::OPT_fno_unsafe_math_optimizations,
4095 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004096 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4097 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004098 A->getOption().getID() != options::OPT_ftrapping_math)
4099 TrappingMath = false;
4100 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
4101 !TrappingMath)
4102 CmdArgs.push_back("-menable-unsafe-fp-math");
4103
Sanjay Patel76c9e092015-01-23 16:40:50 +00004104 if (!SignedZeros)
4105 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00004106
Sanjay Patel359b1052015-04-09 15:03:23 +00004107 if (ReciprocalMath)
4108 CmdArgs.push_back("-freciprocal-math");
4109
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004110 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004111 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004112 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00004113 options::OPT_ffp_contract)) {
4114 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004115 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00004116 if (Val == "fast" || Val == "on" || Val == "off") {
4117 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
4118 } else {
4119 D.Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004120 << A->getOption().getName() << Val;
Lang Hamesaa53b932012-07-06 00:59:19 +00004121 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004122 } else if (A->getOption().matches(options::OPT_ffast_math) ||
4123 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00004124 // If fast-math is set then set the fp-contract mode to fast.
4125 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
4126 }
4127 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004128
Sanjay Patel2987c292015-06-11 14:53:41 +00004129 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00004130
Bob Wilson6a039162012-07-19 03:52:53 +00004131 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
4132 // and if we find them, tell the frontend to provide the appropriate
4133 // preprocessor macros. This is distinct from enabling any optimizations as
4134 // these options induce language changes which must survive serialization
4135 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004136 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
4137 options::OPT_fno_fast_math))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004138 if (!A->getOption().matches(options::OPT_fno_fast_math))
4139 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00004140 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
4141 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004142 if (A->getOption().matches(options::OPT_ffinite_math_only))
4143 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004144
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004145 // Decide whether to use verbose asm. Verbose assembly is the default on
4146 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004147 bool IsIntegratedAssemblerDefault =
4148 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004149 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004150 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004151 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004152 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004153
Rafael Espindolab8a12932015-05-22 20:44:03 +00004154 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
4155 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004156 CmdArgs.push_back("-no-integrated-as");
4157
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004158 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
4159 CmdArgs.push_back("-mdebug-pass");
4160 CmdArgs.push_back("Structure");
4161 }
4162 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
4163 CmdArgs.push_back("-mdebug-pass");
4164 CmdArgs.push_back("Arguments");
4165 }
4166
Justin Lebar710a35f2016-01-25 22:36:35 +00004167 // Enable -mconstructor-aliases except on darwin, where we have to work around
4168 // a linker bug (see <rdar://problem/7651567>), and CUDA device code, where
4169 // aliases aren't supported.
4170 if (!getToolChain().getTriple().isOSDarwin() &&
4171 !getToolChain().getTriple().isNVPTX())
John McCall8517abc2010-02-19 02:45:38 +00004172 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004173
John McCall7ef5cb32011-03-18 02:56:14 +00004174 // Darwin's kernel doesn't support guard variables; just die if we
4175 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00004176 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00004177 CmdArgs.push_back("-fforbid-guard-variables");
4178
Akira Hatanaka02028482015-11-12 17:21:22 +00004179 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
4180 false)) {
Douglas Gregordbe39272011-02-01 15:15:22 +00004181 CmdArgs.push_back("-mms-bitfields");
4182 }
John McCall8517abc2010-02-19 02:45:38 +00004183
Daniel Dunbar306945d2009-09-16 06:17:29 +00004184 // This is a coarse approximation of what llvm-gcc actually does, both
4185 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
4186 // complicated ways.
4187 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00004188 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
4189 options::OPT_fno_asynchronous_unwind_tables,
4190 (getToolChain().IsUnwindTablesDefault() ||
4191 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
4192 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00004193 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
4194 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004195 CmdArgs.push_back("-munwind-tables");
4196
Chandler Carruth05fb5852012-11-21 23:40:23 +00004197 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00004198
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004199 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
4200 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00004201 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004202 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00004203
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00004204 // FIXME: Handle -mtune=.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004205 (void)Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00004206
Benjamin Kramercf4371a2009-08-05 14:30:52 +00004207 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004208 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00004209 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00004210 }
4211
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004212 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00004213 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004214 if (!CPU.empty()) {
4215 CmdArgs.push_back("-target-cpu");
4216 CmdArgs.push_back(Args.MakeArgString(CPU));
4217 }
4218
Rafael Espindolaeb265472013-08-21 21:59:03 +00004219 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
4220 CmdArgs.push_back("-mfpmath");
4221 CmdArgs.push_back(A->getValue());
4222 }
4223
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004224 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00004225 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004226
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004227 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004228 switch (getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00004229 default:
4230 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00004231
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004232 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004233 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004234 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004235 case llvm::Triple::thumbeb:
Saleem Abdulrasoolce63ce92015-09-19 18:19:44 +00004236 // Use the effective triple, which takes into account the deployment target.
4237 AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004238 break;
4239
Tim Northover573cbee2014-05-24 12:52:07 +00004240 case llvm::Triple::aarch64:
4241 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00004242 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00004243 break;
4244
Eric Christopher0b26a612010-03-02 02:41:08 +00004245 case llvm::Triple::mips:
4246 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00004247 case llvm::Triple::mips64:
4248 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00004249 AddMIPSTargetArgs(Args, CmdArgs);
4250 break;
4251
Ulrich Weigand8afad612014-07-28 13:17:52 +00004252 case llvm::Triple::ppc:
4253 case llvm::Triple::ppc64:
4254 case llvm::Triple::ppc64le:
4255 AddPPCTargetArgs(Args, CmdArgs);
4256 break;
4257
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004258 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00004259 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00004260 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004261 AddSparcTargetArgs(Args, CmdArgs);
4262 break;
4263
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +00004264 case llvm::Triple::systemz:
4265 AddSystemZTargetArgs(Args, CmdArgs);
4266 break;
4267
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00004268 case llvm::Triple::x86:
4269 case llvm::Triple::x86_64:
4270 AddX86TargetArgs(Args, CmdArgs);
4271 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004272
Jacques Pienaard964cc22016-03-28 21:02:54 +00004273 case llvm::Triple::lanai:
4274 AddLanaiTargetArgs(Args, CmdArgs);
4275 break;
4276
Tony Linthicum76329bf2011-12-12 21:14:55 +00004277 case llvm::Triple::hexagon:
4278 AddHexagonTargetArgs(Args, CmdArgs);
4279 break;
Dan Gohmane3d71e12016-01-07 01:00:21 +00004280
4281 case llvm::Triple::wasm32:
4282 case llvm::Triple::wasm64:
4283 AddWebAssemblyTargetArgs(Args, CmdArgs);
4284 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00004285 }
4286
Douglas Katzman3459ce22015-10-08 04:24:12 +00004287 // The 'g' groups options involve a somewhat intricate sequence of decisions
4288 // about what to pass from the driver to the frontend, but by the time they
Paul Robinson0334a042015-12-19 19:41:48 +00004289 // reach cc1 they've been factored into three well-defined orthogonal choices:
Douglas Katzman3459ce22015-10-08 04:24:12 +00004290 // * what level of debug info to generate
4291 // * what dwarf version to write
Paul Robinson0334a042015-12-19 19:41:48 +00004292 // * what debugger tuning to use
Douglas Katzman3459ce22015-10-08 04:24:12 +00004293 // This avoids having to monkey around further in cc1 other than to disable
4294 // codeview if not running in a Windows environment. Perhaps even that
4295 // decision should be made in the driver as well though.
Paul Robinson0334a042015-12-19 19:41:48 +00004296 unsigned DwarfVersion = 0;
4297 llvm::DebuggerKind DebuggerTuning = getToolChain().getDefaultDebuggerTuning();
4298 // These two are potentially updated by AddClangCLArgs.
Benjamin Kramer8c305922016-02-02 11:06:51 +00004299 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo;
Douglas Katzman3459ce22015-10-08 04:24:12 +00004300 bool EmitCodeView = false;
4301
Hans Wennborg75958c42013-08-08 00:17:41 +00004302 // Add clang-cl arguments.
David Majnemercd5855e2016-02-29 01:40:36 +00004303 types::ID InputType = Input.getType();
Hans Wennborg75958c42013-08-08 00:17:41 +00004304 if (getToolChain().getDriver().IsCLMode())
David Majnemercd5855e2016-02-29 01:40:36 +00004305 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
Hans Wennborg75958c42013-08-08 00:17:41 +00004306
Daniel Dunbar976a2f52010-08-11 23:07:47 +00004307 // Pass the linker version in use.
4308 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4309 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00004310 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00004311 }
4312
Eric Christopherb7d97e92013-04-03 01:58:53 +00004313 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00004314 CmdArgs.push_back("-momit-leaf-frame-pointer");
4315
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00004316 // Explicitly error on some things we know we don't support and can't just
4317 // ignore.
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00004318 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4319 Arg *Unsupported;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004320 if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004321 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00004322 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4323 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004324 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004325 << Unsupported->getOption().getName();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00004326 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00004327 }
4328
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004329 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00004330 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00004331 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00004332 CmdArgs.push_back("-header-include-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004333 CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
4334 : "-");
Daniel Dunbarac540b32011-02-02 21:11:35 +00004335 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004336 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00004337 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004338
Chad Rosierbe10f982011-08-02 17:58:04 +00004339 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00004340 CmdArgs.push_back("-diagnostic-log-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004341 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
4342 : "-");
Daniel Dunbar529c03b2011-04-07 18:01:20 +00004343 }
4344
Rafael Espindola08a692a2010-03-07 04:46:18 +00004345 Args.ClaimAllArgs(options::OPT_g_Group);
David Blaikiece3e7a62015-07-30 21:42:22 +00004346 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00004347 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Paul Robinson0334a042015-12-19 19:41:48 +00004348 // If the last option explicitly specified a debug-info level, use it.
4349 if (A->getOption().matches(options::OPT_gN_Group)) {
4350 DebugInfoKind = DebugLevelToInfoKind(*A);
4351 // If you say "-gsplit-dwarf -gline-tables-only", -gsplit-dwarf loses.
4352 // But -gsplit-dwarf is not a g_group option, hence we have to check the
4353 // order explicitly. (If -gsplit-dwarf wins, we fix DebugInfoKind later.)
Benjamin Kramer8c305922016-02-02 11:06:51 +00004354 if (SplitDwarfArg && DebugInfoKind < codegenoptions::LimitedDebugInfo &&
Paul Robinson0334a042015-12-19 19:41:48 +00004355 A->getIndex() > SplitDwarfArg->getIndex())
4356 SplitDwarfArg = nullptr;
4357 } else
4358 // For any other 'g' option, use Limited.
Benjamin Kramer8c305922016-02-02 11:06:51 +00004359 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00004360 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004361
Paul Robinson0334a042015-12-19 19:41:48 +00004362 // If a debugger tuning argument appeared, remember it.
4363 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
4364 options::OPT_ggdbN_Group)) {
4365 if (A->getOption().matches(options::OPT_glldb))
4366 DebuggerTuning = llvm::DebuggerKind::LLDB;
4367 else if (A->getOption().matches(options::OPT_gsce))
4368 DebuggerTuning = llvm::DebuggerKind::SCE;
4369 else
4370 DebuggerTuning = llvm::DebuggerKind::GDB;
4371 }
4372
4373 // If a -gdwarf argument appeared, remember it.
Douglas Katzman3459ce22015-10-08 04:24:12 +00004374 if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
Eric Christopher3cb592d2015-12-28 19:58:44 +00004375 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
Douglas Katzman3459ce22015-10-08 04:24:12 +00004376 DwarfVersion = DwarfVersionNum(A->getSpelling());
4377
Reid Kleckner124955a2015-08-05 18:51:13 +00004378 // Forward -gcodeview.
Douglas Katzman3459ce22015-10-08 04:24:12 +00004379 // 'EmitCodeView might have been set by CL-compatibility argument parsing.
4380 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
4381 // DwarfVersion remains at 0 if no explicit choice was made.
4382 CmdArgs.push_back("-gcodeview");
4383 } else if (DwarfVersion == 0 &&
Benjamin Kramer8c305922016-02-02 11:06:51 +00004384 DebugInfoKind != codegenoptions::NoDebugInfo) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00004385 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
4386 }
Reid Kleckner124955a2015-08-05 18:51:13 +00004387
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00004388 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
4389 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004390
4391 // PS4 defaults to no column info
Diego Novillo94b276d2014-07-10 23:29:28 +00004392 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004393 /*Default=*/ !IsPS4CPU))
Eric Christophera2f7eb72012-10-18 21:52:18 +00004394 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00004395
Eric Christopher138c32b2013-09-13 22:37:55 +00004396 // FIXME: Move backend command line options to the module.
Adrian Prantl6b21ab22015-08-27 19:46:20 +00004397 if (Args.hasArg(options::OPT_gmodules)) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004398 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Adrian Prantl6b21ab22015-08-27 19:46:20 +00004399 CmdArgs.push_back("-dwarf-ext-refs");
4400 CmdArgs.push_back("-fmodule-format=obj");
4401 }
4402
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00004403 // -gsplit-dwarf should turn on -g and enable the backend dwarf
4404 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00004405 // FIXME: Currently only works on Linux.
David Blaikiece3e7a62015-07-30 21:42:22 +00004406 if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004407 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00004408 CmdArgs.push_back("-backend-option");
4409 CmdArgs.push_back("-split-dwarf=Enable");
4410 }
4411
Douglas Katzman3459ce22015-10-08 04:24:12 +00004412 // After we've dealt with all combinations of things that could
4413 // make DebugInfoKind be other than None or DebugLineTablesOnly,
4414 // figure out if we need to "upgrade" it to standalone debug info.
4415 // We parse these two '-f' options whether or not they will be used,
4416 // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"
4417 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
4418 options::OPT_fno_standalone_debug,
4419 getToolChain().GetDefaultStandaloneDebug());
Benjamin Kramer8c305922016-02-02 11:06:51 +00004420 if (DebugInfoKind == codegenoptions::LimitedDebugInfo && NeedFullDebug)
4421 DebugInfoKind = codegenoptions::FullDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00004422 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
4423 DebuggerTuning);
Douglas Katzman3459ce22015-10-08 04:24:12 +00004424
Eric Christopher138c32b2013-09-13 22:37:55 +00004425 // -ggnu-pubnames turns on gnu style pubnames in the backend.
4426 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
4427 CmdArgs.push_back("-backend-option");
4428 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
4429 }
Eric Christophereec89c22013-06-18 00:03:50 +00004430
Eric Christopher0d403d22014-02-14 01:27:03 +00004431 // -gdwarf-aranges turns on the emission of the aranges section in the
4432 // backend.
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004433 // Always enabled on the PS4.
4434 if (Args.hasArg(options::OPT_gdwarf_aranges) || IsPS4CPU) {
Eric Christopher0d403d22014-02-14 01:27:03 +00004435 CmdArgs.push_back("-backend-option");
4436 CmdArgs.push_back("-generate-arange-section");
4437 }
4438
David Blaikief36d9ba2014-01-27 18:52:43 +00004439 if (Args.hasFlag(options::OPT_fdebug_types_section,
4440 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00004441 CmdArgs.push_back("-backend-option");
4442 CmdArgs.push_back("-generate-type-units");
4443 }
Eric Christophereec89c22013-06-18 00:03:50 +00004444
Dan Gohmana5b804b2016-01-07 00:50:27 +00004445 // CloudABI and WebAssembly use -ffunction-sections and -fdata-sections by
4446 // default.
4447 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI ||
4448 Triple.getArch() == llvm::Triple::wasm32 ||
4449 Triple.getArch() == llvm::Triple::wasm64;
Ed Schouten6e576152015-03-26 17:50:28 +00004450
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004451 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00004452 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004453 CmdArgs.push_back("-ffunction-sections");
4454 }
4455
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004456 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4457 UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004458 CmdArgs.push_back("-fdata-sections");
4459 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00004460
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00004461 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00004462 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00004463 CmdArgs.push_back("-fno-unique-section-names");
4464
Chris Lattner3c77a352010-06-22 00:03:40 +00004465 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
4466
Diego Novilloa0545962015-07-10 18:00:07 +00004467 addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
Nick Lewycky480cb992011-05-04 20:46:58 +00004468
Paul Robinsond083b9a2015-12-16 17:25:27 +00004469 // Add runtime flag for PS4 when PGO or Coverage are enabled.
4470 if (getToolChain().getTriple().isPS4CPU())
4471 addPS4ProfileRTArgs(getToolChain(), Args, CmdArgs);
4472
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00004473 // Pass options for controlling the default header search paths.
4474 if (Args.hasArg(options::OPT_nostdinc)) {
4475 CmdArgs.push_back("-nostdsysteminc");
4476 CmdArgs.push_back("-nobuiltininc");
4477 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00004478 if (Args.hasArg(options::OPT_nostdlibinc))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004479 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00004480 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4481 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4482 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004483
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00004484 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00004485 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00004486 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00004487
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00004488 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4489
Ted Kremenekf7639e12012-03-06 20:06:33 +00004490 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00004491 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004492 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004493 options::OPT_ccc_arcmt_modify,
4494 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004495 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00004496 switch (A->getOption().getID()) {
4497 default:
4498 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004499 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00004500 CmdArgs.push_back("-arcmt-check");
4501 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004502 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00004503 CmdArgs.push_back("-arcmt-modify");
4504 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004505 case options::OPT_ccc_arcmt_migrate:
4506 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004507 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004508 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00004509
4510 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
4511 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004512 break;
John McCalld70fb982011-06-15 23:25:17 +00004513 }
4514 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00004515 } else {
4516 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
4517 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
4518 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00004519 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004520
Ted Kremenekf7639e12012-03-06 20:06:33 +00004521 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
4522 if (ARCMTEnabled) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004523 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4524 << "-ccc-arcmt-migrate";
Ted Kremenekf7639e12012-03-06 20:06:33 +00004525 }
4526 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004527 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00004528
4529 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004530 options::OPT_objcmt_migrate_subscripting,
4531 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004532 // None specified, means enable them all.
4533 CmdArgs.push_back("-objcmt-migrate-literals");
4534 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004535 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004536 } else {
4537 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4538 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004539 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004540 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004541 } else {
4542 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4543 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4544 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4545 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4546 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4547 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00004548 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004549 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4550 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4551 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4552 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4553 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4554 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4555 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00004556 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00004557 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004558 }
4559
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004560 // Add preprocessing options like -I, -D, etc. if we are using the
4561 // preprocessor.
4562 //
4563 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004564 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Artem Belevichfa11ab52015-11-17 22:28:46 +00004565 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs,
4566 AuxToolChain);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004567
Rafael Espindolaa7431922011-07-21 23:40:37 +00004568 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
4569 // that "The compiler can only warn and ignore the option if not recognized".
4570 // When building with ccache, it will pass -D options to clang even on
4571 // preprocessed inputs and configure concludes that -fPIC is not supported.
4572 Args.ClaimAllArgs(options::OPT_D);
4573
Alp Toker7874bdc2013-11-15 20:40:58 +00004574 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00004575 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4576 if (A->getOption().matches(options::OPT_O4)) {
4577 CmdArgs.push_back("-O3");
4578 D.Diag(diag::warn_O4_is_O3);
4579 } else {
4580 A->render(Args, CmdArgs);
4581 }
4582 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004583
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004584 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00004585 for (const Arg *A :
4586 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4587 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Douglas Katzman8b50e012015-08-05 18:03:47 +00004588 A->claim();
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004589 }
4590
Rafael Espindola577637a2015-01-03 00:06:04 +00004591 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00004592
Richard Smith3be1cb22014-08-07 00:24:21 +00004593 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00004594 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00004595 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
4596 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00004597 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004598 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004599
4600 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00004601 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004602 //
4603 // If a std is supplied, only add -trigraphs if it follows the
4604 // option.
David Majnemer8db91762015-05-18 04:49:30 +00004605 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004606 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4607 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00004608 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004609 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00004610 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004611 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004612 else
4613 Std->render(Args, CmdArgs);
4614
Nico Weber00721502014-12-23 22:32:37 +00004615 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004616 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00004617 options::OPT_ftrigraphs,
4618 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004619 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004620 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004621 } else {
4622 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00004623 //
4624 // FIXME: Clang doesn't correctly handle -std= when the input language
4625 // doesn't match. For the time being just ignore this for C++ inputs;
4626 // eventually we want to do all the standard defaulting here instead of
4627 // splitting it between the driver and clang -cc1.
4628 if (!types::isCXX(InputType))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004629 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
4630 /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004631 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00004632 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00004633
Nico Weber00721502014-12-23 22:32:37 +00004634 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4635 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004636 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004637
Richard Smith282b4492013-09-04 22:50:31 +00004638 // GCC's behavior for -Wwrite-strings is a bit strange:
4639 // * In C, this "warning flag" changes the types of string literals from
4640 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
4641 // for the discarded qualifier.
4642 // * In C++, this is just a normal warning flag.
4643 //
4644 // Implementing this warning correctly in C is hard, so we follow GCC's
4645 // behavior for now. FIXME: Directly diagnose uses of a string literal as
4646 // a non-const char* in C, rather than using this crude hack.
4647 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00004648 // FIXME: This should behave just like a warning flag, and thus should also
4649 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
4650 Arg *WriteStrings =
4651 Args.getLastArg(options::OPT_Wwrite_strings,
4652 options::OPT_Wno_write_strings, options::OPT_w);
4653 if (WriteStrings &&
4654 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00004655 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00004656 }
4657
Chandler Carruth61fbf622011-04-23 09:27:53 +00004658 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00004659 // during C++ compilation, which it is by default. GCC keeps this define even
4660 // in the presence of '-w', match this behavior bug-for-bug.
4661 if (types::isCXX(InputType) &&
4662 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4663 true)) {
4664 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00004665 }
4666
Chandler Carruthe0391482010-05-22 02:21:53 +00004667 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
4668 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4669 if (Asm->getOption().matches(options::OPT_fasm))
4670 CmdArgs.push_back("-fgnu-keywords");
4671 else
4672 CmdArgs.push_back("-fno-gnu-keywords");
4673 }
4674
Nick Lewycky1d617ac2011-10-17 23:05:52 +00004675 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
4676 CmdArgs.push_back("-fno-dwarf-directory-asm");
4677
Daniel Dunbare246fbe2013-04-16 18:21:19 +00004678 if (ShouldDisableAutolink(Args, getToolChain()))
4679 CmdArgs.push_back("-fno-autolink");
4680
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004681 // Add in -fdebug-compilation-dir if necessary.
4682 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00004683
Saleem Abdulrasool436256a2015-10-12 20:21:08 +00004684 for (const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
4685 StringRef Map = A->getValue();
4686 if (Map.find('=') == StringRef::npos)
4687 D.Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
4688 else
4689 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
4690 A->claim();
4691 }
4692
Richard Smith9a568822011-11-21 19:36:32 +00004693 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4694 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004695 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004696 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004697 }
4698
Richard Smith79c927b2013-11-06 19:31:51 +00004699 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4700 CmdArgs.push_back("-foperator-arrow-depth");
4701 CmdArgs.push_back(A->getValue());
4702 }
4703
Richard Smith9a568822011-11-21 19:36:32 +00004704 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4705 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004706 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00004707 }
4708
Richard Smitha3d3bd22013-05-08 02:12:03 +00004709 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4710 CmdArgs.push_back("-fconstexpr-steps");
4711 CmdArgs.push_back(A->getValue());
4712 }
4713
Richard Smithb3a14522013-02-22 01:59:51 +00004714 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4715 CmdArgs.push_back("-fbracket-depth");
4716 CmdArgs.push_back(A->getValue());
4717 }
4718
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00004719 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4720 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004721 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004722 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004723 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
4724 } else
4725 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00004726 }
4727
Michael J. Spencer929fccd2012-10-22 22:13:48 +00004728 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00004729 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00004730
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004731 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4732 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00004733 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004734 }
David Chisnall5778fce2009-08-31 16:41:57 +00004735
Chris Lattnere23003d2010-01-09 21:54:33 +00004736 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4737 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00004738 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00004739 }
4740
Chris Lattnerb35583d2010-04-07 20:49:23 +00004741 CmdArgs.push_back("-ferror-limit");
4742 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00004743 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00004744 else
4745 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00004746
Chandler Carrutha77a7272010-05-06 04:55:18 +00004747 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4748 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004749 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004750 }
4751
4752 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4753 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004754 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004755 }
4756
Richard Smithf6f003a2011-12-16 19:06:07 +00004757 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4758 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004759 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00004760 }
4761
Nick Lewycky24653262014-12-16 21:39:02 +00004762 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4763 CmdArgs.push_back("-fspell-checking-limit");
4764 CmdArgs.push_back(A->getValue());
4765 }
4766
Daniel Dunbar2c978472009-11-04 06:24:47 +00004767 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00004768 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00004769 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004770 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00004771 } else {
4772 // If -fmessage-length=N was not specified, determine whether this is a
4773 // terminal and, if so, implicitly define -fmessage-length appropriately.
4774 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004775 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00004776 }
4777
John McCallb4a99d32013-02-19 01:57:35 +00004778 // -fvisibility= and -fvisibility-ms-compat are of a piece.
4779 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4780 options::OPT_fvisibility_ms_compat)) {
4781 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4782 CmdArgs.push_back("-fvisibility");
4783 CmdArgs.push_back(A->getValue());
4784 } else {
4785 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4786 CmdArgs.push_back("-fvisibility");
4787 CmdArgs.push_back("hidden");
4788 CmdArgs.push_back("-ftype-visibility");
4789 CmdArgs.push_back("default");
4790 }
Daniel Dunbare357d562009-12-03 18:42:11 +00004791 }
4792
Douglas Gregor08329632010-06-15 17:05:35 +00004793 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004794
Hans Wennborgf60f6af2012-06-28 08:01:44 +00004795 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4796
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004797 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00004798 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
4799 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004800 CmdArgs.push_back("-ffreestanding");
4801
Daniel Dunbare357d562009-12-03 18:42:11 +00004802 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004803 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004804 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Eric Christopher86050822011-10-25 07:13:06 +00004805 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004806 // Emulated TLS is enabled by default on Android, and can be enabled manually
4807 // with -femulated-tls.
NAKAMURA Takumi33ff1dd2016-01-16 03:44:52 +00004808 bool EmulatedTLSDefault = Triple.isAndroid() || Triple.isWindowsCygwinEnvironment();
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004809 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
4810 EmulatedTLSDefault))
4811 CmdArgs.push_back("-femulated-tls");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004812 // AltiVec-like language extensions aren't relevant for assembling.
4813 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) {
Bill Schmidtb3b804e2013-07-03 15:36:02 +00004814 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004815 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4816 }
Richard Trieu91844232012-06-26 18:18:47 +00004817 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4818 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00004819
Alexey Bataevdb390212015-05-20 04:24:19 +00004820 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004821 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4822 options::OPT_fno_openmp, false))
4823 switch (getOpenMPRuntime(getToolChain(), Args)) {
4824 case OMPRT_OMP:
4825 case OMPRT_IOMP5:
4826 // Clang can generate useful OpenMP code for these two runtime libraries.
4827 CmdArgs.push_back("-fopenmp");
Samuel Antaof8b50122015-07-13 22:54:53 +00004828
4829 // If no option regarding the use of TLS in OpenMP codegeneration is
4830 // given, decide a default based on the target. Otherwise rely on the
4831 // options and pass the right information to the frontend.
4832 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
Alexey Bataev6a43c002015-09-10 12:06:58 +00004833 options::OPT_fnoopenmp_use_tls, /*Default=*/true))
Samuel Antaof8b50122015-07-13 22:54:53 +00004834 CmdArgs.push_back("-fnoopenmp-use-tls");
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004835 break;
4836 default:
4837 // By default, if Clang doesn't know how to generate useful OpenMP code
4838 // for a specific runtime library, we just don't pass the '-fopenmp' flag
4839 // down to the actual compilation.
4840 // FIXME: It would be better to have a mode which *only* omits IR
4841 // generation based on the OpenMP support so that we get consistent
4842 // semantic analysis, etc.
4843 break;
4844 }
Alexey Bataevdb390212015-05-20 04:24:19 +00004845
Peter Collingbourne32701642013-11-01 18:16:25 +00004846 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
Peter Collingbourne581f4382015-07-02 01:48:12 +00004847 Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
Richard Smith52be6192012-11-05 22:04:41 +00004848
Eric Christopher459d2712013-02-19 06:16:53 +00004849 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004850 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4851 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4852 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4853 Arch == llvm::Triple::ppc64le))
4854 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4855 << "ppc/ppc64/ppc64le";
4856 }
Chad Rosier864dfe12012-03-13 23:45:51 +00004857
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004858 // -fzvector is incompatible with -faltivec.
4859 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4860 if (Args.hasArg(options::OPT_faltivec))
4861 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4862 << "-faltivec";
4863
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004864 if (getToolChain().SupportsProfiling())
4865 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00004866
4867 // -flax-vector-conversions is default.
4868 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4869 options::OPT_fno_lax_vector_conversions))
4870 CmdArgs.push_back("-fno-lax-vector-conversions");
4871
John Brawna7b4ec02015-08-10 11:11:28 +00004872 if (Args.getLastArg(options::OPT_fapple_kext) ||
4873 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004874 CmdArgs.push_back("-fapple-kext");
4875
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00004876 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00004877 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00004878 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004879 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4880 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00004881
4882 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4883 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00004884 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00004885 }
4886
Bob Wilson14adb362012-02-03 06:27:22 +00004887 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00004888
Chandler Carruth6e501032011-03-27 00:04:55 +00004889 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4890 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004891 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
Chandler Carruth6e501032011-03-27 00:04:55 +00004892 if (A->getOption().matches(options::OPT_fwrapv))
4893 CmdArgs.push_back("-fwrapv");
4894 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4895 options::OPT_fno_strict_overflow)) {
4896 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4897 CmdArgs.push_back("-fwrapv");
4898 }
Hal Finkelce0697f2013-11-17 16:03:29 +00004899
4900 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4901 options::OPT_fno_reroll_loops))
4902 if (A->getOption().matches(options::OPT_freroll_loops))
4903 CmdArgs.push_back("-freroll-loops");
4904
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004905 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00004906 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4907 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004908
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004909 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4910
Daniel Dunbar4930e332009-11-17 08:07:36 +00004911 // -stack-protector=0 is default.
4912 unsigned StackProtectorLevel = 0;
Evgeniy Stepanov368d3072016-04-11 22:27:55 +00004913 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4914 options::OPT_fstack_protector_all,
4915 options::OPT_fstack_protector_strong,
4916 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004917 if (A->getOption().matches(options::OPT_fstack_protector)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004918 StackProtectorLevel = std::max<unsigned>(
4919 LangOptions::SSPOn,
4920 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
Rafael Espindolace5c6092014-05-22 22:57:39 +00004921 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004922 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004923 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004924 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004925 } else {
4926 StackProtectorLevel =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004927 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
Nico Weberdd473632011-08-23 07:38:27 +00004928 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004929 if (StackProtectorLevel) {
4930 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004931 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004932 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004933
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004934 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004935 for (const Arg *A : Args.filtered(options::OPT__param)) {
4936 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004937 if (Str.startswith("ssp-buffer-size=")) {
4938 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004939 CmdArgs.push_back("-stack-protector-buffer-size");
4940 // FIXME: Verify the argument is a valid integer.
4941 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004942 }
Sean Silva14facf32015-06-09 01:57:17 +00004943 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004944 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004945 }
4946
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004947 // Translate -mstackrealign
4948 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
Akira Hatanakaaecca042015-09-11 18:55:09 +00004949 false))
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004950 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004951
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004952 if (Args.hasArg(options::OPT_mstack_alignment)) {
4953 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4954 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00004955 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004956
Hans Wennborg77dc2362015-01-20 19:45:50 +00004957 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4958 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4959
4960 if (!Size.empty())
4961 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4962 else
4963 CmdArgs.push_back("-mstack-probe-size=0");
4964 }
4965
Oliver Stannarddc2854c2015-09-03 12:40:58 +00004966 switch (getToolChain().getArch()) {
4967 case llvm::Triple::aarch64:
4968 case llvm::Triple::aarch64_be:
4969 case llvm::Triple::arm:
4970 case llvm::Triple::armeb:
4971 case llvm::Triple::thumb:
4972 case llvm::Triple::thumbeb:
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004973 CmdArgs.push_back("-fallow-half-arguments-and-returns");
Oliver Stannarddc2854c2015-09-03 12:40:58 +00004974 break;
4975
4976 default:
4977 break;
4978 }
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004979
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004980 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4981 options::OPT_mno_restrict_it)) {
4982 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4983 CmdArgs.push_back("-backend-option");
4984 CmdArgs.push_back("-arm-restrict-it");
4985 } else {
4986 CmdArgs.push_back("-backend-option");
4987 CmdArgs.push_back("-arm-no-restrict-it");
4988 }
James Y Knight2db38f32015-08-15 03:45:25 +00004989 } else if (Triple.isOSWindows() &&
4990 (Triple.getArch() == llvm::Triple::arm ||
4991 Triple.getArch() == llvm::Triple::thumb)) {
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00004992 // Windows on ARM expects restricted IT blocks
4993 CmdArgs.push_back("-backend-option");
4994 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004995 }
4996
Daniel Dunbard18049a2009-04-07 21:16:11 +00004997 // Forward -f options with positive and negative forms; we translate
4998 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00004999 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
5000 StringRef fname = A->getValue();
5001 if (!llvm::sys::fs::exists(fname))
5002 D.Diag(diag::err_drv_no_such_file) << fname;
5003 else
5004 A->render(Args, CmdArgs);
5005 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00005006
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00005007 // -fbuiltin is default unless -mkernel is used.
5008 bool UseBuiltins =
5009 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
5010 !Args.hasArg(options::OPT_mkernel));
5011 if (!UseBuiltins)
Daniel Dunbar484afa22009-11-19 04:55:23 +00005012 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00005013
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00005014 // -ffreestanding implies -fno-builtin.
5015 if (Args.hasArg(options::OPT_ffreestanding))
5016 UseBuiltins = false;
5017
5018 // Process the -fno-builtin-* options.
5019 for (const auto &Arg : Args) {
5020 const Option &O = Arg->getOption();
5021 if (!O.matches(options::OPT_fno_builtin_))
5022 continue;
5023
5024 Arg->claim();
5025 // If -fno-builtin is specified, then there's no need to pass the option to
5026 // the frontend.
5027 if (!UseBuiltins)
5028 continue;
5029
5030 StringRef FuncName = Arg->getValue();
5031 CmdArgs.push_back(Args.MakeArgString("-fno-builtin-" + FuncName));
5032 }
5033
Nuno Lopes13c88c72009-12-16 16:59:22 +00005034 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5035 options::OPT_fno_assume_sane_operator_new))
5036 CmdArgs.push_back("-fno-assume-sane-operator-new");
5037
Daniel Dunbar4930e332009-11-17 08:07:36 +00005038 // -fblocks=0 is default.
5039 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00005040 getToolChain().IsBlocksDefault()) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005041 (Args.hasArg(options::OPT_fgnu_runtime) &&
5042 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
5043 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00005044 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00005045
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005046 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
John McCall7959fee2011-09-09 20:41:01 +00005047 !getToolChain().hasBlocksRuntime())
5048 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00005049 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00005050
Richard Smith47972af2015-06-16 00:08:24 +00005051 // -fmodules enables the use of precompiled modules (off by default).
Richard Smithffb65082014-09-30 23:10:19 +00005052 // Users can pass -fno-cxx-modules to turn off modules support for
Richard Smith47972af2015-06-16 00:08:24 +00005053 // C++/Objective-C++ programs.
Douglas Gregorc60437f2013-01-16 01:23:41 +00005054 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00005055 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005056 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
5057 options::OPT_fno_cxx_modules, true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00005058 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00005059 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00005060 HaveModules = true;
5061 }
5062 }
5063
Richard Smith47972af2015-06-16 00:08:24 +00005064 // -fmodule-maps enables implicit reading of module map files. By default,
5065 // this is enabled if we are using precompiled modules.
Richard Smithcf18b792015-06-16 00:20:23 +00005066 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
5067 options::OPT_fno_implicit_module_maps, HaveModules)) {
Richard Smith47972af2015-06-16 00:08:24 +00005068 CmdArgs.push_back("-fimplicit-module-maps");
Daniel Jasper07e6c402013-08-05 20:26:17 +00005069 }
5070
Daniel Jasperac42b752013-10-21 06:34:34 +00005071 // -fmodules-decluse checks that modules used are declared so (off by
5072 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00005073 if (Args.hasFlag(options::OPT_fmodules_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005074 options::OPT_fno_modules_decluse, false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00005075 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00005076 }
5077
Daniel Jasper962b38e2014-04-11 11:47:45 +00005078 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
5079 // all #included headers are part of modules.
5080 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005081 options::OPT_fno_modules_strict_decluse, false)) {
Daniel Jasper962b38e2014-04-11 11:47:45 +00005082 CmdArgs.push_back("-fmodules-strict-decluse");
5083 }
5084
Manuel Klimekd2e8b042015-02-20 11:44:41 +00005085 // -fno-implicit-modules turns off implicitly compiling modules on demand.
5086 if (!Args.hasFlag(options::OPT_fimplicit_modules,
5087 options::OPT_fno_implicit_modules)) {
5088 CmdArgs.push_back("-fno-implicit-modules");
Richard Smith8d83d6d2016-03-21 19:06:06 +00005089 } else if (HaveModules) {
5090 // -fmodule-cache-path specifies where our implicitly-built module files
5091 // should be written.
5092 SmallString<128> Path;
5093 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
5094 Path = A->getValue();
Justin Bognera88f0122014-06-20 22:59:50 +00005095 if (C.isForDiagnostics()) {
5096 // When generating crash reports, we want to emit the modules along with
5097 // the reproduction sources, so we ignore any provided module path.
Daniel Jasper7450f912015-07-10 08:25:54 +00005098 Path = Output.getFilename();
5099 llvm::sys::path::replace_extension(Path, ".cache");
5100 llvm::sys::path::append(Path, "modules");
5101 } else if (Path.empty()) {
Justin Bognera88f0122014-06-20 22:59:50 +00005102 // No module path was provided: use the default.
Renato Golin7c542b42015-07-27 23:44:45 +00005103 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Path);
Daniel Jasper7450f912015-07-10 08:25:54 +00005104 llvm::sys::path::append(Path, "org.llvm.clang.");
5105 appendUserToPath(Path);
5106 llvm::sys::path::append(Path, "ModuleCache");
Justin Bognera88f0122014-06-20 22:59:50 +00005107 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00005108 const char Arg[] = "-fmodules-cache-path=";
Daniel Jasper7450f912015-07-10 08:25:54 +00005109 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
5110 CmdArgs.push_back(Args.MakeArgString(Path));
Justin Bognera88f0122014-06-20 22:59:50 +00005111 }
5112
Richard Smith8d83d6d2016-03-21 19:06:06 +00005113 // -fmodule-name specifies the module that is currently being built (or
5114 // used for header checking by -fmodule-maps).
5115 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
5116
5117 // -fmodule-map-file can be used to specify files containing module
5118 // definitions.
5119 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
5120
5121 // -fmodule-file can be used to specify files containing precompiled modules.
5122 if (HaveModules)
5123 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
5124 else
5125 Args.ClaimAllArgs(options::OPT_fmodule_file);
5126
Justin Bognera88f0122014-06-20 22:59:50 +00005127 // When building modules and generating crashdumps, we need to dump a module
5128 // dependency VFS alongside the output.
5129 if (HaveModules && C.isForDiagnostics()) {
5130 SmallString<128> VFSDir(Output.getFilename());
5131 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00005132 // Add the cache directory as a temp so the crash diagnostics pick it up.
5133 C.addTempFile(Args.MakeArgString(VFSDir));
5134
Justin Bognera88f0122014-06-20 22:59:50 +00005135 llvm::sys::path::append(VFSDir, "vfs");
5136 CmdArgs.push_back("-module-dependency-dir");
5137 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00005138 }
5139
Richard Smith9887d792014-10-17 01:42:53 +00005140 if (HaveModules)
5141 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00005142
Douglas Gregor35b04d62013-02-07 19:01:24 +00005143 // Pass through all -fmodules-ignore-macro arguments.
5144 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00005145 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
5146 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00005147
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005148 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
5149
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005150 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
5151 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
5152 D.Diag(diag::err_drv_argument_not_allowed_with)
5153 << A->getAsString(Args) << "-fbuild-session-timestamp";
5154
5155 llvm::sys::fs::file_status Status;
5156 if (llvm::sys::fs::status(A->getValue(), Status))
5157 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00005158 CmdArgs.push_back(Args.MakeArgString(
5159 "-fbuild-session-timestamp=" +
5160 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005161 }
5162
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005163 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005164 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
5165 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005166 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
5167
5168 Args.AddLastArg(CmdArgs,
5169 options::OPT_fmodules_validate_once_per_build_session);
5170 }
5171
Ben Langmuirdcf73862014-03-12 00:06:17 +00005172 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
5173
John McCalldfea9982010-04-09 19:12:06 +00005174 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00005175 if (Args.hasFlag(options::OPT_fno_access_control,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005176 options::OPT_faccess_control, false))
John McCall3155f572010-04-09 19:03:51 +00005177 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00005178
Anders Carlssond470fef2010-11-21 00:09:52 +00005179 // -felide-constructors is the default.
5180 if (Args.hasFlag(options::OPT_fno_elide_constructors,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005181 options::OPT_felide_constructors, false))
Anders Carlssond470fef2010-11-21 00:09:52 +00005182 CmdArgs.push_back("-fno-elide-constructors");
5183
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00005184 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00005185
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00005186 if (KernelOrKext || (types::isCXX(InputType) &&
5187 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
5188 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00005189 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00005190
Tony Linthicum76329bf2011-12-12 21:14:55 +00005191 // -fshort-enums=0 is default for all architectures except Hexagon.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005192 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
5193 getToolChain().getArch() == llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00005194 CmdArgs.push_back("-fshort-enums");
5195
Daniel Dunbard609b7b2009-11-17 06:37:03 +00005196 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00005197 if (Arg *A = Args.getLastArg(
5198 options::OPT_fsigned_char, options::OPT_fno_signed_char,
5199 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
5200 if (A->getOption().matches(options::OPT_funsigned_char) ||
5201 A->getOption().matches(options::OPT_fno_signed_char)) {
5202 CmdArgs.push_back("-fno-signed-char");
5203 }
5204 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00005205 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00005206 }
Eli Friedman327f0b52009-06-05 07:21:14 +00005207
Daniel Dunbarfe06df42010-03-20 04:15:41 +00005208 // -fuse-cxa-atexit is default.
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00005209 if (!Args.hasFlag(
5210 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
5211 !IsWindowsCygnus && !IsWindowsGNU &&
5212 getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
5213 getToolChain().getArch() != llvm::Triple::hexagon &&
5214 getToolChain().getArch() != llvm::Triple::xcore &&
5215 ((getToolChain().getTriple().getVendor() !=
5216 llvm::Triple::MipsTechnologies) ||
5217 getToolChain().getTriple().hasEnvironment())) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00005218 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00005219 CmdArgs.push_back("-fno-use-cxa-atexit");
5220
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00005221 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00005222 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00005223 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00005224 CmdArgs.push_back("-fms-extensions");
5225
Reid Kleckner1df0fea2015-02-26 00:17:25 +00005226 // -fno-use-line-directives is default.
5227 if (Args.hasFlag(options::OPT_fuse_line_directives,
5228 options::OPT_fno_use_line_directives, false))
5229 CmdArgs.push_back("-fuse-line-directives");
5230
Francois Pichet1b4f1632011-09-17 04:32:15 +00005231 // -fms-compatibility=0 is default.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005232 if (Args.hasFlag(options::OPT_fms_compatibility,
Douglas Gregor2b4907e2011-10-24 15:49:38 +00005233 options::OPT_fno_ms_compatibility,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005234 (IsWindowsMSVC &&
5235 Args.hasFlag(options::OPT_fms_extensions,
5236 options::OPT_fno_ms_extensions, true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00005237 CmdArgs.push_back("-fms-compatibility");
5238
David Majnemerc371ff02015-03-22 08:39:22 +00005239 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00005240 VersionTuple MSVT = visualstudio::getMSVCVersion(
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00005241 &D, getToolChain(), getToolChain().getTriple(), Args, IsWindowsMSVC);
David Majnemere11d3732015-06-08 00:22:46 +00005242 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00005243 CmdArgs.push_back(
5244 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00005245
David Majnemer8db91762015-05-18 04:49:30 +00005246 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
5247 if (ImplyVCPPCXXVer) {
5248 if (IsMSVC2015Compatible)
5249 CmdArgs.push_back("-std=c++14");
5250 else
5251 CmdArgs.push_back("-std=c++11");
5252 }
5253
Eric Christopher5ecce122013-02-18 00:38:31 +00005254 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00005255 if (Args.hasFlag(options::OPT_fborland_extensions,
5256 options::OPT_fno_borland_extensions, false))
5257 CmdArgs.push_back("-fborland-extensions");
5258
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00005259 // -fno-declspec is default, except for PS4.
5260 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
5261 getToolChain().getTriple().isPS4()))
5262 CmdArgs.push_back("-fdeclspec");
5263 else if (Args.hasArg(options::OPT_fno_declspec))
5264 CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec.
5265
David Majnemerc371ff02015-03-22 08:39:22 +00005266 // -fthreadsafe-static is default, except for MSVC compatibility versions less
5267 // than 19.
5268 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
5269 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00005270 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00005271 CmdArgs.push_back("-fno-threadsafe-statics");
5272
Francois Pichet02744872011-09-01 16:38:08 +00005273 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
5274 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00005275 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00005276 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00005277 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00005278
Chandler Carruthe03aa552010-04-17 20:17:31 +00005279 // -fgnu-keywords default varies depending on language; only pass if
5280 // specified.
5281 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00005282 options::OPT_fno_gnu_keywords))
5283 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00005284
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005285 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
Rafael Espindola922a6242011-06-02 17:30:53 +00005286 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00005287 CmdArgs.push_back("-fgnu89-inline");
5288
Chad Rosier9c76d242012-03-15 22:31:42 +00005289 if (Args.hasArg(options::OPT_fno_inline))
5290 CmdArgs.push_back("-fno-inline");
5291
Chad Rosier64d6be92012-03-06 21:17:19 +00005292 if (Args.hasArg(options::OPT_fno_inline_functions))
5293 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00005294
John McCall5fb5df92012-06-20 06:18:46 +00005295 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00005296
John McCall5fb5df92012-06-20 06:18:46 +00005297 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00005298 // legacy is the default. Except for deployment taget of 10.5,
5299 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
5300 // gets ignored silently.
5301 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00005302 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
5303 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00005304 objcRuntime.isLegacyDispatchDefaultForArch(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005305 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00005306 if (getToolChain().UseObjCMixedDispatch())
5307 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
5308 else
5309 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
5310 }
5311 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00005312
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00005313 // When ObjectiveC legacy runtime is in effect on MacOSX,
5314 // turn on the option to do Array/Dictionary subscripting
5315 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005316 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00005317 getToolChain().getTriple().isMacOSX() &&
5318 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
5319 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00005320 objcRuntime.isNeXTFamily())
5321 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005322
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00005323 // -fencode-extended-block-signature=1 is default.
5324 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
5325 CmdArgs.push_back("-fencode-extended-block-signature");
5326 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005327
John McCall24fc0de2011-07-06 00:26:06 +00005328 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
5329 // NOTE: This logic is duplicated in ToolChains.cpp.
5330 bool ARC = isObjCAutoRefCount(Args);
5331 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00005332 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00005333
John McCall24fc0de2011-07-06 00:26:06 +00005334 CmdArgs.push_back("-fobjc-arc");
5335
Chandler Carruth491db322011-11-04 07:34:47 +00005336 // FIXME: It seems like this entire block, and several around it should be
5337 // wrapped in isObjC, but for now we just use it here as this is where it
5338 // was being used previously.
5339 if (types::isCXX(InputType) && types::isObjC(InputType)) {
5340 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
5341 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
5342 else
5343 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
5344 }
5345
John McCall24fc0de2011-07-06 00:26:06 +00005346 // Allow the user to enable full exceptions code emission.
5347 // We define off for Objective-CC, on for Objective-C++.
5348 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
5349 options::OPT_fno_objc_arc_exceptions,
5350 /*default*/ types::isCXX(InputType)))
5351 CmdArgs.push_back("-fobjc-arc-exceptions");
John McCall460ce582015-10-22 18:38:17 +00005352
John McCall24fc0de2011-07-06 00:26:06 +00005353 }
5354
5355 // -fobjc-infer-related-result-type is the default, except in the Objective-C
5356 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00005357 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00005358 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005359
John McCall24fc0de2011-07-06 00:26:06 +00005360 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
5361 // takes precedence.
5362 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
5363 if (!GCArg)
5364 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
5365 if (GCArg) {
5366 if (ARC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005367 D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00005368 } else if (getToolChain().SupportsObjCGC()) {
5369 GCArg->render(Args, CmdArgs);
5370 } else {
5371 // FIXME: We should move this to a hard error.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005372 D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00005373 }
5374 }
5375
John McCallfbe5ed72015-11-05 19:19:56 +00005376 // Pass down -fobjc-weak or -fno-objc-weak if present.
5377 if (types::isObjC(InputType)) {
5378 auto WeakArg = Args.getLastArg(options::OPT_fobjc_weak,
5379 options::OPT_fno_objc_weak);
5380 if (!WeakArg) {
5381 // nothing to do
5382 } else if (GCArg) {
5383 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5384 D.Diag(diag::err_objc_weak_with_gc);
5385 } else if (!objcRuntime.allowsWeak()) {
5386 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5387 D.Diag(diag::err_objc_weak_unsupported);
5388 } else {
5389 WeakArg->render(Args, CmdArgs);
5390 }
5391 }
5392
Bob Wilsonb111ec92015-03-02 19:01:14 +00005393 if (Args.hasFlag(options::OPT_fapplication_extension,
5394 options::OPT_fno_application_extension, false))
5395 CmdArgs.push_back("-fapplication-extension");
5396
Reid Klecknerc542d372014-06-27 17:02:02 +00005397 // Handle GCC-style exception args.
5398 if (!C.getDriver().IsCLMode())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005399 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
5400 CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00005401
Tim Northovere931f9f2015-10-30 16:30:41 +00005402 if (getToolChain().UseSjLjExceptions(Args))
John McCallb5f652e2011-06-22 00:53:57 +00005403 CmdArgs.push_back("-fsjlj-exceptions");
5404
5405 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00005406 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5407 options::OPT_fno_assume_sane_operator_new))
5408 CmdArgs.push_back("-fno-assume-sane-operator-new");
5409
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00005410 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
5411 // most platforms.
5412 if (Args.hasFlag(options::OPT_fsized_deallocation,
5413 options::OPT_fno_sized_deallocation, false))
5414 CmdArgs.push_back("-fsized-deallocation");
5415
Daniel Dunbar34d7a992010-04-27 15:34:57 +00005416 // -fconstant-cfstrings is default, and may be subject to argument translation
5417 // on Darwin.
5418 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
5419 options::OPT_fno_constant_cfstrings) ||
5420 !Args.hasFlag(options::OPT_mconstant_cfstrings,
5421 options::OPT_mno_constant_cfstrings))
5422 CmdArgs.push_back("-fno-constant-cfstrings");
5423
John Thompsoned4e2952009-11-05 20:14:16 +00005424 // -fshort-wchar default varies depending on platform; only
5425 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00005426 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
5427 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00005428 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00005429
Hans Wennborg28c96312013-07-31 23:39:13 +00005430 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005431 if (Args.hasFlag(options::OPT_fpascal_strings,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005432 options::OPT_fno_pascal_strings, false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00005433 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00005434
Daniel Dunbar096ed292011-10-05 21:04:55 +00005435 // Honor -fpack-struct= and -fpack-struct, if given. Note that
5436 // -fno-pack-struct doesn't apply to -fpack-struct=.
5437 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00005438 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00005439 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00005440 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00005441 } else if (Args.hasFlag(options::OPT_fpack_struct,
5442 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00005443 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00005444 }
5445
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00005446 // Handle -fmax-type-align=N and -fno-type-align
5447 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
5448 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
5449 if (!SkipMaxTypeAlign) {
5450 std::string MaxTypeAlignStr = "-fmax-type-align=";
5451 MaxTypeAlignStr += A->getValue();
5452 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5453 }
5454 } else if (getToolChain().getTriple().isOSDarwin()) {
5455 if (!SkipMaxTypeAlign) {
5456 std::string MaxTypeAlignStr = "-fmax-type-align=16";
5457 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5458 }
5459 }
5460
John Brawna7b4ec02015-08-10 11:11:28 +00005461 // -fcommon is the default unless compiling kernel code or the target says so
5462 bool NoCommonDefault =
5463 KernelOrKext || isNoCommonDefault(getToolChain().getTriple());
5464 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
5465 !NoCommonDefault))
Daniel Dunbard18049a2009-04-07 21:16:11 +00005466 CmdArgs.push_back("-fno-common");
5467
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005468 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00005469 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00005470 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005471 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005472 D.Diag(diag::warn_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005473 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005474
Daniel Dunbar6358d682010-10-15 22:30:42 +00005475 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005476 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005477 D.Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005478 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
Daniel Dunbar6358d682010-10-15 22:30:42 +00005479
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00005480 // -finput_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005481 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
5482 StringRef value = inputCharset->getValue();
5483 if (value != "UTF-8")
5484 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
5485 << value;
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00005486 }
5487
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00005488 // -fexec_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005489 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
5490 StringRef value = execCharset->getValue();
5491 if (value != "UTF-8")
5492 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
5493 << value;
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00005494 }
5495
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00005496 // -fcaret-diagnostics is default.
5497 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
5498 options::OPT_fno_caret_diagnostics, true))
5499 CmdArgs.push_back("-fno-caret-diagnostics");
5500
Daniel Dunbar8281bde2009-04-19 21:09:34 +00005501 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00005502 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00005503 options::OPT_fno_diagnostics_fixit_info))
5504 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005505
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005506 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00005507 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005508 options::OPT_fno_diagnostics_show_option))
5509 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005510
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005511 if (const Arg *A =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005512 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005513 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00005514 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005515 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005516
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005517 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
Douglas Gregor643c9222011-05-21 17:07:29 +00005518 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00005519 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00005520 }
5521
Chandler Carruthb6766f02011-03-27 01:50:55 +00005522 if (Arg *A = Args.getLastArg(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005523 options::OPT_fdiagnostics_show_note_include_stack,
5524 options::OPT_fno_diagnostics_show_note_include_stack)) {
Chandler Carruthb6766f02011-03-27 01:50:55 +00005525 if (A->getOption().matches(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005526 options::OPT_fdiagnostics_show_note_include_stack))
Chandler Carruthb6766f02011-03-27 01:50:55 +00005527 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
5528 else
5529 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
5530 }
5531
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005532 // Color diagnostics are the default, unless the terminal doesn't support
5533 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00005534 // Support both clang's -f[no-]color-diagnostics and gcc's
5535 // -f[no-]diagnostics-colors[=never|always|auto].
5536 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005537 for (const auto &Arg : Args) {
5538 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00005539 if (!O.matches(options::OPT_fcolor_diagnostics) &&
5540 !O.matches(options::OPT_fdiagnostics_color) &&
5541 !O.matches(options::OPT_fno_color_diagnostics) &&
5542 !O.matches(options::OPT_fno_diagnostics_color) &&
5543 !O.matches(options::OPT_fdiagnostics_color_EQ))
5544 continue;
5545
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005546 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00005547 if (O.matches(options::OPT_fcolor_diagnostics) ||
5548 O.matches(options::OPT_fdiagnostics_color)) {
5549 ShowColors = Colors_On;
5550 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
5551 O.matches(options::OPT_fno_diagnostics_color)) {
5552 ShowColors = Colors_Off;
5553 } else {
5554 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005555 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00005556 if (value == "always")
5557 ShowColors = Colors_On;
5558 else if (value == "never")
5559 ShowColors = Colors_Off;
5560 else if (value == "auto")
5561 ShowColors = Colors_Auto;
5562 else
5563 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005564 << ("-fdiagnostics-color=" + value).str();
Nico Weber7e2da792013-04-17 21:52:44 +00005565 }
5566 }
5567 if (ShowColors == Colors_On ||
5568 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005569 CmdArgs.push_back("-fcolor-diagnostics");
5570
Nico Rieck7857d462013-09-11 00:38:02 +00005571 if (Args.hasArg(options::OPT_fansi_escape_codes))
5572 CmdArgs.push_back("-fansi-escape-codes");
5573
Daniel Dunbardb097022009-06-08 21:13:54 +00005574 if (!Args.hasFlag(options::OPT_fshow_source_location,
5575 options::OPT_fno_show_source_location))
5576 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005577
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005578 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
Douglas Gregor643c9222011-05-21 17:07:29 +00005579 true))
5580 CmdArgs.push_back("-fno-show-column");
5581
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00005582 if (!Args.hasFlag(options::OPT_fspell_checking,
5583 options::OPT_fno_spell_checking))
5584 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005585
Chad Rosierc8e56e82012-12-05 21:08:21 +00005586 // -fno-asm-blocks is default.
5587 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5588 false))
5589 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00005590
Steven Wucb0d13f2015-01-16 23:05:28 +00005591 // -fgnu-inline-asm is default.
5592 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5593 options::OPT_fno_gnu_inline_asm, true))
5594 CmdArgs.push_back("-fno-gnu-inline-asm");
5595
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00005596 // Enable vectorization per default according to the optimization level
5597 // selected. For optimization levels that want vectorization we use the alias
5598 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005599 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005600 OptSpecifier VectorizeAliasOption =
5601 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00005602 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00005603 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005604 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005605
Chad Rosier136d67d2014-04-28 19:30:57 +00005606 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005607 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005608 OptSpecifier SLPVectAliasOption =
5609 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
Chad Rosier136d67d2014-04-28 19:30:57 +00005610 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005611 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00005612 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00005613
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005614 // -fno-slp-vectorize-aggressive is default.
5615 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00005616 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005617 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005618
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00005619 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
5620 A->render(Args, CmdArgs);
5621
Filipe Cabecinhasab731f72016-05-12 16:51:36 +00005622 if (Arg *A = Args.getLastArg(
5623 options::OPT_fsanitize_undefined_strip_path_components_EQ))
5624 A->render(Args, CmdArgs);
5625
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005626 // -fdollars-in-identifiers default varies depending on platform and
5627 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00005628 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005629 options::OPT_fno_dollars_in_identifiers)) {
5630 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005631 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005632 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005633 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005634 }
5635
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005636 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
5637 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00005638 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005639 options::OPT_fno_unit_at_a_time)) {
5640 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005641 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005642 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005643
Eli Friedman055c9702011-11-02 01:53:16 +00005644 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5645 options::OPT_fno_apple_pragma_pack, false))
5646 CmdArgs.push_back("-fapple-pragma-pack");
5647
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005648 // le32-specific flags:
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005649 // -fno-math-builtin: clang should not convert math builtins to intrinsics
5650 // by default.
Chad Rosierf662fb32016-01-26 16:16:53 +00005651 if (getToolChain().getArch() == llvm::Triple::le32) {
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005652 CmdArgs.push_back("-fno-math-builtin");
Chad Rosierf662fb32016-01-26 16:16:53 +00005653 }
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005654
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005655// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
5656//
Chad Rosier38fd54e2016-01-26 15:46:29 +00005657// FIXME: Now that PR4941 has been fixed this can be enabled.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005658#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00005659 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005660 (getToolChain().getArch() == llvm::Triple::arm ||
5661 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005662 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
5663 CmdArgs.push_back("-fno-builtin-strcat");
5664 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
5665 CmdArgs.push_back("-fno-builtin-strcpy");
5666 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005667#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005668
Justin Bognera88f0122014-06-20 22:59:50 +00005669 // Enable rewrite includes if the user's asked for it or if we're generating
5670 // diagnostics.
5671 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
5672 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00005673 if (Args.hasFlag(options::OPT_frewrite_includes,
5674 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00005675 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00005676 CmdArgs.push_back("-frewrite-includes");
5677
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005678 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00005679 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005680 options::OPT_traditional_cpp)) {
5681 if (isa<PreprocessJobAction>(JA))
5682 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005683 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005684 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005685 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005686
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005687 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00005688 Args.AddLastArg(CmdArgs, options::OPT_dD);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005689
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005690 // Handle serialized diagnostics.
5691 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5692 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00005693 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005694 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005695
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00005696 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5697 CmdArgs.push_back("-fretain-comments-from-system-headers");
5698
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005699 // Forward -fcomment-block-commands to -cc1.
5700 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00005701 // Forward -fparse-all-comments to -cc1.
5702 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005703
John Brawnad31ace2015-09-23 13:55:40 +00005704 // Turn -fplugin=name.so into -load name.so
5705 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5706 CmdArgs.push_back("-load");
5707 CmdArgs.push_back(A->getValue());
5708 A->claim();
5709 }
5710
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005711 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
5712 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005713 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Sean Silva14facf32015-06-09 01:57:17 +00005714 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
5715 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00005716
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005717 // We translate this by hand to the -cc1 argument, since nightly test uses
5718 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00005719 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005720 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00005721 } else
Sean Silva14facf32015-06-09 01:57:17 +00005722 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005723 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005724
Bob Wilson23a55f12014-12-21 07:00:00 +00005725 // With -save-temps, we want to save the unoptimized bitcode output from the
Steven Wu546a1962015-07-17 20:09:56 +00005726 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated
5727 // by the frontend.
Steven Wu27fb5222016-05-11 16:26:03 +00005728 // When -fembed-bitcode is enabled, optimized bitcode is emitted because it
5729 // has slightly different breakdown between stages.
5730 // FIXME: -fembed-bitcode -save-temps will save optimized bitcode instead of
5731 // pristine IR generated by the frontend. Ideally, a new compile action should
5732 // be added so both IR can be captured.
5733 if (C.getDriver().isSaveTempsEnabled() &&
5734 !C.getDriver().embedBitcodeEnabled() && isa<CompileJobAction>(JA))
Steven Wu546a1962015-07-17 20:09:56 +00005735 CmdArgs.push_back("-disable-llvm-passes");
Bob Wilson23a55f12014-12-21 07:00:00 +00005736
Daniel Dunbard67a3222009-03-30 06:36:42 +00005737 if (Output.getType() == types::TY_Dependencies) {
5738 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005739 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005740 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005741 CmdArgs.push_back(Output.getFilename());
5742 } else {
5743 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005744 }
5745
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005746 addDashXForInput(Args, Input, CmdArgs);
Ben Langmuir2cb4a782014-02-05 22:21:15 +00005747
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005748 if (Input.isFilename())
5749 CmdArgs.push_back(Input.getFilename());
5750 else
5751 Input.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005752
Chris Lattnere9d7d782009-11-03 19:50:27 +00005753 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5754
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005755 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005756
5757 // Optionally embed the -cc1 level arguments into the debug info, for build
5758 // analysis.
5759 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00005760 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005761 for (const auto &Arg : Args)
5762 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005763
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005764 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005765 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005766 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005767 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005768 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005769 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005770 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005771 }
5772 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005773 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005774 }
5775
Eric Christopherd3804002013-02-22 20:12:52 +00005776 // Add the split debug info name to the command lines here so we
5777 // can propagate it to the backend.
David Blaikiece3e7a62015-07-30 21:42:22 +00005778 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005779 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5780 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00005781 const char *SplitDwarfOut;
5782 if (SplitDwarf) {
5783 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00005784 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00005785 CmdArgs.push_back(SplitDwarfOut);
5786 }
5787
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005788 // Host-side cuda compilation receives device-side outputs as Inputs[1...].
5789 // Include them with -fcuda-include-gpubinary.
5790 if (IsCuda && Inputs.size() > 1)
Artem Belevich5bde4e02015-07-20 20:02:54 +00005791 for (auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005792 CmdArgs.push_back("-fcuda-include-gpubinary");
Artem Belevich5bde4e02015-07-20 20:02:54 +00005793 CmdArgs.push_back(I->getFilename());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005794 }
5795
Peter Collingbourne3afb2662016-04-28 17:09:37 +00005796 bool WholeProgramVTables =
5797 Args.hasFlag(options::OPT_fwhole_program_vtables,
5798 options::OPT_fno_whole_program_vtables, false);
5799 if (WholeProgramVTables) {
5800 if (!D.isUsingLTO())
5801 D.Diag(diag::err_drv_argument_only_allowed_with)
5802 << "-fwhole-program-vtables"
5803 << "-flto";
5804 CmdArgs.push_back("-fwhole-program-vtables");
5805 }
5806
Eric Christopherd3804002013-02-22 20:12:52 +00005807 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00005808 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00005809 Output.getType() == types::TY_Object &&
5810 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00005811 auto CLCommand =
5812 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
Justin Bognerd3371d82015-07-17 03:35:54 +00005813 C.addCommand(llvm::make_unique<FallbackCommand>(
5814 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
Nico Weber2ca4be92016-03-01 23:16:44 +00005815 } else if (Args.hasArg(options::OPT__SLASH_fallback) &&
5816 isa<PrecompileJobAction>(JA)) {
5817 // In /fallback builds, run the main compilation even if the pch generation
5818 // fails, so that the main compilation's fallback to cl.exe runs.
5819 C.addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *this, Exec,
5820 CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005821 } else {
Justin Bognerd3371d82015-07-17 03:35:54 +00005822 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005823 }
5824
Eric Christopherf1545832013-02-22 23:50:16 +00005825 // Handle the debug info splitting at object creation time if we're
5826 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00005827 // TODO: Currently only works on linux with newer objcopy.
Eric Christopher0945a642016-03-24 00:34:02 +00005828 if (SplitDwarf && Output.getType() == types::TY_Object)
Eric Christopherd3804002013-02-22 20:12:52 +00005829 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00005830
Roman Divacky178e01602011-02-10 16:52:03 +00005831 if (Arg *A = Args.getLastArg(options::OPT_pg))
5832 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005833 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
5834 << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005835
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005836 // Claim some arguments which clang supports automatically.
5837
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00005838 // -fpch-preprocess is used with gcc to add a special marker in the output to
5839 // include the PCH file. Clang's PTH solution is completely transparent, so we
5840 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005841 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005842
Daniel Dunbar17731772009-03-23 19:03:36 +00005843 // Claim some arguments which clang doesn't support, but we don't
5844 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00005845 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5846 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00005847
Rafael Espindolab0092d72013-09-04 19:37:35 +00005848 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00005849 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005850}
5851
John McCall5fb5df92012-06-20 06:18:46 +00005852/// Add options related to the Objective-C runtime/ABI.
5853///
5854/// Returns true if the runtime is non-fragile.
5855ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
5856 ArgStringList &cmdArgs,
5857 RewriteKind rewriteKind) const {
5858 // Look for the controlling runtime option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005859 Arg *runtimeArg =
5860 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5861 options::OPT_fobjc_runtime_EQ);
John McCall5fb5df92012-06-20 06:18:46 +00005862
5863 // Just forward -fobjc-runtime= to the frontend. This supercedes
5864 // options about fragility.
5865 if (runtimeArg &&
5866 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5867 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00005868 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005869 if (runtime.tryParse(value)) {
5870 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005871 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005872 }
5873
5874 runtimeArg->render(args, cmdArgs);
5875 return runtime;
5876 }
5877
5878 // Otherwise, we'll need the ABI "version". Version numbers are
5879 // slightly confusing for historical reasons:
5880 // 1 - Traditional "fragile" ABI
5881 // 2 - Non-fragile ABI, version 1
5882 // 3 - Non-fragile ABI, version 2
5883 unsigned objcABIVersion = 1;
5884 // If -fobjc-abi-version= is present, use that to set the version.
5885 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005886 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005887 if (value == "1")
5888 objcABIVersion = 1;
5889 else if (value == "2")
5890 objcABIVersion = 2;
5891 else if (value == "3")
5892 objcABIVersion = 3;
5893 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005894 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
John McCall5fb5df92012-06-20 06:18:46 +00005895 } else {
5896 // Otherwise, determine if we are using the non-fragile ABI.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005897 bool nonFragileABIIsDefault =
5898 (rewriteKind == RK_NonFragile ||
5899 (rewriteKind == RK_None &&
5900 getToolChain().IsObjCNonFragileABIDefault()));
John McCall5fb5df92012-06-20 06:18:46 +00005901 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5902 options::OPT_fno_objc_nonfragile_abi,
5903 nonFragileABIIsDefault)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005904// Determine the non-fragile ABI version to use.
John McCall5fb5df92012-06-20 06:18:46 +00005905#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5906 unsigned nonFragileABIVersion = 1;
5907#else
5908 unsigned nonFragileABIVersion = 2;
5909#endif
5910
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005911 if (Arg *abiArg =
5912 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005913 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005914 if (value == "1")
5915 nonFragileABIVersion = 1;
5916 else if (value == "2")
5917 nonFragileABIVersion = 2;
5918 else
5919 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005920 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005921 }
5922
5923 objcABIVersion = 1 + nonFragileABIVersion;
5924 } else {
5925 objcABIVersion = 1;
5926 }
5927 }
5928
5929 // We don't actually care about the ABI version other than whether
5930 // it's non-fragile.
5931 bool isNonFragile = objcABIVersion != 1;
5932
5933 // If we have no runtime argument, ask the toolchain for its default runtime.
5934 // However, the rewriter only really supports the Mac runtime, so assume that.
5935 ObjCRuntime runtime;
5936 if (!runtimeArg) {
5937 switch (rewriteKind) {
5938 case RK_None:
5939 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5940 break;
5941 case RK_Fragile:
5942 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5943 break;
5944 case RK_NonFragile:
5945 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5946 break;
5947 }
5948
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005949 // -fnext-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005950 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5951 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005952 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00005953 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5954
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005955 // Otherwise, build for a generic macosx port.
John McCall5fb5df92012-06-20 06:18:46 +00005956 } else {
5957 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5958 }
5959
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005960 // -fgnu-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005961 } else {
5962 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
Eric Christopherbce27882015-12-28 21:57:05 +00005963 // Legacy behaviour is to target the gnustep runtime if we are in
David Chisnall314896c2012-07-04 10:37:03 +00005964 // non-fragile mode or the GCC runtime in fragile mode.
5965 if (isNonFragile)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005966 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6));
David Chisnall314896c2012-07-04 10:37:03 +00005967 else
5968 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00005969 }
5970
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005971 cmdArgs.push_back(
5972 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
John McCall5fb5df92012-06-20 06:18:46 +00005973 return runtime;
5974}
5975
Reid Klecknerc542d372014-06-27 17:02:02 +00005976static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5977 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5978 I += HaveDash;
5979 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00005980}
Reid Klecknerc542d372014-06-27 17:02:02 +00005981
Benjamin Kramere003ca22015-10-28 13:54:16 +00005982namespace {
Reid Klecknerc542d372014-06-27 17:02:02 +00005983struct EHFlags {
David Majnemerb8809092016-02-20 09:23:44 +00005984 bool Synch = false;
5985 bool Asynch = false;
5986 bool NoUnwindC = false;
Reid Klecknerc542d372014-06-27 17:02:02 +00005987};
Benjamin Kramere003ca22015-10-28 13:54:16 +00005988} // end anonymous namespace
Reid Klecknerc542d372014-06-27 17:02:02 +00005989
5990/// /EH controls whether to run destructor cleanups when exceptions are
5991/// thrown. There are three modifiers:
5992/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5993/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5994/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
David Majnemer960813e2016-02-20 09:23:47 +00005995/// - c: Assume that extern "C" functions are implicitly nounwind.
Reid Klecknerc542d372014-06-27 17:02:02 +00005996/// The default is /EHs-c-, meaning cleanups are disabled.
5997static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5998 EHFlags EH;
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005999
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006000 std::vector<std::string> EHArgs =
6001 Args.getAllArgValues(options::OPT__SLASH_EH);
Reid Klecknerc542d372014-06-27 17:02:02 +00006002 for (auto EHVal : EHArgs) {
6003 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
6004 switch (EHVal[I]) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006005 case 'a':
6006 EH.Asynch = maybeConsumeDash(EHVal, I);
David Majnemer387fccd2016-02-29 01:40:30 +00006007 if (EH.Asynch)
6008 EH.Synch = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006009 continue;
6010 case 'c':
David Majnemerb8809092016-02-20 09:23:44 +00006011 EH.NoUnwindC = maybeConsumeDash(EHVal, I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006012 continue;
6013 case 's':
6014 EH.Synch = maybeConsumeDash(EHVal, I);
David Majnemer387fccd2016-02-29 01:40:30 +00006015 if (EH.Synch)
6016 EH.Asynch = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006017 continue;
6018 default:
6019 break;
Reid Klecknerc542d372014-06-27 17:02:02 +00006020 }
6021 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
6022 break;
6023 }
6024 }
David Majnemerb8809092016-02-20 09:23:44 +00006025 // The /GX, /GX- flags are only processed if there are not /EH flags.
David Majnemera7bdc5a2016-02-22 17:44:51 +00006026 // The default is that /GX is not specified.
David Majnemerb8809092016-02-20 09:23:44 +00006027 if (EHArgs.empty() &&
David Majnemera7bdc5a2016-02-22 17:44:51 +00006028 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
6029 /*default=*/false)) {
David Majnemerb8809092016-02-20 09:23:44 +00006030 EH.Synch = true;
6031 EH.NoUnwindC = true;
6032 }
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00006033
Reid Klecknerc542d372014-06-27 17:02:02 +00006034 return EH;
6035}
6036
David Majnemercd5855e2016-02-29 01:40:36 +00006037void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
6038 ArgStringList &CmdArgs,
Benjamin Kramer8c305922016-02-02 11:06:51 +00006039 codegenoptions::DebugInfoKind *DebugInfoKind,
Douglas Katzman3459ce22015-10-08 04:24:12 +00006040 bool *EmitCodeView) const {
Hans Wennborg75958c42013-08-08 00:17:41 +00006041 unsigned RTOptionID = options::OPT__SLASH_MT;
6042
Hans Wennborgf1a74252013-09-10 20:18:04 +00006043 if (Args.hasArg(options::OPT__SLASH_LDd))
6044 // The /LDd option implies /MTd. The dependent lib part can be overridden,
6045 // but defining _DEBUG is sticky.
6046 RTOptionID = options::OPT__SLASH_MTd;
6047
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00006048 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00006049 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00006050
David Majnemere2afb472015-07-24 06:49:13 +00006051 StringRef FlagForCRT;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006052 switch (RTOptionID) {
6053 case options::OPT__SLASH_MD:
6054 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00006055 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006056 CmdArgs.push_back("-D_MT");
6057 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00006058 FlagForCRT = "--dependent-lib=msvcrt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006059 break;
6060 case options::OPT__SLASH_MDd:
6061 CmdArgs.push_back("-D_DEBUG");
6062 CmdArgs.push_back("-D_MT");
6063 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00006064 FlagForCRT = "--dependent-lib=msvcrtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006065 break;
6066 case options::OPT__SLASH_MT:
6067 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00006068 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006069 CmdArgs.push_back("-D_MT");
Peter Collingbourne3afb2662016-04-28 17:09:37 +00006070 CmdArgs.push_back("-flto-visibility-public-std");
David Majnemere2afb472015-07-24 06:49:13 +00006071 FlagForCRT = "--dependent-lib=libcmt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006072 break;
6073 case options::OPT__SLASH_MTd:
6074 CmdArgs.push_back("-D_DEBUG");
6075 CmdArgs.push_back("-D_MT");
Peter Collingbourne3afb2662016-04-28 17:09:37 +00006076 CmdArgs.push_back("-flto-visibility-public-std");
David Majnemere2afb472015-07-24 06:49:13 +00006077 FlagForCRT = "--dependent-lib=libcmtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006078 break;
6079 default:
6080 llvm_unreachable("Unexpected option ID.");
Hans Wennborg75958c42013-08-08 00:17:41 +00006081 }
6082
David Majnemere2afb472015-07-24 06:49:13 +00006083 if (Args.hasArg(options::OPT__SLASH_Zl)) {
6084 CmdArgs.push_back("-D_VC_NODEFAULTLIB");
6085 } else {
6086 CmdArgs.push_back(FlagForCRT.data());
6087
6088 // This provides POSIX compatibility (maps 'open' to '_open'), which most
6089 // users want. The /Za flag to cl.exe turns this off, but it's not
6090 // implemented in clang.
6091 CmdArgs.push_back("--dependent-lib=oldnames");
6092 }
Hans Wennborg614f7072013-08-08 19:54:30 +00006093
Hans Wennborg8858a032014-07-21 23:42:07 +00006094 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
6095 // would produce interleaved output, so ignore /showIncludes in such cases.
6096 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
6097 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
6098 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00006099
David Majnemerf6072342014-07-01 22:24:56 +00006100 // This controls whether or not we emit RTTI data for polymorphic types.
6101 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
6102 /*default=*/false))
6103 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00006104
Reid Kleckner124955a2015-08-05 18:51:13 +00006105 // Emit CodeView if -Z7 is present.
Douglas Katzman3459ce22015-10-08 04:24:12 +00006106 *EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
Reid Kleckner9ce06a4a2016-02-10 21:28:38 +00006107 if (*EmitCodeView)
6108 *DebugInfoKind = codegenoptions::LimitedDebugInfo;
Douglas Katzman3459ce22015-10-08 04:24:12 +00006109 if (*EmitCodeView)
Reid Kleckner124955a2015-08-05 18:51:13 +00006110 CmdArgs.push_back("-gcodeview");
6111
Reid Klecknerc542d372014-06-27 17:02:02 +00006112 const Driver &D = getToolChain().getDriver();
6113 EHFlags EH = parseClangCLEHFlags(D, Args);
Reid Klecknerdeeddec2015-02-05 18:56:03 +00006114 if (EH.Synch || EH.Asynch) {
David Majnemercd5855e2016-02-29 01:40:36 +00006115 if (types::isCXX(InputType))
6116 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00006117 CmdArgs.push_back("-fexceptions");
6118 }
David Majnemercd5855e2016-02-29 01:40:36 +00006119 if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
6120 CmdArgs.push_back("-fexternc-nounwind");
Reid Klecknerc542d372014-06-27 17:02:02 +00006121
Hans Wennborge50cec32014-06-13 20:59:54 +00006122 // /EP should expand to -E -P.
6123 if (Args.hasArg(options::OPT__SLASH_EP)) {
6124 CmdArgs.push_back("-E");
6125 CmdArgs.push_back("-P");
6126 }
6127
David Majnemera5b195a2015-02-14 01:35:12 +00006128 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006129 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
6130 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00006131 VolatileOptionID = options::OPT__SLASH_volatile_ms;
6132 else
6133 VolatileOptionID = options::OPT__SLASH_volatile_iso;
6134
6135 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
6136 VolatileOptionID = A->getOption().getID();
6137
6138 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
6139 CmdArgs.push_back("-fms-volatile");
6140
David Majnemer86c318f2014-02-11 21:05:00 +00006141 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
6142 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
6143 if (MostGeneralArg && BestCaseArg)
6144 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6145 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
6146
6147 if (MostGeneralArg) {
6148 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
6149 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
6150 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
6151
6152 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
6153 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
6154 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
6155 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6156 << FirstConflict->getAsString(Args)
6157 << SecondConflict->getAsString(Args);
6158
6159 if (SingleArg)
6160 CmdArgs.push_back("-fms-memptr-rep=single");
6161 else if (MultipleArg)
6162 CmdArgs.push_back("-fms-memptr-rep=multiple");
6163 else
6164 CmdArgs.push_back("-fms-memptr-rep=virtual");
6165 }
6166
Alexey Bataeva7547182016-05-18 09:06:38 +00006167 if (Args.getLastArg(options::OPT__SLASH_Gd))
6168 CmdArgs.push_back("-fdefault-calling-conv=cdecl");
6169 else if (Args.getLastArg(options::OPT__SLASH_Gr))
6170 CmdArgs.push_back("-fdefault-calling-conv=fastcall");
6171 else if (Args.getLastArg(options::OPT__SLASH_Gz))
6172 CmdArgs.push_back("-fdefault-calling-conv=stdcall");
6173 else if (Args.getLastArg(options::OPT__SLASH_Gv))
6174 CmdArgs.push_back("-fdefault-calling-conv=vectorcall");
6175
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00006176 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
6177 A->render(Args, CmdArgs);
6178
Hans Wennborg81f74482013-09-10 01:07:07 +00006179 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
6180 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00006181 if (Args.hasArg(options::OPT__SLASH_fallback))
6182 CmdArgs.push_back("msvc-fallback");
6183 else
6184 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00006185 }
Hans Wennborg75958c42013-08-08 00:17:41 +00006186}
6187
Douglas Katzman95354292015-06-23 20:42:09 +00006188visualstudio::Compiler *Clang::getCLFallback() const {
Hans Wennborg1da044a2014-06-26 19:59:02 +00006189 if (!CLFallback)
Douglas Katzman95354292015-06-23 20:42:09 +00006190 CLFallback.reset(new visualstudio::Compiler(getToolChain()));
Hans Wennborg1da044a2014-06-26 19:59:02 +00006191 return CLFallback.get();
6192}
6193
Daniel Sanders7f933f42015-01-30 17:35:23 +00006194void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
6195 ArgStringList &CmdArgs) const {
6196 StringRef CPUName;
6197 StringRef ABIName;
6198 const llvm::Triple &Triple = getToolChain().getTriple();
6199 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
6200
6201 CmdArgs.push_back("-target-abi");
6202 CmdArgs.push_back(ABIName.data());
6203}
6204
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006205void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006206 const InputInfo &Output, const InputInfoList &Inputs,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006207 const ArgList &Args,
6208 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006209 ArgStringList CmdArgs;
6210
6211 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6212 const InputInfo &Input = Inputs[0];
6213
James Y Knight2db38f32015-08-15 03:45:25 +00006214 std::string TripleStr =
6215 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
6216 const llvm::Triple Triple(TripleStr);
6217
Rafael Espindolacfaadda2010-11-17 22:13:25 +00006218 // Don't warn about "clang -w -c foo.s"
6219 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006220 // and "clang -emit-llvm -c foo.s"
6221 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00006222
Rafael Espindola577637a2015-01-03 00:06:04 +00006223 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00006224
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006225 // Invoke ourselves in -cc1as mode.
6226 //
6227 // FIXME: Implement custom jobs for internal actions.
6228 CmdArgs.push_back("-cc1as");
6229
6230 // Add the "effective" target triple.
6231 CmdArgs.push_back("-triple");
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006232 CmdArgs.push_back(Args.MakeArgString(TripleStr));
6233
6234 // Set the output mode, we currently only expect to be used as a real
6235 // assembler.
6236 CmdArgs.push_back("-filetype");
6237 CmdArgs.push_back("obj");
6238
Eric Christopher45f2e712012-12-18 00:31:10 +00006239 // Set the main file name, so that debug info works even with
6240 // -save-temps or preprocessed assembly.
6241 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00006242 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00006243
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006244 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00006245 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006246 if (!CPU.empty()) {
6247 CmdArgs.push_back("-target-cpu");
6248 CmdArgs.push_back(Args.MakeArgString(CPU));
6249 }
6250
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00006251 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00006252 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00006253
Daniel Dunbar1d733e22011-03-17 17:37:29 +00006254 // Ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006255 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006256
Jim Grosbachc78c2bc2015-06-23 18:20:13 +00006257 // Pass along any -I options so we get proper .include search paths.
6258 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
6259
Eric Christopherfc3ee562012-01-10 00:38:01 +00006260 // Determine the original source input.
6261 const Action *SourceAction = &JA;
6262 while (SourceAction->getKind() != Action::InputClass) {
6263 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6264 SourceAction = SourceAction->getInputs()[0];
6265 }
6266
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00006267 // Forward -g and handle debug info related flags, assuming we are dealing
6268 // with an actual assembly file.
Douglas Katzman3103f252016-04-19 18:55:53 +00006269 bool WantDebug = false;
6270 unsigned DwarfVersion = 0;
6271 Args.ClaimAllArgs(options::OPT_g_Group);
6272 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
6273 WantDebug = !A->getOption().matches(options::OPT_g0) &&
6274 !A->getOption().matches(options::OPT_ggdb0);
6275 if (WantDebug)
6276 DwarfVersion = DwarfVersionNum(A->getSpelling());
6277 }
6278 if (DwarfVersion == 0)
6279 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
6280
6281 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo;
6282
Eric Christopherfc3ee562012-01-10 00:38:01 +00006283 if (SourceAction->getType() == types::TY_Asm ||
6284 SourceAction->getType() == types::TY_PP_Asm) {
Douglas Katzman3103f252016-04-19 18:55:53 +00006285 // You might think that it would be ok to set DebugInfoKind outside of
6286 // the guard for source type, however there is a test which asserts
6287 // that some assembler invocation receives no -debug-info-kind,
6288 // and it's not clear whether that test is just overly restrictive.
6289 DebugInfoKind = (WantDebug ? codegenoptions::LimitedDebugInfo
6290 : codegenoptions::NoDebugInfo);
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00006291 // Add the -fdebug-compilation-dir flag if needed.
6292 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00006293
6294 // Set the AT_producer to the clang version when using the integrated
6295 // assembler on assembly source files.
6296 CmdArgs.push_back("-dwarf-debug-producer");
Bruno Cardoso Lopes34c549e2016-05-02 20:20:49 +00006297 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Renato Golina74bbc72015-07-22 15:32:36 +00006298
6299 // And pass along -I options
6300 Args.AddAllArgs(CmdArgs, options::OPT_I);
Eric Christopherfc3ee562012-01-10 00:38:01 +00006301 }
Douglas Katzman3103f252016-04-19 18:55:53 +00006302 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
6303 llvm::DebuggerKind::Default);
Kevin Enderby292dc082011-12-22 19:31:58 +00006304
James Y Knight5bdf7ab2015-08-19 15:12:02 +00006305 // Handle -fPIC et al -- the relocation-model affects the assembler
6306 // for some targets.
6307 llvm::Reloc::Model RelocationModel;
6308 unsigned PICLevel;
6309 bool IsPIE;
6310 std::tie(RelocationModel, PICLevel, IsPIE) =
6311 ParsePICArgs(getToolChain(), Triple, Args);
6312
6313 const char *RMName = RelocationModelName(RelocationModel);
6314 if (RMName) {
6315 CmdArgs.push_back("-mrelocation-model");
6316 CmdArgs.push_back(RMName);
6317 }
6318
Kevin Enderby292dc082011-12-22 19:31:58 +00006319 // Optionally embed the -cc1as level arguments into the debug info, for build
6320 // analysis.
6321 if (getToolChain().UseDwarfDebugFlags()) {
6322 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006323 for (const auto &Arg : Args)
6324 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00006325
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00006326 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00006327 const char *Exec = getToolChain().getDriver().getClangProgramPath();
6328 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00006329 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00006330 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00006331 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00006332 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00006333 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00006334 }
6335 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00006336 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00006337 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006338
6339 // FIXME: Add -static support, once we have it.
6340
Daniel Sanders7f933f42015-01-30 17:35:23 +00006341 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006342 switch (getToolChain().getArch()) {
Daniel Sanders7f933f42015-01-30 17:35:23 +00006343 default:
6344 break;
6345
6346 case llvm::Triple::mips:
6347 case llvm::Triple::mipsel:
6348 case llvm::Triple::mips64:
6349 case llvm::Triple::mips64el:
6350 AddMIPSTargetArgs(Args, CmdArgs);
6351 break;
6352 }
6353
David Blaikie372d9502014-01-17 03:17:40 +00006354 // Consume all the warning flags. Usually this would be handled more
6355 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
6356 // doesn't handle that so rather than warning about unused flags that are
6357 // actually used, we'll lie by omission instead.
6358 // FIXME: Stop lying and consume only the appropriate driver flags
Eric Christopher5d1caa52016-01-07 02:00:55 +00006359 Args.ClaimAllArgs(options::OPT_W_Group);
David Blaikie372d9502014-01-17 03:17:40 +00006360
David Blaikie9260ed62013-07-25 21:19:01 +00006361 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
6362 getToolChain().getDriver());
6363
Daniel Dunbar252e8f92011-04-29 17:53:18 +00006364 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006365
6366 assert(Output.isFilename() && "Unexpected lipo output.");
6367 CmdArgs.push_back("-o");
6368 CmdArgs.push_back(Output.getFilename());
6369
Daniel Dunbarb440f562010-08-02 02:38:21 +00006370 assert(Input.isFilename() && "Invalid input.");
6371 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006372
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00006373 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Justin Bognerd3371d82015-07-17 03:35:54 +00006374 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christophera75018a2013-04-10 21:30:40 +00006375
6376 // Handle the debug info splitting at object creation time if we're
6377 // creating an object.
6378 // TODO: Currently only works on linux with newer objcopy.
6379 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006380 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00006381 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00006382 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006383}
6384
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006385void GnuTool::anchor() {}
6386
Daniel Dunbara3246a02009-03-18 08:07:30 +00006387void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00006388 const InputInfo &Output,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006389 const InputInfoList &Inputs, const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00006390 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006391 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00006392 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006393
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006394 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00006395 if (forwardToGCC(A->getOption())) {
Eric Christopher3f07d852016-01-07 09:03:42 +00006396 // It is unfortunate that we have to claim here, as this means
6397 // we will basically never report anything interesting for
6398 // platforms using a generic gcc, even if we are just using gcc
6399 // to get to the assembler.
6400 A->claim();
6401
Daniel Dunbar939c1212010-08-03 16:14:14 +00006402 // Don't forward any -g arguments to assembly steps.
6403 if (isa<AssembleJobAction>(JA) &&
6404 A->getOption().matches(options::OPT_g_Group))
6405 continue;
6406
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00006407 // Don't forward any -W arguments to assembly and link steps.
6408 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
6409 A->getOption().matches(options::OPT_W_Group))
6410 continue;
6411
Daniel Dunbara2aedc62009-03-18 10:01:51 +00006412 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00006413 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006414 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006415
Daniel Dunbar4e295052010-01-25 22:35:08 +00006416 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00006417
6418 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006419 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006420 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00006421 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006422 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00006423 }
6424
Daniel Dunbar5716d872009-05-02 21:41:52 +00006425 // Try to force gcc to match the tool chain we want, if we recognize
6426 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00006427 //
6428 // FIXME: The triple class should directly provide the information we want
6429 // here.
Douglas Katzman38857552015-08-20 18:32:26 +00006430 switch (getToolChain().getArch()) {
6431 default:
6432 break;
6433 case llvm::Triple::x86:
6434 case llvm::Triple::ppc:
Daniel Dunbar5716d872009-05-02 21:41:52 +00006435 CmdArgs.push_back("-m32");
Douglas Katzman38857552015-08-20 18:32:26 +00006436 break;
6437 case llvm::Triple::x86_64:
6438 case llvm::Triple::ppc64:
6439 case llvm::Triple::ppc64le:
Daniel Dunbar5716d872009-05-02 21:41:52 +00006440 CmdArgs.push_back("-m64");
Douglas Katzman38857552015-08-20 18:32:26 +00006441 break;
6442 case llvm::Triple::sparcel:
6443 CmdArgs.push_back("-EL");
6444 break;
6445 }
Daniel Dunbar5716d872009-05-02 21:41:52 +00006446
Daniel Dunbarb440f562010-08-02 02:38:21 +00006447 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006448 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006449 CmdArgs.push_back(Output.getFilename());
6450 } else {
6451 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00006452 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006453 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006454
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006455 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00006456
6457 // Only pass -x if gcc will understand it; otherwise hope gcc
6458 // understands the suffix correctly. The main use case this would go
6459 // wrong in is for linker inputs if they happened to have an odd
6460 // suffix; really the only way to get this to happen is a command
6461 // like '-x foobar a.c' which will treat a.c like a linker input.
6462 //
6463 // FIXME: For the linker case specifically, can we safely convert
6464 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006465 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00006466 // Don't try to pass LLVM or AST inputs to a generic gcc.
Eric Christopherc1984072015-12-08 02:10:19 +00006467 if (types::isLLVMIR(II.getType()))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006468 D.Diag(diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006469 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00006470 else if (II.getType() == types::TY_AST)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006471 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00006472 else if (II.getType() == types::TY_ModuleFile)
6473 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006474 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006475
Daniel Dunbara3246a02009-03-18 08:07:30 +00006476 if (types::canTypeBeUserSpecified(II.getType())) {
6477 CmdArgs.push_back("-x");
6478 CmdArgs.push_back(types::getTypeName(II.getType()));
6479 }
6480
Daniel Dunbarb440f562010-08-02 02:38:21 +00006481 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006482 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00006483 else {
6484 const Arg &A = II.getInputArg();
6485
6486 // Reverse translate some rewritten options.
6487 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
6488 CmdArgs.push_back("-lstdc++");
6489 continue;
6490 }
6491
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006492 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00006493 A.render(Args, CmdArgs);
6494 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006495 }
6496
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006497 const std::string customGCCName = D.getCCCGenericGCCName();
6498 const char *GCCName;
6499 if (!customGCCName.empty())
6500 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00006501 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006502 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006503 } else
6504 GCCName = "gcc";
6505
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006506 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00006507 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006508}
6509
Douglas Katzman95354292015-06-23 20:42:09 +00006510void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
6511 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006512 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006513}
6514
Douglas Katzman95354292015-06-23 20:42:09 +00006515void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
6516 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00006517 const Driver &D = getToolChain().getDriver();
6518
Eric Christophercc7ff502015-01-29 00:56:17 +00006519 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00006520 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00006521 case types::TY_LLVM_IR:
6522 case types::TY_LTO_IR:
6523 case types::TY_LLVM_BC:
6524 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00006525 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00006526 break;
Eric Christopher29a50bc2016-01-06 07:24:45 +00006527 // We assume we've got an "integrated" assembler in that gcc will produce an
6528 // object file itself.
6529 case types::TY_Object:
6530 CmdArgs.push_back("-c");
6531 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00006532 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00006533 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00006534 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00006535 case types::TY_Nothing:
6536 CmdArgs.push_back("-fsyntax-only");
6537 break;
6538 default:
6539 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00006540 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006541}
6542
Douglas Katzman95354292015-06-23 20:42:09 +00006543void gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
6544 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006545 // The types are (hopefully) good enough.
6546}
6547
Tony Linthicum76329bf2011-12-12 21:14:55 +00006548// Hexagon tools start.
Douglas Katzman95354292015-06-23 20:42:09 +00006549void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006550 ArgStringList &CmdArgs) const {
6551}
6552
Douglas Katzman95354292015-06-23 20:42:09 +00006553void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6554 const InputInfo &Output,
6555 const InputInfoList &Inputs,
6556 const ArgList &Args,
6557 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006558 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00006559
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006560 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
6561 const Driver &D = HTC.getDriver();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006562 ArgStringList CmdArgs;
6563
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006564 std::string MArchString = "-march=hexagon";
6565 CmdArgs.push_back(Args.MakeArgString(MArchString));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006566
6567 RenderExtraToolArgs(JA, CmdArgs);
6568
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006569 std::string AsName = "hexagon-llvm-mc";
6570 std::string MCpuString = "-mcpu=hexagon" +
6571 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
6572 CmdArgs.push_back("-filetype=obj");
6573 CmdArgs.push_back(Args.MakeArgString(MCpuString));
6574
Tony Linthicum76329bf2011-12-12 21:14:55 +00006575 if (Output.isFilename()) {
6576 CmdArgs.push_back("-o");
6577 CmdArgs.push_back(Output.getFilename());
6578 } else {
6579 assert(Output.isNothing() && "Unexpected output");
6580 CmdArgs.push_back("-fsyntax-only");
6581 }
6582
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006583 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
6584 std::string N = llvm::utostr(G.getValue());
6585 CmdArgs.push_back(Args.MakeArgString(std::string("-gpsize=") + N));
6586 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006587
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006588 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Matthew Curtise5df3812012-12-07 17:23:04 +00006589
Tony Linthicum76329bf2011-12-12 21:14:55 +00006590 // Only pass -x if gcc will understand it; otherwise hope gcc
6591 // understands the suffix correctly. The main use case this would go
6592 // wrong in is for linker inputs if they happened to have an odd
6593 // suffix; really the only way to get this to happen is a command
6594 // like '-x foobar a.c' which will treat a.c like a linker input.
6595 //
6596 // FIXME: For the linker case specifically, can we safely convert
6597 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006598 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006599 // Don't try to pass LLVM or AST inputs to a generic gcc.
Eric Christopherc1984072015-12-08 02:10:19 +00006600 if (types::isLLVMIR(II.getType()))
Tony Linthicum76329bf2011-12-12 21:14:55 +00006601 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006602 << HTC.getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006603 else if (II.getType() == types::TY_AST)
6604 D.Diag(clang::diag::err_drv_no_ast_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006605 << HTC.getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00006606 else if (II.getType() == types::TY_ModuleFile)
6607 D.Diag(diag::err_drv_no_module_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006608 << HTC.getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006609
6610 if (II.isFilename())
6611 CmdArgs.push_back(II.getFilename());
6612 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006613 // Don't render as input, we need gcc to do the translations.
Eric Christopherb0a44f72015-12-08 01:59:51 +00006614 // FIXME: What is this?
Tony Linthicum76329bf2011-12-12 21:14:55 +00006615 II.getInputArg().render(Args, CmdArgs);
6616 }
6617
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006618 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
Justin Bognerd3371d82015-07-17 03:35:54 +00006619 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006620}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006621
Douglas Katzman95354292015-06-23 20:42:09 +00006622void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
6623 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006624}
6625
Douglas Katzman54366072015-07-27 16:53:08 +00006626static void
6627constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006628 const toolchains::HexagonToolChain &HTC,
Douglas Katzman54366072015-07-27 16:53:08 +00006629 const InputInfo &Output, const InputInfoList &Inputs,
6630 const ArgList &Args, ArgStringList &CmdArgs,
6631 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006632
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006633 const Driver &D = HTC.getDriver();
Matthew Curtise689b052012-12-06 15:46:07 +00006634
Matthew Curtise689b052012-12-06 15:46:07 +00006635 //----------------------------------------------------------------------------
6636 //
6637 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006638 bool IsStatic = Args.hasArg(options::OPT_static);
6639 bool IsShared = Args.hasArg(options::OPT_shared);
6640 bool IsPIE = Args.hasArg(options::OPT_pie);
6641 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
6642 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
6643 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
6644 bool UseG0 = false;
6645 bool UseShared = IsShared && !IsStatic;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006646
Matthew Curtise689b052012-12-06 15:46:07 +00006647 //----------------------------------------------------------------------------
6648 // Silence warnings for various options
6649 //----------------------------------------------------------------------------
Matthew Curtise689b052012-12-06 15:46:07 +00006650 Args.ClaimAllArgs(options::OPT_g_Group);
6651 Args.ClaimAllArgs(options::OPT_emit_llvm);
6652 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
6653 // handled somewhere else.
6654 Args.ClaimAllArgs(options::OPT_static_libgcc);
6655
6656 //----------------------------------------------------------------------------
6657 //
6658 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006659 if (Args.hasArg(options::OPT_s))
6660 CmdArgs.push_back("-s");
6661
6662 if (Args.hasArg(options::OPT_r))
6663 CmdArgs.push_back("-r");
6664
6665 for (const auto &Opt : HTC.ExtraOpts)
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006666 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006667
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006668 CmdArgs.push_back("-march=hexagon");
6669 std::string CpuVer =
6670 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
6671 std::string MCpuString = "-mcpu=hexagon" + CpuVer;
6672 CmdArgs.push_back(Args.MakeArgString(MCpuString));
Sebastian Pop86500282012-01-13 20:37:10 +00006673
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006674 if (IsShared) {
Matthew Curtise689b052012-12-06 15:46:07 +00006675 CmdArgs.push_back("-shared");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006676 // The following should be the default, but doing as hexagon-gcc does.
6677 CmdArgs.push_back("-call_shared");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006678 }
6679
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006680 if (IsStatic)
Matthew Curtise689b052012-12-06 15:46:07 +00006681 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006682
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006683 if (IsPIE && !IsShared)
Matthew Curtise8f80a12012-12-06 17:49:03 +00006684 CmdArgs.push_back("-pie");
6685
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006686 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
6687 std::string N = llvm::utostr(G.getValue());
6688 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + N));
6689 UseG0 = G.getValue() == 0;
Matthew Curtise8f80a12012-12-06 17:49:03 +00006690 }
6691
Matthew Curtise689b052012-12-06 15:46:07 +00006692 //----------------------------------------------------------------------------
6693 //
6694 //----------------------------------------------------------------------------
6695 CmdArgs.push_back("-o");
6696 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006697
Matthew Curtise689b052012-12-06 15:46:07 +00006698 //----------------------------------------------------------------------------
6699 // moslib
6700 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006701 std::vector<std::string> OsLibs;
6702 bool HasStandalone = false;
Matthew Curtise689b052012-12-06 15:46:07 +00006703
Sean Silva14facf32015-06-09 01:57:17 +00006704 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
6705 A->claim();
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006706 OsLibs.emplace_back(A->getValue());
6707 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006708 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006709 if (OsLibs.empty()) {
6710 OsLibs.push_back("standalone");
6711 HasStandalone = true;
Matthew Curtise689b052012-12-06 15:46:07 +00006712 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006713
Matthew Curtise689b052012-12-06 15:46:07 +00006714 //----------------------------------------------------------------------------
6715 // Start Files
6716 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006717 const std::string MCpuSuffix = "/" + CpuVer;
6718 const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
6719 const std::string RootDir =
6720 HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
6721 const std::string StartSubDir =
6722 "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00006723
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006724 auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
6725 const char *Name) -> std::string {
6726 std::string RelName = SubDir + Name;
6727 std::string P = HTC.GetFilePath(RelName.c_str());
6728 if (llvm::sys::fs::exists(P))
6729 return P;
6730 return RootDir + RelName;
6731 };
6732
6733 if (IncStdLib && IncStartFiles) {
6734 if (!IsShared) {
6735 if (HasStandalone) {
6736 std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
6737 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
Matthew Curtise689b052012-12-06 15:46:07 +00006738 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006739 std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
6740 CmdArgs.push_back(Args.MakeArgString(Crt0));
Matthew Curtise689b052012-12-06 15:46:07 +00006741 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006742 std::string Init = UseShared
6743 ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
6744 : Find(RootDir, StartSubDir, "/init.o");
6745 CmdArgs.push_back(Args.MakeArgString(Init));
Matthew Curtise689b052012-12-06 15:46:07 +00006746 }
6747
6748 //----------------------------------------------------------------------------
6749 // Library Search Paths
6750 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006751 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
6752 for (const auto &LibPath : LibPaths)
6753 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00006754
6755 //----------------------------------------------------------------------------
6756 //
6757 //----------------------------------------------------------------------------
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006758 Args.AddAllArgs(CmdArgs,
6759 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6760 options::OPT_t, options::OPT_u_Group});
Matthew Curtise689b052012-12-06 15:46:07 +00006761
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006762 AddLinkerInputs(HTC, Inputs, Args, CmdArgs);
Matthew Curtise689b052012-12-06 15:46:07 +00006763
6764 //----------------------------------------------------------------------------
6765 // Libraries
6766 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006767 if (IncStdLib && IncDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006768 if (D.CCCIsCXX()) {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006769 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
Matthew Curtise689b052012-12-06 15:46:07 +00006770 CmdArgs.push_back("-lm");
6771 }
6772
6773 CmdArgs.push_back("--start-group");
6774
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006775 if (!IsShared) {
6776 for (const std::string &Lib : OsLibs)
Douglas Katzman2675d012015-06-29 19:12:56 +00006777 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
Matthew Curtise689b052012-12-06 15:46:07 +00006778 CmdArgs.push_back("-lc");
6779 }
6780 CmdArgs.push_back("-lgcc");
6781
6782 CmdArgs.push_back("--end-group");
6783 }
6784
6785 //----------------------------------------------------------------------------
6786 // End files
6787 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006788 if (IncStdLib && IncStartFiles) {
6789 std::string Fini = UseShared
6790 ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
6791 : Find(RootDir, StartSubDir, "/fini.o");
6792 CmdArgs.push_back(Args.MakeArgString(Fini));
Matthew Curtise689b052012-12-06 15:46:07 +00006793 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006794}
6795
Douglas Katzman95354292015-06-23 20:42:09 +00006796void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6797 const InputInfo &Output,
6798 const InputInfoList &Inputs,
6799 const ArgList &Args,
6800 const char *LinkingOutput) const {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006801 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006802
6803 ArgStringList CmdArgs;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006804 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006805 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00006806
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006807 std::string Linker = HTC.GetProgramPath("hexagon-link");
David Blaikiec11bf802014-09-04 16:04:28 +00006808 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
Justin Bognerd3371d82015-07-17 03:35:54 +00006809 CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006810}
6811// Hexagon tools end.
6812
Tom Stellard8fa33092015-07-18 01:49:05 +00006813void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6814 const InputInfo &Output,
6815 const InputInfoList &Inputs,
6816 const ArgList &Args,
6817 const char *LinkingOutput) const {
6818
6819 std::string Linker = getToolChain().GetProgramPath(getShortName());
6820 ArgStringList CmdArgs;
Tom Stellard8fa33092015-07-18 01:49:05 +00006821 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Tom Stellardf6699f52016-05-05 17:03:41 +00006822 CmdArgs.push_back("-shared");
6823 CmdArgs.push_back("-o");
Tom Stellard8fa33092015-07-18 01:49:05 +00006824 CmdArgs.push_back(Output.getFilename());
6825 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
6826 CmdArgs, Inputs));
6827}
6828// AMDGPU tools end.
6829
Dan Gohman52816862015-12-16 23:30:41 +00006830wasm::Linker::Linker(const ToolChain &TC)
6831 : GnuTool("wasm::Linker", "lld", TC) {}
6832
6833bool wasm::Linker::isLinkJob() const {
6834 return true;
6835}
6836
6837bool wasm::Linker::hasIntegratedCPP() const {
6838 return false;
6839}
6840
6841void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6842 const InputInfo &Output,
6843 const InputInfoList &Inputs,
6844 const ArgList &Args,
6845 const char *LinkingOutput) const {
Dan Gohman57b62c52016-02-22 19:26:15 +00006846
6847 const ToolChain &ToolChain = getToolChain();
6848 const Driver &D = ToolChain.getDriver();
6849 const char *Linker = Args.MakeArgString(ToolChain.GetLinkerPath());
Dan Gohman52816862015-12-16 23:30:41 +00006850 ArgStringList CmdArgs;
6851 CmdArgs.push_back("-flavor");
6852 CmdArgs.push_back("ld");
Dan Gohman1aa58282016-01-06 19:43:32 +00006853
6854 // Enable garbage collection of unused input sections by default, since code
Dan Gohmana5b804b2016-01-07 00:50:27 +00006855 // size is of particular importance. This is significantly facilitated by
6856 // the enabling of -ffunction-sections and -fdata-sections in
6857 // Clang::ConstructJob.
Dan Gohman4e480202016-01-07 00:32:04 +00006858 if (areOptimizationsEnabled(Args))
6859 CmdArgs.push_back("--gc-sections");
Dan Gohman1aa58282016-01-06 19:43:32 +00006860
Dan Gohman57b62c52016-02-22 19:26:15 +00006861 if (Args.hasArg(options::OPT_rdynamic))
6862 CmdArgs.push_back("-export-dynamic");
6863 if (Args.hasArg(options::OPT_s))
6864 CmdArgs.push_back("--strip-all");
6865 if (Args.hasArg(options::OPT_shared))
6866 CmdArgs.push_back("-shared");
6867 if (Args.hasArg(options::OPT_static))
6868 CmdArgs.push_back("-Bstatic");
6869
6870 Args.AddAllArgs(CmdArgs, options::OPT_L);
6871 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
6872
6873 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
6874 if (Args.hasArg(options::OPT_shared))
6875 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("rcrt1.o")));
6876 else if (Args.hasArg(options::OPT_pie))
6877 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("Scrt1.o")));
6878 else
6879 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
6880
6881 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6882 }
6883
6884 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6885
6886 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6887 if (D.CCCIsCXX())
6888 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6889
6890 if (Args.hasArg(options::OPT_pthread))
6891 CmdArgs.push_back("-lpthread");
6892
6893 CmdArgs.push_back("-lc");
6894 CmdArgs.push_back("-lcompiler_rt");
6895 }
6896
6897 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
6898 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6899
Dan Gohman52816862015-12-16 23:30:41 +00006900 CmdArgs.push_back("-o");
6901 CmdArgs.push_back(Output.getFilename());
Dan Gohman57b62c52016-02-22 19:26:15 +00006902
Dan Gohman52816862015-12-16 23:30:41 +00006903 C.addCommand(llvm::make_unique<Command>(JA, *this, Linker, CmdArgs, Inputs));
6904}
6905
Renato Golin7c542b42015-07-27 23:44:45 +00006906const std::string arm::getARMArch(StringRef Arch, const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00006907 std::string MArch;
Renato Goline17c5802015-07-27 23:44:42 +00006908 if (!Arch.empty())
6909 MArch = Arch;
6910 else
Bernard Ogden31561762013-12-12 13:27:11 +00006911 MArch = Triple.getArchName();
Bradley Smithbbf5a002015-11-18 16:33:48 +00006912 MArch = StringRef(MArch).split("+").first.lower();
John Brawn94fd9632015-05-21 12:19:49 +00006913
6914 // Handle -march=native.
6915 if (MArch == "native") {
6916 std::string CPU = llvm::sys::getHostCPUName();
6917 if (CPU != "generic") {
6918 // Translate the native cpu into the architecture suffix for that CPU.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006919 StringRef Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006920 // If there is no valid architecture suffix for this CPU we don't know how
6921 // to handle it, so return no architecture.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006922 if (Suffix.empty())
John Brawn94fd9632015-05-21 12:19:49 +00006923 MArch = "";
6924 else
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006925 MArch = std::string("arm") + Suffix.str();
John Brawn94fd9632015-05-21 12:19:49 +00006926 }
6927 }
6928
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006929 return MArch;
6930}
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006931
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006932/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006933StringRef arm::getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple) {
Renato Goline17c5802015-07-27 23:44:42 +00006934 std::string MArch = getARMArch(Arch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006935 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
6936 // here means an -march=native that we can't handle, so instead return no CPU.
6937 if (MArch.empty())
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006938 return StringRef();
Bernard Ogden31561762013-12-12 13:27:11 +00006939
John Brawna95c1a82015-05-08 12:52:18 +00006940 // We need to return an empty string here on invalid MArch values as the
6941 // various places that call this function can't cope with a null result.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006942 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00006943}
6944
6945/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Renato Golin7c542b42015-07-27 23:44:45 +00006946std::string arm::getARMTargetCPU(StringRef CPU, StringRef Arch,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006947 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00006948 // FIXME: Warn on inconsistent use of -mcpu and -march.
6949 // If we have -mcpu=, use that.
Renato Goline17c5802015-07-27 23:44:42 +00006950 if (!CPU.empty()) {
Bradley Smithbbf5a002015-11-18 16:33:48 +00006951 std::string MCPU = StringRef(CPU).split("+").first.lower();
Bernard Ogden31561762013-12-12 13:27:11 +00006952 // Handle -mcpu=native.
6953 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00006954 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00006955 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00006956 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00006957 }
6958
Renato Goline17c5802015-07-27 23:44:42 +00006959 return getARMCPUForMArch(Arch, Triple);
Bernard Ogden31561762013-12-12 13:27:11 +00006960}
6961
6962/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006963/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00006964// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006965StringRef arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
6966 const llvm::Triple &Triple) {
6967 unsigned ArchKind;
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006968 if (CPU == "generic") {
Vladimir Sukhareva317dfb2015-09-24 10:06:44 +00006969 std::string ARMArch = tools::arm::getARMArch(Arch, Triple);
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00006970 ArchKind = llvm::ARM::parseArch(ARMArch);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006971 if (ArchKind == llvm::ARM::AK_INVALID)
6972 // In case of generic Arch, i.e. "arm",
6973 // extract arch from default cpu of the Triple
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00006974 ArchKind = llvm::ARM::parseCPUArch(Triple.getARMCPUForArch(ARMArch));
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006975 } else {
Tim Northover6f3ff222015-10-30 16:30:27 +00006976 // FIXME: horrible hack to get around the fact that Cortex-A7 is only an
6977 // armv7k triple if it's actually been specified via "-arch armv7k".
6978 ArchKind = (Arch == "armv7k" || Arch == "thumbv7k")
Aaron Ballman43059102015-11-04 14:43:43 +00006979 ? (unsigned)llvm::ARM::AK_ARMV7K
Tim Northover6f3ff222015-10-30 16:30:27 +00006980 : llvm::ARM::parseCPUArch(CPU);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006981 }
Renato Golin3c007252015-05-28 15:05:53 +00006982 if (ArchKind == llvm::ARM::AK_INVALID)
6983 return "";
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00006984 return llvm::ARM::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00006985}
6986
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006987void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006988 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006989 if (Args.hasArg(options::OPT_r))
6990 return;
6991
John Brawn94fd9632015-05-21 12:19:49 +00006992 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
6993 // to generate BE-8 executables.
6994 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
6995 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006996}
6997
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006998mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
Daniel Sanderse0395a72015-09-24 10:22:17 +00006999 // Strictly speaking, mips32r2 and mips64r2 are NanLegacy-only since Nan2008
7000 // was first introduced in Release 3. However, other compilers have
7001 // traditionally allowed it for Release 2 so we should do the same.
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007002 return (NanEncoding)llvm::StringSwitch<int>(CPU)
7003 .Case("mips1", NanLegacy)
7004 .Case("mips2", NanLegacy)
7005 .Case("mips3", NanLegacy)
7006 .Case("mips4", NanLegacy)
7007 .Case("mips5", NanLegacy)
7008 .Case("mips32", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00007009 .Case("mips32r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007010 .Case("mips32r3", NanLegacy | Nan2008)
7011 .Case("mips32r5", NanLegacy | Nan2008)
7012 .Case("mips32r6", Nan2008)
7013 .Case("mips64", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00007014 .Case("mips64r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007015 .Case("mips64r3", NanLegacy | Nan2008)
7016 .Case("mips64r5", NanLegacy | Nan2008)
7017 .Case("mips64r6", Nan2008)
7018 .Default(NanLegacy);
7019}
7020
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007021bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
7022 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
7023 return A && (A->getValue() == StringRef(Value));
7024}
7025
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007026bool mips::isUCLibc(const ArgList &Args) {
7027 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00007028 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007029}
7030
Daniel Sanders2bf13662014-07-10 14:40:57 +00007031bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007032 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
7033 return llvm::StringSwitch<bool>(NaNArg->getValue())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007034 .Case("2008", true)
7035 .Case("legacy", false)
7036 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007037
7038 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00007039 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007040 .Cases("mips32r6", "mips64r6", true)
7041 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007042
7043 return false;
7044}
7045
Petar Jovanovic3ca16222016-05-18 12:46:06 +00007046bool mips::isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName) {
7047 if (!Triple.isAndroid())
7048 return false;
7049
7050 // Android MIPS32R6 defaults to FP64A.
7051 return llvm::StringSwitch<bool>(CPUName)
7052 .Case("mips32r6", true)
7053 .Default(false);
7054}
7055
Daniel Sanders379d44b2014-07-16 11:52:23 +00007056bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007057 StringRef ABIName, mips::FloatABI FloatABI) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00007058 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Petar Jovanovic3ca16222016-05-18 12:46:06 +00007059 Triple.getVendor() != llvm::Triple::MipsTechnologies &&
7060 !Triple.isAndroid())
Daniel Sanders379d44b2014-07-16 11:52:23 +00007061 return false;
7062
7063 if (ABIName != "32")
7064 return false;
7065
Toma Tabacu94ea6862015-06-16 13:54:13 +00007066 // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is
7067 // present.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007068 if (FloatABI == mips::FloatABI::Soft)
Toma Tabacu94ea6862015-06-16 13:54:13 +00007069 return false;
7070
Daniel Sanders379d44b2014-07-16 11:52:23 +00007071 return llvm::StringSwitch<bool>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007072 .Cases("mips2", "mips3", "mips4", "mips5", true)
7073 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
7074 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
7075 .Default(false);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007076}
7077
Toma Tabacu94ea6862015-06-16 13:54:13 +00007078bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple,
7079 StringRef CPUName, StringRef ABIName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007080 mips::FloatABI FloatABI) {
Toma Tabacu94ea6862015-06-16 13:54:13 +00007081 bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
7082
7083 // FPXX shouldn't be used if -msingle-float is present.
7084 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
7085 options::OPT_mdouble_float))
7086 if (A->getOption().matches(options::OPT_msingle_float))
7087 UseFPXX = false;
7088
7089 return UseFPXX;
7090}
7091
Tim Northover157d9112014-01-16 08:48:16 +00007092llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00007093 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
7094 // archs which Darwin doesn't use.
7095
7096 // The matching this routine does is fairly pointless, since it is neither the
7097 // complete architecture list, nor a reasonable subset. The problem is that
7098 // historically the driver driver accepts this and also ties its -march=
7099 // handling to the architecture name, so we need to be careful before removing
7100 // support for it.
7101
7102 // This code must be kept in sync with Clang's Darwin specific argument
7103 // translation.
7104
7105 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007106 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
7107 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
7108 .Case("ppc64", llvm::Triple::ppc64)
7109 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
7110 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
7111 llvm::Triple::x86)
7112 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
7113 // This is derived from the driver driver.
7114 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
7115 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
7116 .Cases("armv7s", "xscale", llvm::Triple::arm)
7117 .Case("arm64", llvm::Triple::aarch64)
7118 .Case("r600", llvm::Triple::r600)
7119 .Case("amdgcn", llvm::Triple::amdgcn)
7120 .Case("nvptx", llvm::Triple::nvptx)
7121 .Case("nvptx64", llvm::Triple::nvptx64)
7122 .Case("amdil", llvm::Triple::amdil)
7123 .Case("spir", llvm::Triple::spir)
7124 .Default(llvm::Triple::UnknownArch);
Rafael Espindoladcbf6982012-10-31 18:51:07 +00007125}
Tony Linthicum76329bf2011-12-12 21:14:55 +00007126
Tim Northover157d9112014-01-16 08:48:16 +00007127void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007128 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00007129 T.setArch(Arch);
7130
7131 if (Str == "x86_64h")
7132 T.setArchName(Str);
7133 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
7134 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00007135 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00007136 }
7137}
7138
Bob Wilsondecc03e2012-11-23 06:14:39 +00007139const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00007140 const InputInfo &Input) {
7141 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007142}
7143
Bob Wilsondecc03e2012-11-23 06:14:39 +00007144const char *Clang::getBaseInputStem(const ArgList &Args,
7145 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00007146 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007147
Chris Lattner906bb902011-01-16 08:14:11 +00007148 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00007149 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007150
7151 return Str;
7152}
7153
Bob Wilsondecc03e2012-11-23 06:14:39 +00007154const char *Clang::getDependencyFileName(const ArgList &Args,
7155 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007156 // FIXME: Think about this more.
7157 std::string Res;
7158
7159 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00007160 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007161 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00007162 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00007163 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00007164 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00007165 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007166}
7167
Douglas Katzman95354292015-06-23 20:42:09 +00007168void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7169 const InputInfo &Output,
7170 const InputInfoList &Inputs,
7171 const ArgList &Args,
7172 const char *LinkingOutput) const {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007173 const ToolChain &ToolChain = getToolChain();
7174 const Driver &D = ToolChain.getDriver();
7175 ArgStringList CmdArgs;
7176
7177 // Silence warning for "clang -g foo.o -o foo"
7178 Args.ClaimAllArgs(options::OPT_g_Group);
7179 // and "clang -emit-llvm foo.o -o foo"
7180 Args.ClaimAllArgs(options::OPT_emit_llvm);
7181 // and for "clang -w foo.o -o foo". Other warning options are already
7182 // handled somewhere else.
7183 Args.ClaimAllArgs(options::OPT_w);
7184
7185 if (!D.SysRoot.empty())
7186 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7187
7188 // CloudABI only supports static linkage.
7189 CmdArgs.push_back("-Bstatic");
Ed Schouten506f2952016-04-06 15:37:06 +00007190
7191 // CloudABI uses Position Independent Executables exclusively.
7192 CmdArgs.push_back("-pie");
7193 CmdArgs.push_back("--no-dynamic-linker");
7194 CmdArgs.push_back("-zrelro");
7195
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007196 CmdArgs.push_back("--eh-frame-hdr");
7197 CmdArgs.push_back("--gc-sections");
7198
7199 if (Output.isFilename()) {
7200 CmdArgs.push_back("-o");
7201 CmdArgs.push_back(Output.getFilename());
7202 } else {
7203 assert(Output.isNothing() && "Invalid output.");
7204 }
7205
Douglas Katzman78b37b02015-11-17 20:28:07 +00007206 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007207 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
7208 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
7209 }
7210
7211 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +00007212 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007213 Args.AddAllArgs(CmdArgs,
7214 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
7215 options::OPT_t, options::OPT_Z_Flag, options::OPT_r});
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007216
Teresa Johnson945bc502015-10-15 20:35:53 +00007217 if (D.isUsingLTO())
7218 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007219
7220 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7221
Douglas Katzman78b37b02015-11-17 20:28:07 +00007222 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007223 if (D.CCCIsCXX())
7224 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
7225 CmdArgs.push_back("-lc");
7226 CmdArgs.push_back("-lcompiler_rt");
7227 }
7228
Douglas Katzman78b37b02015-11-17 20:28:07 +00007229 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007230 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
7231
7232 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007233 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007234}
7235
Douglas Katzman95354292015-06-23 20:42:09 +00007236void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7237 const InputInfo &Output,
7238 const InputInfoList &Inputs,
7239 const ArgList &Args,
7240 const char *LinkingOutput) const {
Daniel Dunbarbe220842009-03-20 16:06:39 +00007241 ArgStringList CmdArgs;
7242
7243 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
7244 const InputInfo &Input = Inputs[0];
7245
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007246 // Determine the original source input.
7247 const Action *SourceAction = &JA;
7248 while (SourceAction->getKind() != Action::InputClass) {
7249 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
7250 SourceAction = SourceAction->getInputs()[0];
7251 }
7252
Eric Christopherf5a8f492015-12-08 00:10:10 +00007253 // If -fno-integrated-as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00007254 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00007255 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
7256 // FIXME: at run-time detect assembler capabilities or rely on version
Eric Christopherf5a8f492015-12-08 00:10:10 +00007257 // information forwarded by -target-assembler-version.
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00007258 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00007259 const llvm::Triple &T(getToolChain().getTriple());
7260 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00007261 CmdArgs.push_back("-Q");
7262 }
Kevin Enderby319baa42013-11-18 23:30:29 +00007263
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007264 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00007265 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007266 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00007267 if (Args.hasArg(options::OPT_gstabs))
7268 CmdArgs.push_back("--gstabs");
7269 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00007270 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00007271 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007272
Daniel Dunbarbe220842009-03-20 16:06:39 +00007273 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00007274 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00007275
Daniel Dunbar6d484762010-07-22 01:47:22 +00007276 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00007277 if (getToolChain().getArch() == llvm::Triple::x86 ||
7278 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00007279 Args.hasArg(options::OPT_force__cpusubtype__ALL))
7280 CmdArgs.push_back("-force_cpusubtype_ALL");
7281
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00007282 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00007283 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00007284 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00007285 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00007286 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007287 CmdArgs.push_back("-static");
7288
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007289 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarbe220842009-03-20 16:06:39 +00007290
7291 assert(Output.isFilename() && "Unexpected lipo output.");
7292 CmdArgs.push_back("-o");
7293 CmdArgs.push_back(Output.getFilename());
7294
Daniel Dunbarb440f562010-08-02 02:38:21 +00007295 assert(Input.isFilename() && "Invalid input.");
7296 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00007297
7298 // asm_final spec is empty.
7299
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007300 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007301 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00007302}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007303
Tim Northover157d9112014-01-16 08:48:16 +00007304void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00007305
Tim Northover157d9112014-01-16 08:48:16 +00007306void darwin::MachOTool::AddMachOArch(const ArgList &Args,
7307 ArgStringList &CmdArgs) const {
7308 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007309
Daniel Dunbarc1964212009-03-26 16:23:12 +00007310 // Derived from darwin_arch spec.
7311 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007312 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00007313
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007314 // FIXME: Is this needed anymore?
7315 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00007316 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00007317}
7318
Douglas Katzman95354292015-06-23 20:42:09 +00007319bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
Bill Wendling3b2000f2012-10-02 18:02:50 +00007320 // We only need to generate a temp path for LTO if we aren't compiling object
7321 // files. When compiling source files, we run 'dsymutil' after linking. We
7322 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007323 for (const auto &Input : Inputs)
7324 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00007325 return true;
7326
7327 return false;
7328}
7329
Douglas Katzman95354292015-06-23 20:42:09 +00007330void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
7331 ArgStringList &CmdArgs,
7332 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007333 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00007334 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00007335
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00007336 unsigned Version[5] = {0, 0, 0, 0, 0};
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007337 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00007338 if (!Driver::GetReleaseVersion(A->getValue(), Version))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007339 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007340 }
7341
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00007342 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007343 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00007344 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7345 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007346
Bob Wilson3d27dad2013-08-02 22:25:34 +00007347 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
7348 CmdArgs.push_back("-export_dynamic");
7349
Bob Wilsonb111ec92015-03-02 19:01:14 +00007350 // If we are using App Extension restrictions, pass a flag to the linker
7351 // telling it that the compiled code has been audited.
7352 if (Args.hasFlag(options::OPT_fapplication_extension,
7353 options::OPT_fno_application_extension, false))
7354 CmdArgs.push_back("-application_extension");
7355
Teresa Johnson945bc502015-10-15 20:35:53 +00007356 if (D.isUsingLTO()) {
Bruno Cardoso Lopesa5efe3a2015-10-02 15:10:33 +00007357 // If we are using LTO, then automatically create a temporary file path for
7358 // the linker to use, so that it's lifetime will extend past a possible
7359 // dsymutil step.
7360 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
7361 const char *TmpPath = C.getArgs().MakeArgString(
7362 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
7363 C.addTempFile(TmpPath);
7364 CmdArgs.push_back("-object_path_lto");
7365 CmdArgs.push_back(TmpPath);
7366 }
7367
7368 // Use -lto_library option to specify the libLTO.dylib path. Try to find
7369 // it in clang installed libraries. If not found, the option is not used
7370 // and 'ld' will use its default mechanism to search for libLTO.dylib.
7371 if (Version[0] >= 133) {
7372 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
7373 StringRef P = llvm::sys::path::parent_path(D.getInstalledDir());
7374 SmallString<128> LibLTOPath(P);
7375 llvm::sys::path::append(LibLTOPath, "lib");
7376 llvm::sys::path::append(LibLTOPath, "libLTO.dylib");
7377 if (llvm::sys::fs::exists(LibLTOPath)) {
7378 CmdArgs.push_back("-lto_library");
7379 CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));
7380 } else {
7381 D.Diag(diag::warn_drv_lto_libpath);
7382 }
7383 }
Daniel Dunbaref889c72011-06-21 20:55:11 +00007384 }
7385
Daniel Dunbarc1964212009-03-26 16:23:12 +00007386 // Derived from the "link" spec.
7387 Args.AddAllArgs(CmdArgs, options::OPT_static);
7388 if (!Args.hasArg(options::OPT_static))
7389 CmdArgs.push_back("-dynamic");
7390 if (Args.hasArg(options::OPT_fgnu_runtime)) {
7391 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
7392 // here. How do we wish to handle such things?
7393 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007394
Daniel Dunbarc1964212009-03-26 16:23:12 +00007395 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00007396 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00007397 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00007398 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007399
7400 Args.AddLastArg(CmdArgs, options::OPT_bundle);
7401 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
7402 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
7403
7404 Arg *A;
7405 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
7406 (A = Args.getLastArg(options::OPT_current__version)) ||
7407 (A = Args.getLastArg(options::OPT_install__name)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007408 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
7409 << "-dynamiclib";
Daniel Dunbarc1964212009-03-26 16:23:12 +00007410
7411 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
7412 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
7413 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
7414 } else {
7415 CmdArgs.push_back("-dylib");
7416
7417 Arg *A;
7418 if ((A = Args.getLastArg(options::OPT_bundle)) ||
7419 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
7420 (A = Args.getLastArg(options::OPT_client__name)) ||
7421 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
7422 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
7423 (A = Args.getLastArg(options::OPT_private__bundle)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007424 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
7425 << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007426
Daniel Dunbarc1964212009-03-26 16:23:12 +00007427 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
7428 "-dylib_compatibility_version");
7429 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
7430 "-dylib_current_version");
7431
Tim Northover157d9112014-01-16 08:48:16 +00007432 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007433
7434 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
7435 "-dylib_install_name");
7436 }
7437
7438 Args.AddLastArg(CmdArgs, options::OPT_all__load);
7439 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
7440 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00007441 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007442 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007443 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
7444 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
7445 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
7446 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
7447 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
7448 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00007449 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007450 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
7451 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
7452 Args.AddAllArgs(CmdArgs, options::OPT_init);
7453
Daniel Dunbarc44d3132011-04-28 21:23:41 +00007454 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00007455 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00007456
Daniel Dunbarc1964212009-03-26 16:23:12 +00007457 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
7458 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
7459 Args.AddLastArg(CmdArgs, options::OPT_single__module);
7460 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
7461 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007462
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007463 if (const Arg *A =
7464 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
7465 options::OPT_fno_pie, options::OPT_fno_PIE)) {
Daniel Dunbaraf68a882010-07-13 23:31:40 +00007466 if (A->getOption().matches(options::OPT_fpie) ||
7467 A->getOption().matches(options::OPT_fPIE))
7468 CmdArgs.push_back("-pie");
7469 else
7470 CmdArgs.push_back("-no_pie");
7471 }
Steven Wu574b0f22016-03-01 01:07:58 +00007472 // for embed-bitcode, use -bitcode_bundle in linker command
7473 if (C.getDriver().embedBitcodeEnabled() ||
7474 C.getDriver().embedBitcodeMarkerOnly()) {
7475 // Check if the toolchain supports bitcode build flow.
7476 if (MachOTC.SupportsEmbeddedBitcode())
7477 CmdArgs.push_back("-bitcode_bundle");
7478 else
7479 D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
7480 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00007481
7482 Args.AddLastArg(CmdArgs, options::OPT_prebind);
7483 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
7484 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
7485 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
7486 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
7487 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
7488 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
7489 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
7490 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
7491 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
7492 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
7493 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
7494 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
7495 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
7496 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
7497 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007498
Daniel Dunbar84384642011-05-02 21:03:47 +00007499 // Give --sysroot= preference, over the Apple specific behavior to also use
7500 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00007501 StringRef sysroot = C.getSysRoot();
7502 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00007503 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00007504 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00007505 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
7506 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00007507 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007508 }
7509
Daniel Dunbarc1964212009-03-26 16:23:12 +00007510 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
7511 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
7512 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
7513 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
7514 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007515 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007516 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
7517 Args.AddAllArgs(CmdArgs, options::OPT_y);
7518 Args.AddLastArg(CmdArgs, options::OPT_w);
7519 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
7520 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
7521 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
7522 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
7523 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
7524 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
7525 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
7526 Args.AddLastArg(CmdArgs, options::OPT_whyload);
7527 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
7528 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
7529 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
7530 Args.AddLastArg(CmdArgs, options::OPT_Mach);
7531}
7532
Douglas Katzman95354292015-06-23 20:42:09 +00007533void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7534 const InputInfo &Output,
7535 const InputInfoList &Inputs,
7536 const ArgList &Args,
7537 const char *LinkingOutput) const {
Daniel Dunbarc1964212009-03-26 16:23:12 +00007538 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00007539
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007540 // If the number of arguments surpasses the system limits, we will encode the
7541 // input files in a separate file, shortening the command line. To this end,
7542 // build a list of input file names that can be passed via a file with the
7543 // -filelist linker option.
7544 llvm::opt::ArgStringList InputFileList;
7545
Daniel Dunbarc1964212009-03-26 16:23:12 +00007546 // The logic here is derived from gcc's behavior; most of which
7547 // comes from specs (starting with link_command). Consult gcc for
7548 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00007549 ArgStringList CmdArgs;
7550
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007551 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
7552 if (Args.hasArg(options::OPT_ccc_arcmt_check,
7553 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007554 for (const auto &Arg : Args)
7555 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007556 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007557 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007558 CmdArgs.push_back(Output.getFilename());
Justin Bognerd3371d82015-07-17 03:35:54 +00007559 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007560 return;
7561 }
7562
Daniel Dunbarc1964212009-03-26 16:23:12 +00007563 // I'm not sure why this particular decomposition exists in gcc, but
7564 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00007565 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007566
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007567 // It seems that the 'e' option is completely ignored for dynamic executables
7568 // (the default), and with static executables, the last one wins, as expected.
7569 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
7570 options::OPT_Z_Flag, options::OPT_u_Group,
7571 options::OPT_e, options::OPT_r});
Daniel Dunbarc1964212009-03-26 16:23:12 +00007572
Daniel Dunbar767bbab2010-10-18 22:08:36 +00007573 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
7574 // members of static archive libraries which implement Objective-C classes or
7575 // categories.
7576 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
7577 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007578
Daniel Dunbarc1964212009-03-26 16:23:12 +00007579 CmdArgs.push_back("-o");
7580 CmdArgs.push_back(Output.getFilename());
7581
Douglas Katzman78b37b02015-11-17 20:28:07 +00007582 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
Tim Northover157d9112014-01-16 08:48:16 +00007583 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007584
Peter Collingbournec4122c12015-06-15 21:08:13 +00007585 // SafeStack requires its own runtime libraries
7586 // These libraries should be linked first, to make sure the
7587 // __safestack_init constructor executes before everything else
7588 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
7589 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
7590 "libclang_rt.safestack_osx.a",
7591 /*AlwaysLink=*/true);
7592 }
7593
Daniel Dunbarc1964212009-03-26 16:23:12 +00007594 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007595
Douglas Gregor9295df02012-05-15 21:00:27 +00007596 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007597 // Build the input file for -filelist (list of linker input files) in case we
7598 // need it later
7599 for (const auto &II : Inputs) {
7600 if (!II.isFilename()) {
7601 // This is a linker input argument.
7602 // We cannot mix input arguments and file names in a -filelist input, thus
7603 // we prematurely stop our list (remaining files shall be passed as
7604 // arguments).
7605 if (InputFileList.size() > 0)
7606 break;
7607
7608 continue;
7609 }
7610
7611 InputFileList.push_back(II.getFilename());
7612 }
7613
Douglas Katzman78b37b02015-11-17 20:28:07 +00007614 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
Joerg Sonnenberger5c3f9d52015-09-23 20:07:56 +00007615 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
7616
Douglas Katzman78b37b02015-11-17 20:28:07 +00007617 if (isObjCRuntimeLinked(Args) &&
7618 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00007619 // We use arclite library for both ARC and subscripting support.
7620 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
7621
Bob Wilson7dda0cd2012-04-21 00:21:42 +00007622 CmdArgs.push_back("-framework");
7623 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00007624 // Link libobj.
7625 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00007626 }
John McCall31168b02011-06-15 23:02:42 +00007627
Daniel Dunbarc1964212009-03-26 16:23:12 +00007628 if (LinkingOutput) {
7629 CmdArgs.push_back("-arch_multiple");
7630 CmdArgs.push_back("-final_output");
7631 CmdArgs.push_back(LinkingOutput);
7632 }
7633
Daniel Dunbarc1964212009-03-26 16:23:12 +00007634 if (Args.hasArg(options::OPT_fnested_functions))
7635 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007636
Justin Bognerc7701242015-05-12 05:44:36 +00007637 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
7638
Douglas Katzman78b37b02015-11-17 20:28:07 +00007639 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007640 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007641 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00007642
Daniel Dunbarc1964212009-03-26 16:23:12 +00007643 // link_ssp spec is empty.
7644
Daniel Dunbar26d482a2009-09-18 08:15:03 +00007645 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00007646 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007647 }
7648
Douglas Katzman78b37b02015-11-17 20:28:07 +00007649 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00007650 // endfile_spec is empty.
7651 }
7652
7653 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7654 Args.AddAllArgs(CmdArgs, options::OPT_F);
7655
Steven Wu3ffb61b2015-02-06 18:08:29 +00007656 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00007657 for (const Arg *A : Args.filtered(options::OPT_iframework))
7658 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00007659
Douglas Katzman78b37b02015-11-17 20:28:07 +00007660 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00007661 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
7662 if (A->getValue() == StringRef("Accelerate")) {
7663 CmdArgs.push_back("-framework");
7664 CmdArgs.push_back("Accelerate");
7665 }
7666 }
7667 }
7668
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007669 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007670 std::unique_ptr<Command> Cmd =
Justin Bognerd3371d82015-07-17 03:35:54 +00007671 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007672 Cmd->setInputFileList(std::move(InputFileList));
7673 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00007674}
7675
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007676void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007677 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007678 const InputInfoList &Inputs,
7679 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007680 const char *LinkingOutput) const {
7681 ArgStringList CmdArgs;
7682
7683 CmdArgs.push_back("-create");
7684 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007685
7686 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007687 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007688
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007689 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007690 assert(II.isFilename() && "Unexpected lipo input.");
7691 CmdArgs.push_back(II.getFilename());
7692 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007693
7694 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007695 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007696}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007697
Daniel Dunbar88299622010-06-04 18:28:36 +00007698void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007699 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00007700 const InputInfoList &Inputs,
7701 const ArgList &Args,
7702 const char *LinkingOutput) const {
7703 ArgStringList CmdArgs;
7704
Daniel Dunbareb86b042011-05-09 17:23:16 +00007705 CmdArgs.push_back("-o");
7706 CmdArgs.push_back(Output.getFilename());
7707
Daniel Dunbar88299622010-06-04 18:28:36 +00007708 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7709 const InputInfo &Input = Inputs[0];
7710 assert(Input.isFilename() && "Unexpected dsymutil input.");
7711 CmdArgs.push_back(Input.getFilename());
7712
Daniel Dunbar88299622010-06-04 18:28:36 +00007713 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007714 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007715 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar88299622010-06-04 18:28:36 +00007716}
7717
Eric Christopher551ef452011-08-23 17:56:55 +00007718void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00007719 const InputInfo &Output,
7720 const InputInfoList &Inputs,
7721 const ArgList &Args,
7722 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00007723 ArgStringList CmdArgs;
7724 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00007725 CmdArgs.push_back("--debug-info");
7726 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00007727 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00007728
7729 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7730 const InputInfo &Input = Inputs[0];
7731 assert(Input.isFilename() && "Unexpected verify input");
7732
7733 // Grabbing the output of the earlier dsymutil run.
7734 CmdArgs.push_back(Input.getFilename());
7735
7736 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007737 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007738 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher551ef452011-08-23 17:56:55 +00007739}
7740
Douglas Katzman95354292015-06-23 20:42:09 +00007741void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
David Chisnallf571cde2012-02-15 13:39:01 +00007742 const InputInfo &Output,
7743 const InputInfoList &Inputs,
7744 const ArgList &Args,
7745 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007746 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00007747 ArgStringList CmdArgs;
7748
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007749 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
David Chisnallf571cde2012-02-15 13:39:01 +00007750
7751 CmdArgs.push_back("-o");
7752 CmdArgs.push_back(Output.getFilename());
7753
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007754 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00007755 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00007756
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007757 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007758 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007759}
7760
Douglas Katzman95354292015-06-23 20:42:09 +00007761void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7762 const InputInfo &Output,
7763 const InputInfoList &Inputs,
7764 const ArgList &Args,
7765 const char *LinkingOutput) const {
David Chisnallf571cde2012-02-15 13:39:01 +00007766 ArgStringList CmdArgs;
7767
David Chisnall272a0712012-02-29 15:06:12 +00007768 // Demangle C++ names in errors
7769 CmdArgs.push_back("-C");
7770
Douglas Katzman78b37b02015-11-17 20:28:07 +00007771 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
David Chisnallf571cde2012-02-15 13:39:01 +00007772 CmdArgs.push_back("-e");
7773 CmdArgs.push_back("_start");
7774 }
7775
7776 if (Args.hasArg(options::OPT_static)) {
7777 CmdArgs.push_back("-Bstatic");
7778 CmdArgs.push_back("-dn");
7779 } else {
7780 CmdArgs.push_back("-Bdynamic");
7781 if (Args.hasArg(options::OPT_shared)) {
7782 CmdArgs.push_back("-shared");
7783 } else {
7784 CmdArgs.push_back("--dynamic-linker");
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007785 CmdArgs.push_back(
7786 Args.MakeArgString(getToolChain().GetFilePath("ld.so.1")));
David Chisnallf571cde2012-02-15 13:39:01 +00007787 }
7788 }
7789
7790 if (Output.isFilename()) {
7791 CmdArgs.push_back("-o");
7792 CmdArgs.push_back(Output.getFilename());
7793 } else {
7794 assert(Output.isNothing() && "Invalid output.");
7795 }
7796
Douglas Katzman78b37b02015-11-17 20:28:07 +00007797 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007798 if (!Args.hasArg(options::OPT_shared))
7799 CmdArgs.push_back(
7800 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7801
7802 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7803 CmdArgs.push_back(
7804 Args.MakeArgString(getToolChain().GetFilePath("values-Xa.o")));
7805 CmdArgs.push_back(
7806 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007807 }
7808
Douglas Katzman6059ef92015-11-17 17:41:23 +00007809 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00007810
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007811 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7812 options::OPT_e, options::OPT_r});
David Chisnallf571cde2012-02-15 13:39:01 +00007813
7814 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7815
Douglas Katzman78b37b02015-11-17 20:28:07 +00007816 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007817 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00007818 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00007819 CmdArgs.push_back("-lgcc_s");
Rafael Espindola8d4d9d2f2015-09-14 19:30:53 +00007820 CmdArgs.push_back("-lc");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007821 if (!Args.hasArg(options::OPT_shared)) {
7822 CmdArgs.push_back("-lgcc");
David Chisnallc73fb892012-02-28 20:06:45 +00007823 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007824 }
David Chisnallf571cde2012-02-15 13:39:01 +00007825 }
7826
Douglas Katzman78b37b02015-11-17 20:28:07 +00007827 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007828 CmdArgs.push_back(
7829 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007830 }
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007831 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007832
Xinliang David Li69306c02015-10-22 06:15:31 +00007833 getToolChain().addProfileRTLibs(Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00007834
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007835 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007836 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007837}
7838
Douglas Katzman95354292015-06-23 20:42:09 +00007839void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7840 const InputInfo &Output,
7841 const InputInfoList &Inputs,
7842 const ArgList &Args,
7843 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007844 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007845 ArgStringList CmdArgs;
7846
Rafael Espindolacc126272014-02-28 01:55:21 +00007847 switch (getToolChain().getArch()) {
7848 case llvm::Triple::x86:
7849 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
7850 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007851 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00007852 break;
7853
7854 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007855 CmdArgs.push_back("-mppc");
7856 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00007857 break;
7858
7859 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007860 case llvm::Triple::sparcel: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007861 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007862 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7863 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7864 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007865 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007866 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007867
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007868 case llvm::Triple::sparcv9: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007869 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007870 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7871 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7872 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007873 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007874 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007875
7876 case llvm::Triple::mips64:
7877 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007878 StringRef CPUName;
7879 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007880 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007881
7882 CmdArgs.push_back("-mabi");
7883 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7884
7885 if (getToolChain().getArch() == llvm::Triple::mips64)
7886 CmdArgs.push_back("-EB");
7887 else
7888 CmdArgs.push_back("-EL");
7889
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007890 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007891 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007892 }
7893
Rafael Espindolacc126272014-02-28 01:55:21 +00007894 default:
7895 break;
7896 }
7897
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007898 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007899
7900 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007901 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007902
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007903 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007904 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007905
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007906 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007907 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007908}
7909
Douglas Katzman95354292015-06-23 20:42:09 +00007910void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7911 const InputInfo &Output,
7912 const InputInfoList &Inputs,
7913 const ArgList &Args,
7914 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007915 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007916 ArgStringList CmdArgs;
7917
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00007918 // Silence warning for "clang -g foo.o -o foo"
7919 Args.ClaimAllArgs(options::OPT_g_Group);
7920 // and "clang -emit-llvm foo.o -o foo"
7921 Args.ClaimAllArgs(options::OPT_emit_llvm);
7922 // and for "clang -w foo.o -o foo". Other warning options are already
7923 // handled somewhere else.
7924 Args.ClaimAllArgs(options::OPT_w);
7925
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007926 if (getToolChain().getArch() == llvm::Triple::mips64)
7927 CmdArgs.push_back("-EB");
7928 else if (getToolChain().getArch() == llvm::Triple::mips64el)
7929 CmdArgs.push_back("-EL");
7930
Douglas Katzman78b37b02015-11-17 20:28:07 +00007931 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007932 CmdArgs.push_back("-e");
7933 CmdArgs.push_back("__start");
7934 }
7935
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007936 if (Args.hasArg(options::OPT_static)) {
7937 CmdArgs.push_back("-Bstatic");
7938 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007939 if (Args.hasArg(options::OPT_rdynamic))
7940 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007941 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007942 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007943 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007944 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007945 } else {
7946 CmdArgs.push_back("-dynamic-linker");
7947 CmdArgs.push_back("/usr/libexec/ld.so");
7948 }
7949 }
7950
Rafael Espindola044f7832013-06-05 04:28:55 +00007951 if (Args.hasArg(options::OPT_nopie))
7952 CmdArgs.push_back("-nopie");
7953
Daniel Dunbarb440f562010-08-02 02:38:21 +00007954 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007955 CmdArgs.push_back("-o");
7956 CmdArgs.push_back(Output.getFilename());
7957 } else {
7958 assert(Output.isNothing() && "Invalid output.");
7959 }
7960
Douglas Katzman78b37b02015-11-17 20:28:07 +00007961 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007962 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007963 if (Args.hasArg(options::OPT_pg))
7964 CmdArgs.push_back(
7965 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman3715d1f2011-12-15 02:15:56 +00007966 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007967 CmdArgs.push_back(
7968 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7969 CmdArgs.push_back(
7970 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007971 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007972 CmdArgs.push_back(
7973 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007974 }
7975 }
7976
Edward O'Callaghan5c521462009-10-28 15:13:08 +00007977 std::string Triple = getToolChain().getTripleString();
7978 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007979 Triple.replace(0, 6, "amd64");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007980 CmdArgs.push_back(
7981 Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007982
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007983 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7984 options::OPT_e, options::OPT_s, options::OPT_t,
7985 options::OPT_Z_Flag, options::OPT_r});
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007986
Daniel Dunbar54423b22010-09-17 00:24:54 +00007987 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007988
Douglas Katzman78b37b02015-11-17 20:28:07 +00007989 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007990 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007991 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007992 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00007993 CmdArgs.push_back("-lm_p");
7994 else
7995 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00007996 }
7997
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007998 // FIXME: For some reason GCC passes -lgcc before adding
7999 // the default system libraries. Just mimic this for now.
8000 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008001
Eric Christopher17674ec2012-09-13 06:32:34 +00008002 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008003 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
8004 CmdArgs.push_back("-lpthread_p");
Eric Christopher17674ec2012-09-13 06:32:34 +00008005 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008006 CmdArgs.push_back("-lpthread");
Eric Christopher17674ec2012-09-13 06:32:34 +00008007 }
8008
Chandler Carruth45661652011-12-17 22:32:42 +00008009 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00008010 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008011 CmdArgs.push_back("-lc_p");
Eli Friedman3715d1f2011-12-15 02:15:56 +00008012 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008013 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00008014 }
Eric Christopher17674ec2012-09-13 06:32:34 +00008015
Daniel Dunbara8888ac2009-08-03 01:28:59 +00008016 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008017 }
8018
Douglas Katzman78b37b02015-11-17 20:28:07 +00008019 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008020 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008021 CmdArgs.push_back(
8022 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008023 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008024 CmdArgs.push_back(
8025 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008026 }
8027
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008028 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008029 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008030}
Ed Schoutene33194b2009-04-02 19:13:12 +00008031
Douglas Katzman95354292015-06-23 20:42:09 +00008032void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8033 const InputInfo &Output,
8034 const InputInfoList &Inputs,
8035 const ArgList &Args,
8036 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008037 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00008038 ArgStringList CmdArgs;
8039
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008040 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Eli Friedman9fa28852012-08-08 23:57:20 +00008041
8042 CmdArgs.push_back("-o");
8043 CmdArgs.push_back(Output.getFilename());
8044
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008045 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00008046 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00008047
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008048 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008049 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00008050}
8051
Douglas Katzman95354292015-06-23 20:42:09 +00008052void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8053 const InputInfo &Output,
8054 const InputInfoList &Inputs,
8055 const ArgList &Args,
8056 const char *LinkingOutput) const {
Eli Friedman9fa28852012-08-08 23:57:20 +00008057 const Driver &D = getToolChain().getDriver();
8058 ArgStringList CmdArgs;
8059
Douglas Katzman78b37b02015-11-17 20:28:07 +00008060 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008061 CmdArgs.push_back("-e");
8062 CmdArgs.push_back("__start");
8063 }
8064
8065 if (Args.hasArg(options::OPT_static)) {
8066 CmdArgs.push_back("-Bstatic");
8067 } else {
8068 if (Args.hasArg(options::OPT_rdynamic))
8069 CmdArgs.push_back("-export-dynamic");
8070 CmdArgs.push_back("--eh-frame-hdr");
8071 CmdArgs.push_back("-Bdynamic");
8072 if (Args.hasArg(options::OPT_shared)) {
8073 CmdArgs.push_back("-shared");
8074 } else {
8075 CmdArgs.push_back("-dynamic-linker");
8076 CmdArgs.push_back("/usr/libexec/ld.so");
8077 }
8078 }
8079
8080 if (Output.isFilename()) {
8081 CmdArgs.push_back("-o");
8082 CmdArgs.push_back(Output.getFilename());
8083 } else {
8084 assert(Output.isNothing() && "Invalid output.");
8085 }
8086
Douglas Katzman78b37b02015-11-17 20:28:07 +00008087 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008088 if (!Args.hasArg(options::OPT_shared)) {
8089 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008090 CmdArgs.push_back(
8091 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008092 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008093 CmdArgs.push_back(
8094 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
8095 CmdArgs.push_back(
8096 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008097 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008098 CmdArgs.push_back(
8099 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008100 }
8101 }
8102
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008103 Args.AddAllArgs(CmdArgs,
8104 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Eli Friedman9fa28852012-08-08 23:57:20 +00008105
8106 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8107
Douglas Katzman78b37b02015-11-17 20:28:07 +00008108 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008109 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008110 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8111 if (Args.hasArg(options::OPT_pg))
8112 CmdArgs.push_back("-lm_p");
8113 else
8114 CmdArgs.push_back("-lm");
8115 }
8116
Rafael Espindola1ad26f02012-10-23 17:07:31 +00008117 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008118 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
Rafael Espindola1ad26f02012-10-23 17:07:31 +00008119 CmdArgs.push_back("-lpthread_p");
8120 else
8121 CmdArgs.push_back("-lpthread");
8122 }
8123
Eli Friedman9fa28852012-08-08 23:57:20 +00008124 if (!Args.hasArg(options::OPT_shared)) {
8125 if (Args.hasArg(options::OPT_pg))
8126 CmdArgs.push_back("-lc_p");
8127 else
8128 CmdArgs.push_back("-lc");
8129 }
8130
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00008131 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008132 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00008133 case llvm::Triple::arm:
8134 MyArch = "arm";
8135 break;
8136 case llvm::Triple::x86:
8137 MyArch = "i386";
8138 break;
8139 case llvm::Triple::x86_64:
8140 MyArch = "amd64";
8141 break;
8142 default:
8143 llvm_unreachable("Unsupported architecture");
8144 }
8145 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00008146 }
8147
Douglas Katzman78b37b02015-11-17 20:28:07 +00008148 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008149 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008150 CmdArgs.push_back(
8151 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008152 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008153 CmdArgs.push_back(
8154 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008155 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00008156
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008157 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008158 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00008159}
8160
Douglas Katzman95354292015-06-23 20:42:09 +00008161void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8162 const InputInfo &Output,
8163 const InputInfoList &Inputs,
8164 const ArgList &Args,
8165 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008166 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008167 ArgStringList CmdArgs;
8168
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008169 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
8170 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008171 switch (getToolChain().getArch()) {
8172 default:
8173 break;
8174 case llvm::Triple::x86:
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008175 CmdArgs.push_back("--32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008176 break;
8177 case llvm::Triple::ppc:
Roman Divacky00859c22011-06-04 07:37:31 +00008178 CmdArgs.push_back("-a32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008179 break;
8180 case llvm::Triple::mips:
8181 case llvm::Triple::mipsel:
8182 case llvm::Triple::mips64:
8183 case llvm::Triple::mips64el: {
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008184 StringRef CPUName;
8185 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008186 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00008187
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008188 CmdArgs.push_back("-march");
8189 CmdArgs.push_back(CPUName.data());
8190
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008191 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00008192 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008193
8194 if (getToolChain().getArch() == llvm::Triple::mips ||
8195 getToolChain().getArch() == llvm::Triple::mips64)
8196 CmdArgs.push_back("-EB");
8197 else
8198 CmdArgs.push_back("-EL");
8199
Dimitry Andric46f338c2015-12-27 10:36:44 +00008200 if (Arg *A = Args.getLastArg(options::OPT_G)) {
8201 StringRef v = A->getValue();
8202 CmdArgs.push_back(Args.MakeArgString("-G" + v));
8203 A->claim();
8204 }
8205
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008206 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008207 break;
8208 }
8209 case llvm::Triple::arm:
8210 case llvm::Triple::armeb:
8211 case llvm::Triple::thumb:
8212 case llvm::Triple::thumbeb: {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008213 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
Renato Golinf4421f72014-02-19 10:44:07 +00008214
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008215 if (ABI == arm::FloatABI::Hard)
Renato Golinf4421f72014-02-19 10:44:07 +00008216 CmdArgs.push_back("-mfpu=vfp");
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008217 else
Renato Golinf4421f72014-02-19 10:44:07 +00008218 CmdArgs.push_back("-mfpu=softvfp");
Renato Golinf4421f72014-02-19 10:44:07 +00008219
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008220 switch (getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00008221 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00008222 case llvm::Triple::GNUEABI:
8223 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00008224 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00008225 break;
8226
8227 default:
8228 CmdArgs.push_back("-matpcs");
8229 }
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008230 break;
8231 }
8232 case llvm::Triple::sparc:
8233 case llvm::Triple::sparcel:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008234 case llvm::Triple::sparcv9: {
8235 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8236 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008237 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008238 break;
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008239 }
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008240 }
Eric Christopher0b26a612010-03-02 02:41:08 +00008241
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008242 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008243
8244 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008245 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008246
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008247 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008248 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008249
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008250 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008251 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008252}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008253
Douglas Katzman95354292015-06-23 20:42:09 +00008254void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8255 const InputInfo &Output,
8256 const InputInfoList &Inputs,
8257 const ArgList &Args,
8258 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008259 const toolchains::FreeBSD &ToolChain =
8260 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00008261 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008262 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008263 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008264 !Args.hasArg(options::OPT_shared) &&
8265 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008266 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00008267
8268 // Silence warning for "clang -g foo.o -o foo"
8269 Args.ClaimAllArgs(options::OPT_g_Group);
8270 // and "clang -emit-llvm foo.o -o foo"
8271 Args.ClaimAllArgs(options::OPT_emit_llvm);
8272 // and for "clang -w foo.o -o foo". Other warning options are already
8273 // handled somewhere else.
8274 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008275
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008276 if (!D.SysRoot.empty())
8277 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8278
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008279 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008280 CmdArgs.push_back("-pie");
8281
Ed Maste1bc232d2016-04-12 21:11:46 +00008282 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008283 if (Args.hasArg(options::OPT_static)) {
8284 CmdArgs.push_back("-Bstatic");
8285 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00008286 if (Args.hasArg(options::OPT_rdynamic))
8287 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008288 if (Args.hasArg(options::OPT_shared)) {
8289 CmdArgs.push_back("-Bshareable");
8290 } else {
8291 CmdArgs.push_back("-dynamic-linker");
8292 CmdArgs.push_back("/libexec/ld-elf.so.1");
8293 }
Roman Divackyafe2f232012-08-28 15:09:03 +00008294 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00008295 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
8296 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
8297 CmdArgs.push_back("--hash-style=both");
8298 }
8299 }
8300 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008301 }
8302
8303 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
8304 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008305 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008306 CmdArgs.push_back("-m");
8307 CmdArgs.push_back("elf_i386_fbsd");
8308 }
8309
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008310 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00008311 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00008312 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00008313 }
8314
Dimitry Andric904895f2015-12-27 06:47:09 +00008315 if (Arg *A = Args.getLastArg(options::OPT_G)) {
8316 if (ToolChain.getArch() == llvm::Triple::mips ||
8317 ToolChain.getArch() == llvm::Triple::mipsel ||
8318 ToolChain.getArch() == llvm::Triple::mips64 ||
8319 ToolChain.getArch() == llvm::Triple::mips64el) {
8320 StringRef v = A->getValue();
8321 CmdArgs.push_back(Args.MakeArgString("-G" + v));
8322 A->claim();
8323 }
8324 }
8325
Daniel Dunbarb440f562010-08-02 02:38:21 +00008326 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008327 CmdArgs.push_back("-o");
8328 CmdArgs.push_back(Output.getFilename());
8329 } else {
8330 assert(Output.isNothing() && "Invalid output.");
8331 }
8332
Douglas Katzman78b37b02015-11-17 20:28:07 +00008333 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008334 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008335 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00008336 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00008337 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008338 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008339 crt1 = "Scrt1.o";
8340 else
8341 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008342 }
Roman Divackyafe2f232012-08-28 15:09:03 +00008343 if (crt1)
8344 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
8345
8346 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8347
Craig Topper92fc2df2014-05-17 16:56:41 +00008348 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00008349 if (Args.hasArg(options::OPT_static))
8350 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008351 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008352 crtbegin = "crtbeginS.o";
8353 else
8354 crtbegin = "crtbegin.o";
8355
8356 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008357 }
8358
8359 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +00008360 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008361 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8362 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00008363 Args.AddAllArgs(CmdArgs, options::OPT_s);
8364 Args.AddAllArgs(CmdArgs, options::OPT_t);
8365 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8366 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008367
Teresa Johnson945bc502015-10-15 20:35:53 +00008368 if (D.isUsingLTO())
8369 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Roman Divackyf0d7f942013-11-10 09:31:43 +00008370
Alexey Samsonov52550342014-09-15 19:58:40 +00008371 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00008372 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008373
Douglas Katzman78b37b02015-11-17 20:28:07 +00008374 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Dimitry Andric0cc6f472015-10-18 13:32:20 +00008375 addOpenMPRuntime(CmdArgs, ToolChain, Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00008376 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00008377 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00008378 if (Args.hasArg(options::OPT_pg))
8379 CmdArgs.push_back("-lm_p");
8380 else
8381 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00008382 }
Alexey Samsonov52550342014-09-15 19:58:40 +00008383 if (NeedsSanitizerDeps)
8384 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008385 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
8386 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00008387 if (Args.hasArg(options::OPT_pg))
8388 CmdArgs.push_back("-lgcc_p");
8389 else
8390 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008391 if (Args.hasArg(options::OPT_static)) {
8392 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00008393 } else if (Args.hasArg(options::OPT_pg)) {
8394 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008395 } else {
8396 CmdArgs.push_back("--as-needed");
8397 CmdArgs.push_back("-lgcc_s");
8398 CmdArgs.push_back("--no-as-needed");
8399 }
8400
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00008401 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00008402 if (Args.hasArg(options::OPT_pg))
8403 CmdArgs.push_back("-lpthread_p");
8404 else
8405 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00008406 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008407
Roman Divacky66f22762011-02-10 16:59:40 +00008408 if (Args.hasArg(options::OPT_pg)) {
8409 if (Args.hasArg(options::OPT_shared))
8410 CmdArgs.push_back("-lc");
8411 else
8412 CmdArgs.push_back("-lc_p");
8413 CmdArgs.push_back("-lgcc_p");
8414 } else {
8415 CmdArgs.push_back("-lc");
8416 CmdArgs.push_back("-lgcc");
8417 }
8418
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008419 if (Args.hasArg(options::OPT_static)) {
8420 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00008421 } else if (Args.hasArg(options::OPT_pg)) {
8422 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008423 } else {
8424 CmdArgs.push_back("--as-needed");
8425 CmdArgs.push_back("-lgcc_s");
8426 CmdArgs.push_back("--no-as-needed");
8427 }
8428 }
8429
Douglas Katzman78b37b02015-11-17 20:28:07 +00008430 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008431 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008432 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00008433 else
8434 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00008435 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008436 }
8437
Xinliang David Li69306c02015-10-22 06:15:31 +00008438 ToolChain.addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008439
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008440 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008441 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008442}
Daniel Dunbarcc912342009-05-02 18:28:39 +00008443
Douglas Katzman95354292015-06-23 20:42:09 +00008444void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008445 const InputInfo &Output,
8446 const InputInfoList &Inputs,
8447 const ArgList &Args,
8448 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008449 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008450 ArgStringList CmdArgs;
8451
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008452 // GNU as needs different flags for creating the correct output format
8453 // on architectures with different ABIs or optional feature sets.
8454 switch (getToolChain().getArch()) {
8455 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008456 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008457 break;
8458 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00008459 case llvm::Triple::armeb:
8460 case llvm::Triple::thumb:
8461 case llvm::Triple::thumbeb: {
Renato Goline17c5802015-07-27 23:44:42 +00008462 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00008463 getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true);
8464 std::string Arch =
8465 arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple());
Renato Goline17c5802015-07-27 23:44:42 +00008466 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008467 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00008468 }
8469
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008470 case llvm::Triple::mips:
8471 case llvm::Triple::mipsel:
8472 case llvm::Triple::mips64:
8473 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008474 StringRef CPUName;
8475 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008476 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008477
8478 CmdArgs.push_back("-march");
8479 CmdArgs.push_back(CPUName.data());
8480
8481 CmdArgs.push_back("-mabi");
8482 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
8483
8484 if (getToolChain().getArch() == llvm::Triple::mips ||
8485 getToolChain().getArch() == llvm::Triple::mips64)
8486 CmdArgs.push_back("-EB");
8487 else
8488 CmdArgs.push_back("-EL");
8489
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008490 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008491 break;
8492 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008493
8494 case llvm::Triple::sparc:
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008495 case llvm::Triple::sparcel: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008496 CmdArgs.push_back("-32");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008497 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8498 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008499 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008500 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008501 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008502
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008503 case llvm::Triple::sparcv9: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008504 CmdArgs.push_back("-64");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008505 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8506 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008507 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008508 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008509 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008510
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008511 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008512 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008513 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008514
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008515 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008516
8517 CmdArgs.push_back("-o");
8518 CmdArgs.push_back(Output.getFilename());
8519
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008520 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008521 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008522
David Chisnallddbd68f2011-09-27 22:03:18 +00008523 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Justin Bognerd3371d82015-07-17 03:35:54 +00008524 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008525}
8526
Douglas Katzman95354292015-06-23 20:42:09 +00008527void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8528 const InputInfo &Output,
8529 const InputInfoList &Inputs,
8530 const ArgList &Args,
8531 const char *LinkingOutput) const {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008532 const Driver &D = getToolChain().getDriver();
8533 ArgStringList CmdArgs;
8534
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008535 if (!D.SysRoot.empty())
8536 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8537
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00008538 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008539 if (Args.hasArg(options::OPT_static)) {
8540 CmdArgs.push_back("-Bstatic");
8541 } else {
8542 if (Args.hasArg(options::OPT_rdynamic))
8543 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008544 if (Args.hasArg(options::OPT_shared)) {
8545 CmdArgs.push_back("-Bshareable");
8546 } else {
8547 CmdArgs.push_back("-dynamic-linker");
8548 CmdArgs.push_back("/libexec/ld.elf_so");
8549 }
8550 }
8551
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008552 // Many NetBSD architectures support more than one ABI.
8553 // Determine the correct emulation for ld.
8554 switch (getToolChain().getArch()) {
8555 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008556 CmdArgs.push_back("-m");
8557 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008558 break;
8559 case llvm::Triple::arm:
8560 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008561 CmdArgs.push_back("-m");
8562 switch (getToolChain().getTriple().getEnvironment()) {
8563 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008564 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008565 CmdArgs.push_back("armelf_nbsd_eabi");
8566 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00008567 case llvm::Triple::EABIHF:
8568 case llvm::Triple::GNUEABIHF:
8569 CmdArgs.push_back("armelf_nbsd_eabihf");
8570 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008571 default:
8572 CmdArgs.push_back("armelf_nbsd");
8573 break;
8574 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008575 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00008576 case llvm::Triple::armeb:
8577 case llvm::Triple::thumbeb:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008578 arm::appendEBLinkFlags(
8579 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00008580 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00008581 CmdArgs.push_back("-m");
8582 switch (getToolChain().getTriple().getEnvironment()) {
8583 case llvm::Triple::EABI:
8584 case llvm::Triple::GNUEABI:
8585 CmdArgs.push_back("armelfb_nbsd_eabi");
8586 break;
8587 case llvm::Triple::EABIHF:
8588 case llvm::Triple::GNUEABIHF:
8589 CmdArgs.push_back("armelfb_nbsd_eabihf");
8590 break;
8591 default:
8592 CmdArgs.push_back("armelfb_nbsd");
8593 break;
8594 }
8595 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00008596 case llvm::Triple::mips64:
8597 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00008598 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00008599 CmdArgs.push_back("-m");
8600 if (getToolChain().getArch() == llvm::Triple::mips64)
8601 CmdArgs.push_back("elf32btsmip");
8602 else
8603 CmdArgs.push_back("elf32ltsmip");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008604 } else if (mips::hasMipsAbiArg(Args, "64")) {
8605 CmdArgs.push_back("-m");
8606 if (getToolChain().getArch() == llvm::Triple::mips64)
8607 CmdArgs.push_back("elf64btsmip");
8608 else
8609 CmdArgs.push_back("elf64ltsmip");
8610 }
8611 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00008612 case llvm::Triple::ppc:
8613 CmdArgs.push_back("-m");
8614 CmdArgs.push_back("elf32ppc_nbsd");
8615 break;
8616
8617 case llvm::Triple::ppc64:
8618 case llvm::Triple::ppc64le:
8619 CmdArgs.push_back("-m");
8620 CmdArgs.push_back("elf64ppc");
8621 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008622
8623 case llvm::Triple::sparc:
8624 CmdArgs.push_back("-m");
8625 CmdArgs.push_back("elf32_sparc");
8626 break;
8627
8628 case llvm::Triple::sparcv9:
8629 CmdArgs.push_back("-m");
8630 CmdArgs.push_back("elf64_sparc");
8631 break;
8632
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008633 default:
8634 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008635 }
8636
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008637 if (Output.isFilename()) {
8638 CmdArgs.push_back("-o");
8639 CmdArgs.push_back(Output.getFilename());
8640 } else {
8641 assert(Output.isNothing() && "Invalid output.");
8642 }
8643
Douglas Katzman78b37b02015-11-17 20:28:07 +00008644 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008645 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008646 CmdArgs.push_back(
8647 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
8648 CmdArgs.push_back(
8649 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8650 CmdArgs.push_back(
8651 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008652 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008653 CmdArgs.push_back(
8654 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8655 CmdArgs.push_back(
8656 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008657 }
8658 }
8659
8660 Args.AddAllArgs(CmdArgs, options::OPT_L);
8661 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8662 Args.AddAllArgs(CmdArgs, options::OPT_e);
8663 Args.AddAllArgs(CmdArgs, options::OPT_s);
8664 Args.AddAllArgs(CmdArgs, options::OPT_t);
8665 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8666 Args.AddAllArgs(CmdArgs, options::OPT_r);
8667
8668 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8669
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008670 unsigned Major, Minor, Micro;
8671 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
8672 bool useLibgcc = true;
Joerg Sonnenberger21156e82016-02-11 23:35:03 +00008673 if (Major >= 7 || Major == 0) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008674 switch (getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00008675 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00008676 case llvm::Triple::arm:
8677 case llvm::Triple::armeb:
8678 case llvm::Triple::thumb:
8679 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00008680 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00008681 case llvm::Triple::ppc64:
8682 case llvm::Triple::ppc64le:
Joerg Sonnenberger059613c2016-02-11 23:18:36 +00008683 case llvm::Triple::sparc:
8684 case llvm::Triple::sparcv9:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008685 case llvm::Triple::x86:
8686 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008687 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008688 break;
8689 default:
8690 break;
8691 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008692 }
8693
Douglas Katzman78b37b02015-11-17 20:28:07 +00008694 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Joerg Sonnenberger27a69a22015-09-23 20:11:00 +00008695 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00008696 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008697 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8698 CmdArgs.push_back("-lm");
8699 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008700 if (Args.hasArg(options::OPT_pthread))
8701 CmdArgs.push_back("-lpthread");
8702 CmdArgs.push_back("-lc");
8703
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008704 if (useLibgcc) {
8705 if (Args.hasArg(options::OPT_static)) {
8706 // libgcc_eh depends on libc, so resolve as much as possible,
8707 // pull in any new requirements from libc and then get the rest
8708 // of libgcc.
8709 CmdArgs.push_back("-lgcc_eh");
8710 CmdArgs.push_back("-lc");
8711 CmdArgs.push_back("-lgcc");
8712 } else {
8713 CmdArgs.push_back("-lgcc");
8714 CmdArgs.push_back("--as-needed");
8715 CmdArgs.push_back("-lgcc_s");
8716 CmdArgs.push_back("--no-as-needed");
8717 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008718 }
8719 }
8720
Douglas Katzman78b37b02015-11-17 20:28:07 +00008721 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008722 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008723 CmdArgs.push_back(
8724 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008725 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008726 CmdArgs.push_back(
8727 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
8728 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008729 }
8730
Xinliang David Li69306c02015-10-22 06:15:31 +00008731 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008732
Logan Chieneb9162f2014-06-26 14:23:45 +00008733 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008734 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008735}
8736
Douglas Katzman95354292015-06-23 20:42:09 +00008737void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8738 const InputInfo &Output,
8739 const InputInfoList &Inputs,
8740 const ArgList &Args,
8741 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008742 claimNoWarnArgs(Args);
8743
James Y Knight2db38f32015-08-15 03:45:25 +00008744 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8745 llvm::Triple Triple = llvm::Triple(TripleStr);
8746
Rafael Espindola92b00932010-08-10 00:25:48 +00008747 ArgStringList CmdArgs;
8748
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008749 llvm::Reloc::Model RelocationModel;
8750 unsigned PICLevel;
8751 bool IsPIE;
8752 std::tie(RelocationModel, PICLevel, IsPIE) =
8753 ParsePICArgs(getToolChain(), Triple, Args);
8754
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008755 switch (getToolChain().getArch()) {
8756 default:
8757 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00008758 // Add --32/--64 to make sure we get the format we want.
8759 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008760 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00008761 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008762 break;
8763 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00008764 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
8765 CmdArgs.push_back("--x32");
8766 else
8767 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008768 break;
8769 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008770 CmdArgs.push_back("-a32");
8771 CmdArgs.push_back("-mppc");
8772 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008773 break;
8774 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008775 CmdArgs.push_back("-a64");
8776 CmdArgs.push_back("-mppc64");
8777 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008778 break;
8779 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00008780 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008781 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00008782 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008783 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008784 break;
8785 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008786 case llvm::Triple::sparcel: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008787 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008788 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8789 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8790 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008791 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008792 }
8793 case llvm::Triple::sparcv9: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008794 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008795 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8796 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8797 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008798 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008799 }
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008800 case llvm::Triple::arm:
8801 case llvm::Triple::armeb:
8802 case llvm::Triple::thumb:
8803 case llvm::Triple::thumbeb: {
James Y Knight2db38f32015-08-15 03:45:25 +00008804 const llvm::Triple &Triple2 = getToolChain().getTriple();
8805 switch (Triple2.getSubArch()) {
Scott Douglass3205f522015-03-23 10:54:24 +00008806 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00008807 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00008808 break;
8809 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00008810 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00008811 break;
8812 default:
8813 break;
8814 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00008815
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008816 switch (arm::getARMFloatABI(getToolChain(), Args)) {
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008817 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
8818 case arm::FloatABI::Soft:
8819 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
8820 break;
8821 case arm::FloatABI::SoftFP:
8822 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
8823 break;
8824 case arm::FloatABI::Hard:
8825 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
8826 break;
8827 }
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008828
8829 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00008830
8831 // FIXME: remove krait check when GNU tools support krait cpu
Stephen Hinese3f91e32016-03-04 20:57:22 +00008832 // for now replace it with -mcpu=cortex-a15 to avoid a lower
Ana Pazosdd6068d2013-12-06 22:43:17 +00008833 // march from being picked in the absence of a cpu flag.
8834 Arg *A;
8835 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008836 StringRef(A->getValue()).lower() == "krait")
Stephen Hinese3f91e32016-03-04 20:57:22 +00008837 CmdArgs.push_back("-mcpu=cortex-a15");
Ana Pazosdd6068d2013-12-06 22:43:17 +00008838 else
8839 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008840 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008841 break;
8842 }
8843 case llvm::Triple::mips:
8844 case llvm::Triple::mipsel:
8845 case llvm::Triple::mips64:
8846 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008847 StringRef CPUName;
8848 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008849 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00008850 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00008851
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008852 CmdArgs.push_back("-march");
8853 CmdArgs.push_back(CPUName.data());
8854
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008855 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00008856 CmdArgs.push_back(ABIName.data());
8857
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008858 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
8859 // or -mshared (not implemented) is in effect.
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008860 if (RelocationModel == llvm::Reloc::Static)
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008861 CmdArgs.push_back("-mno-shared");
8862
Daniel Sanders379d44b2014-07-16 11:52:23 +00008863 // LLVM doesn't support -mplt yet and acts as if it is always given.
8864 // However, -mplt has no effect with the N64 ABI.
8865 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00008866
8867 if (getToolChain().getArch() == llvm::Triple::mips ||
8868 getToolChain().getArch() == llvm::Triple::mips64)
8869 CmdArgs.push_back("-EB");
8870 else
8871 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00008872
Simon Atanasyan22127ce2013-09-24 09:09:16 +00008873 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
8874 if (StringRef(A->getValue()) == "2008")
8875 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
8876 }
8877
Daniel Sanders379d44b2014-07-16 11:52:23 +00008878 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
8879 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
8880 options::OPT_mfp64)) {
8881 A->claim();
8882 A->render(Args, CmdArgs);
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00008883 } else if (mips::shouldUseFPXX(
8884 Args, getToolChain().getTriple(), CPUName, ABIName,
8885 getMipsFloatABI(getToolChain().getDriver(), Args)))
Daniel Sanders379d44b2014-07-16 11:52:23 +00008886 CmdArgs.push_back("-mfpxx");
8887
8888 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
8889 // -mno-mips16 is actually -no-mips16.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008890 if (Arg *A =
8891 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00008892 if (A->getOption().matches(options::OPT_mips16)) {
8893 A->claim();
8894 A->render(Args, CmdArgs);
8895 } else {
8896 A->claim();
8897 CmdArgs.push_back("-no-mips16");
8898 }
8899 }
8900
Simon Atanasyan036d16d2013-04-30 07:47:13 +00008901 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
8902 options::OPT_mno_micromips);
8903 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
8904 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
8905
Simon Atanasyanbd986632013-11-26 11:58:04 +00008906 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
8907 // Do not use AddLastArg because not all versions of MIPS assembler
8908 // support -mmsa / -mno-msa options.
8909 if (A->getOption().matches(options::OPT_mmsa))
8910 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
8911 }
8912
Daniel Sanders379d44b2014-07-16 11:52:23 +00008913 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
8914 options::OPT_msoft_float);
8915
Toma Tabacub36d6102015-06-11 12:13:18 +00008916 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
8917 options::OPT_msingle_float);
8918
Daniel Sanders379d44b2014-07-16 11:52:23 +00008919 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
8920 options::OPT_mno_odd_spreg);
8921
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008922 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008923 break;
8924 }
8925 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008926 // Always pass an -march option, since our default of z10 is later
8927 // than the GNU assembler's default.
8928 StringRef CPUName = getSystemZTargetCPU(Args);
8929 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008930 break;
8931 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008932 }
8933
Renato Golina74bbc72015-07-22 15:32:36 +00008934 Args.AddAllArgs(CmdArgs, options::OPT_I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008935 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Rafael Espindola92b00932010-08-10 00:25:48 +00008936
8937 CmdArgs.push_back("-o");
8938 CmdArgs.push_back(Output.getFilename());
8939
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008940 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00008941 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00008942
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008943 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008944 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00008945
8946 // Handle the debug info splitting at object creation time if we're
8947 // creating an object.
8948 // TODO: Currently only works on linux with newer objcopy.
8949 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00008950 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00008951 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00008952 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00008953}
8954
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00008955static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008956 ArgStringList &CmdArgs, const ArgList &Args) {
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00008957 bool isAndroid = Triple.isAndroid();
Reid Kleckner0213a472015-07-22 16:01:38 +00008958 bool isCygMing = Triple.isOSCygMing();
Chandler Carruth58d6eb62013-03-04 02:07:55 +00008959 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
8960 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00008961 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008962 CmdArgs.push_back("-lgcc");
8963
Logan Chien3d3373c2012-11-19 12:04:11 +00008964 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008965 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008966 CmdArgs.push_back("-lgcc");
8967 } else {
Reid Kleckner0213a472015-07-22 16:01:38 +00008968 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008969 CmdArgs.push_back("--as-needed");
8970 CmdArgs.push_back("-lgcc_s");
Reid Kleckner0213a472015-07-22 16:01:38 +00008971 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008972 CmdArgs.push_back("--no-as-needed");
8973 }
8974
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008975 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00008976 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00008977 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008978 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00008979
8980 // According to Android ABI, we have to link with libdl if we are
8981 // linking with non-static libgcc.
8982 //
8983 // NOTE: This fixes a link error on Android MIPS as well. The non-static
8984 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
8985 if (isAndroid && !StaticLibgcc)
8986 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00008987}
8988
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008989static std::string getLinuxDynamicLinker(const ArgList &Args,
8990 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008991 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00008992 const llvm::Triple &Triple = ToolChain.getTriple();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008993
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00008994 if (Triple.isAndroid()) {
8995 if (Triple.isArch64Bit())
Alexey Bataevcf7ae302014-01-23 09:08:32 +00008996 return "/system/bin/linker64";
8997 else
8998 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008999 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
9000 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009001 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009002 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009003 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009004 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00009005 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009006 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009007 if (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00009008 arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009009 return "/lib/ld-linux-armhf.so.3";
9010 else
9011 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009012 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
9013 // TODO: check which dynamic linker name.
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009014 if (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00009015 arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard)
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009016 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009017 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009018 return "/lib/ld-linux.so.3";
9019 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
9020 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009021 std::string LibDir = "/lib" + mips::getMipsABILibSuffix(Args, Triple);
Vasileios Kalintiris71b0dfe2015-10-30 11:28:39 +00009022 StringRef LibName;
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009023 bool IsNaN2008 = mips::isNaN2008(Args, Triple);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00009024 if (mips::isUCLibc(Args))
9025 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009026 else if (!Triple.hasEnvironment() &&
9027 Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies) {
9028 bool LE = (Triple.getArch() == llvm::Triple::mipsel) ||
9029 (Triple.getArch() == llvm::Triple::mips64el);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009030 LibName = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
9031 } else
Simon Atanasyand95c67d2014-08-13 14:34:14 +00009032 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00009033
9034 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009035 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009036 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009037 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00009038 if (ppc::hasPPCAbiArg(Args, "elfv2"))
9039 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009040 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009041 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00009042 if (ppc::hasPPCAbiArg(Args, "elfv1"))
9043 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00009044 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009045 } else if (Arch == llvm::Triple::systemz)
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00009046 return "/lib/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009047 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00009048 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009049 else if (Arch == llvm::Triple::x86_64 &&
Vasileios Kalintirisfc118652016-05-13 12:34:14 +00009050 Triple.getEnvironment() == llvm::Triple::GNUX32)
Zinovy Nis1db95732014-07-10 15:27:19 +00009051 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00009052 else
9053 return "/lib64/ld-linux-x86-64.so.2";
9054}
9055
Renato Golinc4b49242014-02-13 10:01:16 +00009056static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00009057 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00009058 // Make use of compiler-rt if --rtlib option is used
9059 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
9060
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00009061 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00009062 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009063 switch (TC.getTriple().getOS()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009064 default:
9065 llvm_unreachable("unsupported OS");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009066 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009067 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00009068 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009069 break;
9070 }
Renato Golinc4b49242014-02-13 10:01:16 +00009071 break;
9072 case ToolChain::RLT_Libgcc:
Andrey Turetskiya4868572016-03-14 11:19:43 +00009073 // Make sure libgcc is not used under MSVC environment by default
9074 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
9075 // Issue error diagnostic if libgcc is explicitly specified
9076 // through command line as --rtlib option argument.
9077 if (Args.hasArg(options::OPT_rtlib_EQ)) {
9078 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
9079 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "MSVC";
9080 }
9081 } else
9082 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
Renato Golinc4b49242014-02-13 10:01:16 +00009083 break;
Renato Golinc4b49242014-02-13 10:01:16 +00009084 }
9085}
9086
Rafael Espindola1e085772014-08-15 17:14:35 +00009087static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
9088 switch (T.getArch()) {
9089 case llvm::Triple::x86:
9090 return "elf_i386";
9091 case llvm::Triple::aarch64:
9092 return "aarch64linux";
9093 case llvm::Triple::aarch64_be:
9094 return "aarch64_be_linux";
9095 case llvm::Triple::arm:
9096 case llvm::Triple::thumb:
9097 return "armelf_linux_eabi";
9098 case llvm::Triple::armeb:
9099 case llvm::Triple::thumbeb:
9100 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
9101 case llvm::Triple::ppc:
9102 return "elf32ppclinux";
9103 case llvm::Triple::ppc64:
9104 return "elf64ppc";
9105 case llvm::Triple::ppc64le:
9106 return "elf64lppc";
9107 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009108 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00009109 return "elf32_sparc";
9110 case llvm::Triple::sparcv9:
9111 return "elf64_sparc";
9112 case llvm::Triple::mips:
9113 return "elf32btsmip";
9114 case llvm::Triple::mipsel:
9115 return "elf32ltsmip";
9116 case llvm::Triple::mips64:
9117 if (mips::hasMipsAbiArg(Args, "n32"))
9118 return "elf32btsmipn32";
9119 return "elf64btsmip";
9120 case llvm::Triple::mips64el:
9121 if (mips::hasMipsAbiArg(Args, "n32"))
9122 return "elf32ltsmipn32";
9123 return "elf64ltsmip";
9124 case llvm::Triple::systemz:
9125 return "elf64_s390";
9126 case llvm::Triple::x86_64:
9127 if (T.getEnvironment() == llvm::Triple::GNUX32)
9128 return "elf32_x86_64";
9129 return "elf_x86_64";
9130 default:
9131 llvm_unreachable("Unexpected arch");
9132 }
9133}
9134
Douglas Katzman95354292015-06-23 20:42:09 +00009135void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9136 const InputInfo &Output,
9137 const InputInfoList &Inputs,
9138 const ArgList &Args,
9139 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009140 const toolchains::Linux &ToolChain =
9141 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009142 const Driver &D = ToolChain.getDriver();
James Y Knight2db38f32015-08-15 03:45:25 +00009143
9144 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
9145 llvm::Triple Triple = llvm::Triple(TripleStr);
9146
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009147 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00009148 const bool isAndroid = ToolChain.getTriple().isAndroid();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009149 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009150 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
9151 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009152 const bool HasCRTBeginEndFiles =
9153 ToolChain.getTriple().hasEnvironment() ||
9154 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009155
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009156 ArgStringList CmdArgs;
9157
Rafael Espindolad1002f62010-11-15 18:28:16 +00009158 // Silence warning for "clang -g foo.o -o foo"
9159 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00009160 // and "clang -emit-llvm foo.o -o foo"
9161 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00009162 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00009163 // handled somewhere else.
9164 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00009165
Peter Collingbourne39719a72015-11-20 20:49:39 +00009166 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
9167 if (llvm::sys::path::filename(Exec) == "lld") {
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009168 CmdArgs.push_back("-flavor");
Rafael Espindola156aac02015-11-16 09:12:12 +00009169 CmdArgs.push_back("old-gnu");
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009170 CmdArgs.push_back("-target");
9171 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
9172 }
9173
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00009174 if (!D.SysRoot.empty())
9175 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009176
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009177 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00009178 CmdArgs.push_back("-pie");
9179
Rafael Espindola1c76c592010-11-07 22:57:16 +00009180 if (Args.hasArg(options::OPT_rdynamic))
9181 CmdArgs.push_back("-export-dynamic");
9182
Rafael Espindola34d77dc2010-11-11 19:34:42 +00009183 if (Args.hasArg(options::OPT_s))
9184 CmdArgs.push_back("-s");
9185
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009186 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
James Y Knight2db38f32015-08-15 03:45:25 +00009187 arm::appendEBLinkFlags(Args, CmdArgs, Triple);
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00009188
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00009189 for (const auto &Opt : ToolChain.ExtraOpts)
9190 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009191
9192 if (!Args.hasArg(options::OPT_static)) {
9193 CmdArgs.push_back("--eh-frame-hdr");
9194 }
9195
9196 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00009197 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009198
9199 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009200 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
9201 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009202 CmdArgs.push_back("-Bstatic");
9203 else
9204 CmdArgs.push_back("-static");
9205 } else if (Args.hasArg(options::OPT_shared)) {
9206 CmdArgs.push_back("-shared");
9207 }
9208
Saleem Abdulrasoolf56c6d82016-02-07 06:03:38 +00009209 if (!Args.hasArg(options::OPT_static)) {
9210 if (Args.hasArg(options::OPT_rdynamic))
9211 CmdArgs.push_back("-export-dynamic");
9212
9213 if (!Args.hasArg(options::OPT_shared)) {
9214 const std::string Loader =
9215 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain);
9216 CmdArgs.push_back("-dynamic-linker");
9217 CmdArgs.push_back(Args.MakeArgString(Loader));
9218 }
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00009219 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009220
9221 CmdArgs.push_back("-o");
9222 CmdArgs.push_back(Output.getFilename());
9223
Douglas Katzman78b37b02015-11-17 20:28:07 +00009224 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009225 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00009226 const char *crt1 = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009227 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopherac021742013-06-07 23:25:01 +00009228 if (Args.hasArg(options::OPT_pg))
9229 crt1 = "gcrt1.o";
9230 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009231 crt1 = "Scrt1.o";
9232 else
9233 crt1 = "crt1.o";
9234 }
9235 if (crt1)
9236 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009237
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009238 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
9239 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009240
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009241 const char *crtbegin;
9242 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009243 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009244 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009245 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009246 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009247 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009248 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009249 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009250
9251 if (HasCRTBeginEndFiles)
9252 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00009253
9254 // Add crtfastmath.o if available and fast math is enabled.
9255 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009256 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009257
9258 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00009259 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009260
Douglas Katzman6059ef92015-11-17 17:41:23 +00009261 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009262
Teresa Johnson945bc502015-10-15 20:35:53 +00009263 if (D.isUsingLTO())
9264 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Chandler Carruth953fb082013-01-13 11:46:33 +00009265
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00009266 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
9267 CmdArgs.push_back("--no-demangle");
9268
Alexey Samsonov52550342014-09-15 19:58:40 +00009269 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009270 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00009271 // The profile runtime also needs access to system libraries.
Xinliang David Li69306c02015-10-22 06:15:31 +00009272 getToolChain().addProfileRTLibs(Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00009273
Douglas Katzman78b37b02015-11-17 20:28:07 +00009274 if (D.CCCIsCXX() &&
9275 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00009276 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009277 !Args.hasArg(options::OPT_static);
Rafael Espindola70b8d762011-10-17 22:14:51 +00009278 if (OnlyLibstdcxxStatic)
9279 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009280 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00009281 if (OnlyLibstdcxxStatic)
9282 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009283 CmdArgs.push_back("-lm");
9284 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00009285 // Silence warnings when linking C code with a C++ '-stdlib' argument.
9286 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009287
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009288 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00009289 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9290 if (Args.hasArg(options::OPT_static))
9291 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00009292
Alexey Samsonov52550342014-09-15 19:58:40 +00009293 if (NeedsSanitizerDeps)
9294 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
9295
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009296 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
9297 Args.hasArg(options::OPT_pthreads);
9298
9299 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9300 options::OPT_fno_openmp, false)) {
9301 // OpenMP runtimes implies pthreads when using the GNU toolchain.
9302 // FIXME: Does this really make sense for all GNU toolchains?
9303 WantPthread = true;
9304
9305 // Also link the particular OpenMP runtimes.
9306 switch (getOpenMPRuntime(ToolChain, Args)) {
9307 case OMPRT_OMP:
9308 CmdArgs.push_back("-lomp");
9309 break;
9310 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00009311 CmdArgs.push_back("-lgomp");
9312
9313 // FIXME: Exclude this for platforms with libgomp that don't require
9314 // librt. Most modern Linux platforms require it, but some may not.
9315 CmdArgs.push_back("-lrt");
9316 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009317 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00009318 CmdArgs.push_back("-liomp5");
9319 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009320 case OMPRT_Unknown:
9321 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00009322 break;
9323 }
Chandler Carruth01538002013-01-17 13:19:29 +00009324 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009325
Renato Golinc4b49242014-02-13 10:01:16 +00009326 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009327
Richard Smith31d1de22015-05-20 22:48:44 +00009328 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00009329 CmdArgs.push_back("-lpthread");
9330
Rafael Espindolab17bc532016-01-25 18:29:16 +00009331 if (Args.hasArg(options::OPT_fsplit_stack))
9332 CmdArgs.push_back("--wrap=pthread_create");
9333
Chandler Carruth94a32012012-05-14 18:31:18 +00009334 CmdArgs.push_back("-lc");
9335
9336 if (Args.hasArg(options::OPT_static))
9337 CmdArgs.push_back("--end-group");
9338 else
Renato Golinc4b49242014-02-13 10:01:16 +00009339 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00009340 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00009341
Rafael Espindola81937ec2010-12-01 01:52:43 +00009342 if (!Args.hasArg(options::OPT_nostartfiles)) {
9343 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009344 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009345 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009346 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009347 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00009348 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009349 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009350
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009351 if (HasCRTBeginEndFiles)
9352 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009353 if (!isAndroid)
9354 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00009355 }
Sumanth Gundapanenib79fdff2015-12-02 19:12:41 +00009356 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009357
Peter Collingbourne39719a72015-11-20 20:49:39 +00009358 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00009359}
9360
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009361// NaCl ARM assembly (inline or standalone) can be written with a set of macros
9362// for the various SFI requirements like register masking. The assembly tool
9363// inserts the file containing the macros as an input into all the assembly
9364// jobs.
Douglas Katzman95354292015-06-23 20:42:09 +00009365void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
9366 const InputInfo &Output,
9367 const InputInfoList &Inputs,
9368 const ArgList &Args,
9369 const char *LinkingOutput) const {
Douglas Katzman54366072015-07-27 16:53:08 +00009370 const toolchains::NaClToolChain &ToolChain =
9371 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Justin Lebard98cea82016-01-11 23:15:21 +00009372 InputInfo NaClMacros(types::TY_PP_Asm, ToolChain.GetNaClArmMacrosPath(),
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009373 "nacl-arm-macros.s");
9374 InputInfoList NewInputs;
9375 NewInputs.push_back(NaClMacros);
9376 NewInputs.append(Inputs.begin(), Inputs.end());
Douglas Katzman95354292015-06-23 20:42:09 +00009377 gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
9378 LinkingOutput);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009379}
9380
Douglas Katzman750cfc52015-06-29 18:42:16 +00009381// This is quite similar to gnutools::Linker::ConstructJob with changes that
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009382// we use static by default, do not yet support sanitizers or LTO, and a few
9383// others. Eventually we can support more of that and hopefully migrate back
Douglas Katzman750cfc52015-06-29 18:42:16 +00009384// to gnutools::Linker.
Douglas Katzman95354292015-06-23 20:42:09 +00009385void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9386 const InputInfo &Output,
9387 const InputInfoList &Inputs,
9388 const ArgList &Args,
9389 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009390
Douglas Katzman54366072015-07-27 16:53:08 +00009391 const toolchains::NaClToolChain &ToolChain =
9392 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009393 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009394 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009395 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009396 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009397
9398 ArgStringList CmdArgs;
9399
9400 // Silence warning for "clang -g foo.o -o foo"
9401 Args.ClaimAllArgs(options::OPT_g_Group);
9402 // and "clang -emit-llvm foo.o -o foo"
9403 Args.ClaimAllArgs(options::OPT_emit_llvm);
9404 // and for "clang -w foo.o -o foo". Other warning options are already
9405 // handled somewhere else.
9406 Args.ClaimAllArgs(options::OPT_w);
9407
9408 if (!D.SysRoot.empty())
9409 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9410
9411 if (Args.hasArg(options::OPT_rdynamic))
9412 CmdArgs.push_back("-export-dynamic");
9413
9414 if (Args.hasArg(options::OPT_s))
9415 CmdArgs.push_back("-s");
9416
Douglas Katzman54366072015-07-27 16:53:08 +00009417 // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
9418 // from there is --build-id, which we do want.
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009419 CmdArgs.push_back("--build-id");
9420
9421 if (!IsStatic)
9422 CmdArgs.push_back("--eh-frame-hdr");
9423
9424 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009425 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009426 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009427 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009428 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009429 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009430 CmdArgs.push_back("elf_x86_64_nacl");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009431 else if (Arch == llvm::Triple::mipsel)
9432 CmdArgs.push_back("mipselelf_nacl");
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009433 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009434 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
9435 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009436
9437 if (IsStatic)
9438 CmdArgs.push_back("-static");
9439 else if (Args.hasArg(options::OPT_shared))
9440 CmdArgs.push_back("-shared");
9441
9442 CmdArgs.push_back("-o");
9443 CmdArgs.push_back(Output.getFilename());
Douglas Katzman78b37b02015-11-17 20:28:07 +00009444 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009445 if (!Args.hasArg(options::OPT_shared))
9446 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
9447 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
9448
9449 const char *crtbegin;
9450 if (IsStatic)
9451 crtbegin = "crtbeginT.o";
9452 else if (Args.hasArg(options::OPT_shared))
9453 crtbegin = "crtbeginS.o";
9454 else
9455 crtbegin = "crtbegin.o";
9456 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
9457 }
9458
9459 Args.AddAllArgs(CmdArgs, options::OPT_L);
9460 Args.AddAllArgs(CmdArgs, options::OPT_u);
9461
Douglas Katzman6059ef92015-11-17 17:41:23 +00009462 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009463
9464 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
9465 CmdArgs.push_back("--no-demangle");
9466
9467 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
9468
Douglas Katzman78b37b02015-11-17 20:28:07 +00009469 if (D.CCCIsCXX() &&
9470 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009471 bool OnlyLibstdcxxStatic =
9472 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009473 if (OnlyLibstdcxxStatic)
9474 CmdArgs.push_back("-Bstatic");
9475 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
9476 if (OnlyLibstdcxxStatic)
9477 CmdArgs.push_back("-Bdynamic");
9478 CmdArgs.push_back("-lm");
9479 }
9480
9481 if (!Args.hasArg(options::OPT_nostdlib)) {
9482 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9483 // Always use groups, since it has no effect on dynamic libraries.
9484 CmdArgs.push_back("--start-group");
9485 CmdArgs.push_back("-lc");
9486 // NaCl's libc++ currently requires libpthread, so just always include it
9487 // in the group for C++.
9488 if (Args.hasArg(options::OPT_pthread) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009489 Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009490 // Gold, used by Mips, handles nested groups differently than ld, and
9491 // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
9492 // which is not a desired behaviour here.
9493 // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
9494 if (getToolChain().getArch() == llvm::Triple::mipsel)
9495 CmdArgs.push_back("-lnacl");
9496
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009497 CmdArgs.push_back("-lpthread");
9498 }
9499
9500 CmdArgs.push_back("-lgcc");
9501 CmdArgs.push_back("--as-needed");
9502 if (IsStatic)
9503 CmdArgs.push_back("-lgcc_eh");
9504 else
9505 CmdArgs.push_back("-lgcc_s");
9506 CmdArgs.push_back("--no-as-needed");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009507
9508 // Mips needs to create and use pnacl_legacy library that contains
9509 // definitions from bitcode/pnaclmm.c and definitions for
9510 // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
9511 if (getToolChain().getArch() == llvm::Triple::mipsel)
9512 CmdArgs.push_back("-lpnacl_legacy");
9513
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009514 CmdArgs.push_back("--end-group");
9515 }
9516
9517 if (!Args.hasArg(options::OPT_nostartfiles)) {
9518 const char *crtend;
9519 if (Args.hasArg(options::OPT_shared))
9520 crtend = "crtendS.o";
9521 else
9522 crtend = "crtend.o";
9523
9524 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
9525 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
9526 }
9527 }
9528
Peter Collingbourne39719a72015-11-20 20:49:39 +00009529 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
9530 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009531}
9532
Douglas Katzman95354292015-06-23 20:42:09 +00009533void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9534 const InputInfo &Output,
9535 const InputInfoList &Inputs,
9536 const ArgList &Args,
9537 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009538 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009539 ArgStringList CmdArgs;
9540
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009541 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009542
9543 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00009544 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00009545
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009546 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00009547 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00009548
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009549 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009550 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009551}
9552
Douglas Katzman95354292015-06-23 20:42:09 +00009553void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9554 const InputInfo &Output,
9555 const InputInfoList &Inputs,
9556 const ArgList &Args,
9557 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00009558 const Driver &D = getToolChain().getDriver();
9559 ArgStringList CmdArgs;
9560
Daniel Dunbarb440f562010-08-02 02:38:21 +00009561 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00009562 CmdArgs.push_back("-o");
9563 CmdArgs.push_back(Output.getFilename());
9564 } else {
9565 assert(Output.isNothing() && "Invalid output.");
9566 }
9567
Douglas Katzman78b37b02015-11-17 20:28:07 +00009568 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009569 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
9570 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
9571 CmdArgs.push_back(
9572 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
9573 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Eli Friedman83de5132011-12-08 23:54:21 +00009574 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00009575
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009576 Args.AddAllArgs(CmdArgs,
9577 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Chris Lattner3e2ee142010-07-07 16:01:42 +00009578
Daniel Dunbar54423b22010-09-17 00:24:54 +00009579 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009580
Xinliang David Li69306c02015-10-22 06:15:31 +00009581 getToolChain().addProfileRTLibs(Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00009582
Douglas Katzman78b37b02015-11-17 20:28:07 +00009583 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00009584 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00009585 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009586 CmdArgs.push_back("-lm");
9587 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00009588 }
9589
Douglas Katzman78b37b02015-11-17 20:28:07 +00009590 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00009591 if (Args.hasArg(options::OPT_pthread))
9592 CmdArgs.push_back("-lpthread");
9593 CmdArgs.push_back("-lc");
9594 CmdArgs.push_back("-lCompilerRT-Generic");
9595 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
9596 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009597 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009598 }
9599
Logan Chieneb9162f2014-06-26 14:23:45 +00009600 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00009601 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009602}
9603
Daniel Dunbarcc912342009-05-02 18:28:39 +00009604/// DragonFly Tools
9605
9606// For now, DragonFly Assemble does just about the same as for
9607// FreeBSD, but this may change soon.
Douglas Katzman95354292015-06-23 20:42:09 +00009608void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9609 const InputInfo &Output,
9610 const InputInfoList &Inputs,
9611 const ArgList &Args,
9612 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009613 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009614 ArgStringList CmdArgs;
9615
9616 // When building 32-bit code on DragonFly/pc64, we have to explicitly
9617 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00009618 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00009619 CmdArgs.push_back("--32");
9620
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009621 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009622
9623 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00009624 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00009625
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009626 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00009627 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00009628
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009629 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009630 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009631}
9632
Douglas Katzman95354292015-06-23 20:42:09 +00009633void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9634 const InputInfo &Output,
9635 const InputInfoList &Inputs,
9636 const ArgList &Args,
9637 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00009638 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00009639 ArgStringList CmdArgs;
John McCall65b8da02013-04-11 22:55:55 +00009640
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00009641 if (!D.SysRoot.empty())
9642 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9643
John McCall65b8da02013-04-11 22:55:55 +00009644 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009645 if (Args.hasArg(options::OPT_static)) {
9646 CmdArgs.push_back("-Bstatic");
9647 } else {
John McCall65b8da02013-04-11 22:55:55 +00009648 if (Args.hasArg(options::OPT_rdynamic))
9649 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009650 if (Args.hasArg(options::OPT_shared))
9651 CmdArgs.push_back("-Bshareable");
9652 else {
9653 CmdArgs.push_back("-dynamic-linker");
9654 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
9655 }
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009656 CmdArgs.push_back("--hash-style=gnu");
9657 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009658 }
9659
9660 // When building 32-bit code on DragonFly/pc64, we have to explicitly
9661 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00009662 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009663 CmdArgs.push_back("-m");
9664 CmdArgs.push_back("elf_i386");
9665 }
9666
Daniel Dunbarb440f562010-08-02 02:38:21 +00009667 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009668 CmdArgs.push_back("-o");
9669 CmdArgs.push_back(Output.getFilename());
9670 } else {
9671 assert(Output.isNothing() && "Invalid output.");
9672 }
9673
Douglas Katzman78b37b02015-11-17 20:28:07 +00009674 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009675 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00009676 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009677 CmdArgs.push_back(
9678 Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009679 else {
9680 if (Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009681 CmdArgs.push_back(
9682 Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009683 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009684 CmdArgs.push_back(
9685 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009686 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009687 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009688 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
John McCall65b8da02013-04-11 22:55:55 +00009689 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009690 CmdArgs.push_back(
9691 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009692 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009693 CmdArgs.push_back(
9694 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009695 }
9696
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009697 Args.AddAllArgs(CmdArgs,
9698 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Daniel Dunbarcc912342009-05-02 18:28:39 +00009699
Daniel Dunbar54423b22010-09-17 00:24:54 +00009700 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009701
Douglas Katzman78b37b02015-11-17 20:28:07 +00009702 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009703 CmdArgs.push_back("-L/usr/lib/gcc50");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009704
9705 if (!Args.hasArg(options::OPT_static)) {
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009706 CmdArgs.push_back("-rpath");
9707 CmdArgs.push_back("/usr/lib/gcc50");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009708 }
9709
Hans Wennborg70850d82013-07-18 20:29:38 +00009710 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00009711 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00009712 CmdArgs.push_back("-lm");
9713 }
9714
Daniel Dunbarcc912342009-05-02 18:28:39 +00009715 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00009716 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009717
9718 if (!Args.hasArg(options::OPT_nolibc)) {
9719 CmdArgs.push_back("-lc");
9720 }
9721
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009722 if (Args.hasArg(options::OPT_static) ||
9723 Args.hasArg(options::OPT_static_libgcc)) {
John McCall65b8da02013-04-11 22:55:55 +00009724 CmdArgs.push_back("-lgcc");
9725 CmdArgs.push_back("-lgcc_eh");
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009726 } else {
9727 if (Args.hasArg(options::OPT_shared_libgcc)) {
John McCall65b8da02013-04-11 22:55:55 +00009728 CmdArgs.push_back("-lgcc_pic");
9729 if (!Args.hasArg(options::OPT_shared))
9730 CmdArgs.push_back("-lgcc");
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009731 } else {
John McCall65b8da02013-04-11 22:55:55 +00009732 CmdArgs.push_back("-lgcc");
9733 CmdArgs.push_back("--as-needed");
9734 CmdArgs.push_back("-lgcc_pic");
9735 CmdArgs.push_back("--no-as-needed");
John McCall65b8da02013-04-11 22:55:55 +00009736 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009737 }
9738 }
9739
Douglas Katzman78b37b02015-11-17 20:28:07 +00009740 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00009741 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009742 CmdArgs.push_back(
9743 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009744 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009745 CmdArgs.push_back(
9746 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
9747 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009748 }
9749
Xinliang David Li69306c02015-10-22 06:15:31 +00009750 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00009751
Logan Chieneb9162f2014-06-26 14:23:45 +00009752 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00009753 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009754}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009755
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009756// Try to find Exe from a Visual Studio distribution. This first tries to find
9757// an installed copy of Visual Studio and, failing that, looks in the PATH,
9758// making sure that whatever executable that's found is not a same-named exe
9759// from clang itself to prevent clang from falling back to itself.
9760static std::string FindVisualStudioExecutable(const ToolChain &TC,
9761 const char *Exe,
9762 const char *ClangProgramPath) {
9763 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
9764 std::string visualStudioBinDir;
9765 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
9766 visualStudioBinDir)) {
9767 SmallString<128> FilePath(visualStudioBinDir);
9768 llvm::sys::path::append(FilePath, Exe);
9769 if (llvm::sys::fs::can_execute(FilePath.c_str()))
9770 return FilePath.str();
9771 }
9772
9773 return Exe;
9774}
9775
Douglas Katzman95354292015-06-23 20:42:09 +00009776void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9777 const InputInfo &Output,
9778 const InputInfoList &Inputs,
9779 const ArgList &Args,
9780 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009781 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009782 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009783
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00009784 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
9785 if (Output.isFilename())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009786 CmdArgs.push_back(
9787 Args.MakeArgString(std::string("-out:") + Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009788
Douglas Katzman78b37b02015-11-17 20:28:07 +00009789 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
9790 !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009791 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009792
Zachary Turner10d75b22014-10-22 20:40:43 +00009793 if (!llvm::sys::Process::GetEnv("LIB")) {
9794 // If the VC environment hasn't been configured (perhaps because the user
9795 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00009796 // the environment variable is set however, assume the user knows what
9797 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00009798 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009799 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00009800 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
9801 SmallString<128> LibDir(VisualStudioDir);
9802 llvm::sys::path::append(LibDir, "VC", "lib");
9803 switch (MSVC.getArch()) {
9804 case llvm::Triple::x86:
9805 // x86 just puts the libraries directly in lib
9806 break;
9807 case llvm::Triple::x86_64:
9808 llvm::sys::path::append(LibDir, "amd64");
9809 break;
9810 case llvm::Triple::arm:
9811 llvm::sys::path::append(LibDir, "arm");
9812 break;
9813 default:
9814 break;
9815 }
9816 CmdArgs.push_back(
9817 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
Reid Kleckner7531f7d2015-09-11 00:09:39 +00009818
9819 if (MSVC.useUniversalCRT(VisualStudioDir)) {
9820 std::string UniversalCRTLibPath;
9821 if (MSVC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
9822 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9823 UniversalCRTLibPath.c_str()));
9824 }
Zachary Turner10d75b22014-10-22 20:40:43 +00009825 }
9826
9827 std::string WindowsSdkLibPath;
9828 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
9829 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9830 WindowsSdkLibPath.c_str()));
9831 }
9832
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009833 CmdArgs.push_back("-nologo");
9834
Reid Kleckner124955a2015-08-05 18:51:13 +00009835 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009836 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009837
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009838 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
Hans Wennborge4c47f22015-03-04 23:16:21 +00009839 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00009840 if (DLL) {
9841 CmdArgs.push_back(Args.MakeArgString("-dll"));
9842
9843 SmallString<128> ImplibName(Output.getFilename());
9844 llvm::sys::path::replace_extension(ImplibName, "lib");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009845 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00009846 }
9847
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009848 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00009849 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00009850 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009851 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009852 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
9853 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00009854 // Make sure the dynamic runtime thunk is not optimized out at link time
9855 // to ensure proper SEH handling.
9856 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009857 } else if (DLL) {
Xinliang David Li69306c02015-10-22 06:15:31 +00009858 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009859 } else {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009860 for (const auto &Lib : {"asan", "asan_cxx"})
9861 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009862 }
Hans Wennborg65f17522013-08-27 18:10:21 +00009863 }
9864
Hans Wennborg2e274592013-08-13 23:38:57 +00009865 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00009866
Alexey Bataevc7e84352015-08-19 04:49:01 +00009867 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9868 options::OPT_fno_openmp, false)) {
9869 CmdArgs.push_back("-nodefaultlib:vcomp.lib");
9870 CmdArgs.push_back("-nodefaultlib:vcompd.lib");
9871 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9872 TC.getDriver().Dir + "/../lib"));
9873 switch (getOpenMPRuntime(getToolChain(), Args)) {
9874 case OMPRT_OMP:
9875 CmdArgs.push_back("-defaultlib:libomp.lib");
9876 break;
9877 case OMPRT_IOMP5:
9878 CmdArgs.push_back("-defaultlib:libiomp5md.lib");
9879 break;
9880 case OMPRT_GOMP:
9881 break;
9882 case OMPRT_Unknown:
9883 // Already diagnosed.
9884 break;
9885 }
9886 }
9887
Andrey Turetskiya4868572016-03-14 11:19:43 +00009888 // Add compiler-rt lib in case if it was explicitly
9889 // specified as an argument for --rtlib option.
9890 if (!Args.hasArg(options::OPT_nostdlib)) {
9891 AddRunTimeLibs(TC, TC.getDriver(), CmdArgs, Args);
9892 }
9893
Reid Kleckner337188f2014-09-16 19:22:00 +00009894 // Add filenames, libraries, and other linker inputs.
9895 for (const auto &Input : Inputs) {
9896 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009897 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00009898 continue;
9899 }
9900
9901 const Arg &A = Input.getInputArg();
9902
9903 // Render -l options differently for the MSVC linker.
9904 if (A.getOption().matches(options::OPT_l)) {
9905 StringRef Lib = A.getValue();
9906 const char *LinkLibArg;
9907 if (Lib.endswith(".lib"))
9908 LinkLibArg = Args.MakeArgString(Lib);
9909 else
9910 LinkLibArg = Args.MakeArgString(Lib + ".lib");
9911 CmdArgs.push_back(LinkLibArg);
9912 continue;
9913 }
9914
9915 // Otherwise, this is some other kind of linker input option like -Wl, -z,
9916 // or -L. Render it, even if MSVC doesn't understand it.
9917 A.renderAsInput(Args, CmdArgs);
9918 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009919
Nathan Slingerlande8ddf9e2016-01-05 18:27:06 +00009920 TC.addProfileRTLibs(Args, CmdArgs);
9921
Zachary Turner719f58c2014-12-01 23:06:47 +00009922 // We need to special case some linker paths. In the case of lld, we need to
9923 // translate 'lld' into 'lld-link', and in the case of the regular msvc
9924 // linker, we need to use a special search algorithm.
9925 llvm::SmallString<128> linkPath;
9926 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
9927 if (Linker.equals_lower("lld"))
9928 Linker = "lld-link";
9929
9930 if (Linker.equals_lower("link")) {
9931 // If we're using the MSVC linker, it's not sufficient to just use link
9932 // from the program PATH, because other environments like GnuWin32 install
9933 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009934 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00009935 C.getDriver().getClangProgramPath());
9936 } else {
9937 linkPath = Linker;
9938 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009939 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00009940 }
9941
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009942 const char *Exec = Args.MakeArgString(linkPath);
Justin Bognerd3371d82015-07-17 03:35:54 +00009943 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009944}
Hans Wennborg87cfa712013-09-19 20:32:16 +00009945
Douglas Katzman95354292015-06-23 20:42:09 +00009946void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9947 const InputInfo &Output,
9948 const InputInfoList &Inputs,
9949 const ArgList &Args,
9950 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009951 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
9952}
9953
Douglas Katzman95354292015-06-23 20:42:09 +00009954std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
David Blaikiec11bf802014-09-04 16:04:28 +00009955 Compilation &C, const JobAction &JA, const InputInfo &Output,
9956 const InputInfoList &Inputs, const ArgList &Args,
9957 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009958 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00009959 CmdArgs.push_back("/nologo");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009960 CmdArgs.push_back("/c"); // Compile only.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009961 CmdArgs.push_back("/W0"); // No warnings.
9962
9963 // The goal is to be able to invoke this tool correctly based on
9964 // any flag accepted by clang-cl.
9965
9966 // These are spelled the same way in clang and cl.exe,.
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009967 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009968
9969 // Optimization level.
David Majnemer015ce0f2015-07-27 07:32:11 +00009970 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
9971 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"
9972 : "/Oi-");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009973 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
9974 if (A->getOption().getID() == options::OPT_O0) {
9975 CmdArgs.push_back("/Od");
9976 } else {
David Majnemer015ce0f2015-07-27 07:32:11 +00009977 CmdArgs.push_back("/Og");
9978
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009979 StringRef OptLevel = A->getValue();
David Majnemer015ce0f2015-07-27 07:32:11 +00009980 if (OptLevel == "s" || OptLevel == "z")
9981 CmdArgs.push_back("/Os");
9982 else
9983 CmdArgs.push_back("/Ot");
9984
9985 CmdArgs.push_back("/Ob2");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009986 }
9987 }
David Majnemer015ce0f2015-07-27 07:32:11 +00009988 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
9989 options::OPT_fno_omit_frame_pointer))
9990 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
9991 ? "/Oy"
9992 : "/Oy-");
9993 if (!Args.hasArg(options::OPT_fwritable_strings))
9994 CmdArgs.push_back("/GF");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009995
Nico Weber3f8dafb2015-03-12 19:37:10 +00009996 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009997 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
9998
David Majnemerf6072342014-07-01 22:24:56 +00009999 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
10000 /*default=*/false))
10001 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +000010002 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
10003 options::OPT_fno_function_sections))
10004 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
10005 ? "/Gy"
10006 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +000010007 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
10008 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +000010009 CmdArgs.push_back(
10010 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +000010011 if (Args.hasArg(options::OPT_fsyntax_only))
10012 CmdArgs.push_back("/Zs");
Reid Kleckner124955a2015-08-05 18:51:13 +000010013 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
10014 options::OPT__SLASH_Z7))
Reid Klecknerc688daf2014-02-19 22:05:59 +000010015 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +000010016
Nico Weber3f8dafb2015-03-12 19:37:10 +000010017 std::vector<std::string> Includes =
10018 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010019 for (const auto &Include : Includes)
10020 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +000010021
Hans Wennborg87cfa712013-09-19 20:32:16 +000010022 // Flags that can simply be passed through.
10023 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
10024 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
David Majnemerb8809092016-02-20 09:23:44 +000010025 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX);
10026 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX_);
Reid Klecknerc542d372014-06-27 17:02:02 +000010027 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
David Majnemerbac941c2015-07-25 06:07:59 +000010028 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
Hans Wennborg87cfa712013-09-19 20:32:16 +000010029
10030 // The order of these flags is relevant, so pick the last one.
10031 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
10032 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
10033 A->render(Args, CmdArgs);
10034
Ehsan Akhgarid8518332016-01-25 21:14:52 +000010035 // Pass through all unknown arguments so that the fallback command can see
10036 // them too.
10037 Args.AddAllArgs(CmdArgs, options::OPT_UNKNOWN);
10038
Hans Wennborg87cfa712013-09-19 20:32:16 +000010039 // Input filename.
10040 assert(Inputs.size() == 1);
10041 const InputInfo &II = Inputs[0];
10042 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
10043 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
10044 if (II.isFilename())
10045 CmdArgs.push_back(II.getFilename());
10046 else
10047 II.getInputArg().renderAsInput(Args, CmdArgs);
10048
10049 // Output filename.
10050 assert(Output.getType() == types::TY_Object);
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010051 const char *Fo =
10052 Args.MakeArgString(std::string("/Fo") + Output.getFilename());
Hans Wennborg87cfa712013-09-19 20:32:16 +000010053 CmdArgs.push_back(Fo);
10054
Hans Wennborg188382e2013-09-20 18:16:35 +000010055 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +000010056 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
10057 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +000010058 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
Justin Bognerd3371d82015-07-17 03:35:54 +000010059 CmdArgs, Inputs);
Hans Wennborg87cfa712013-09-19 20:32:16 +000010060}
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010061
Yaron Keren1c0070c2015-07-02 04:45:27 +000010062/// MinGW Tools
10063void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10064 const InputInfo &Output,
10065 const InputInfoList &Inputs,
10066 const ArgList &Args,
10067 const char *LinkingOutput) const {
10068 claimNoWarnArgs(Args);
10069 ArgStringList CmdArgs;
10070
10071 if (getToolChain().getArch() == llvm::Triple::x86) {
10072 CmdArgs.push_back("--32");
10073 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
10074 CmdArgs.push_back("--64");
10075 }
10076
10077 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10078
10079 CmdArgs.push_back("-o");
10080 CmdArgs.push_back(Output.getFilename());
10081
10082 for (const auto &II : Inputs)
10083 CmdArgs.push_back(II.getFilename());
10084
10085 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010086 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +000010087
10088 if (Args.hasArg(options::OPT_gsplit_dwarf))
10089 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
10090 SplitDebugName(Args, Inputs[0]));
10091}
10092
10093void MinGW::Linker::AddLibGCC(const ArgList &Args,
10094 ArgStringList &CmdArgs) const {
10095 if (Args.hasArg(options::OPT_mthreads))
10096 CmdArgs.push_back("-lmingwthrd");
10097 CmdArgs.push_back("-lmingw32");
Reid Kleckner0213a472015-07-22 16:01:38 +000010098
Yaron Kerenaa281332015-08-09 00:24:07 +000010099 // Make use of compiler-rt if --rtlib option is used
10100 ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
10101 if (RLT == ToolChain::RLT_Libgcc) {
10102 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
10103 Args.hasArg(options::OPT_static);
10104 bool Shared = Args.hasArg(options::OPT_shared);
10105 bool CXX = getToolChain().getDriver().CCCIsCXX();
10106
10107 if (Static || (!CXX && !Shared)) {
10108 CmdArgs.push_back("-lgcc");
10109 CmdArgs.push_back("-lgcc_eh");
10110 } else {
10111 CmdArgs.push_back("-lgcc_s");
10112 CmdArgs.push_back("-lgcc");
10113 }
10114 } else {
10115 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
10116 }
Reid Kleckner0213a472015-07-22 16:01:38 +000010117
Yaron Keren1c0070c2015-07-02 04:45:27 +000010118 CmdArgs.push_back("-lmoldname");
10119 CmdArgs.push_back("-lmingwex");
10120 CmdArgs.push_back("-lmsvcrt");
10121}
10122
10123void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10124 const InputInfo &Output,
10125 const InputInfoList &Inputs,
10126 const ArgList &Args,
10127 const char *LinkingOutput) const {
10128 const ToolChain &TC = getToolChain();
10129 const Driver &D = TC.getDriver();
10130 // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
10131
10132 ArgStringList CmdArgs;
10133
10134 // Silence warning for "clang -g foo.o -o foo"
10135 Args.ClaimAllArgs(options::OPT_g_Group);
10136 // and "clang -emit-llvm foo.o -o foo"
10137 Args.ClaimAllArgs(options::OPT_emit_llvm);
10138 // and for "clang -w foo.o -o foo". Other warning options are already
10139 // handled somewhere else.
10140 Args.ClaimAllArgs(options::OPT_w);
10141
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010142 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
10143 if (LinkerName.equals_lower("lld")) {
10144 CmdArgs.push_back("-flavor");
Martell Maloneaac044e2015-11-22 05:40:06 +000010145 CmdArgs.push_back("gnu");
Yaron Kerena7fa79f2015-11-15 08:06:27 +000010146 } else if (!LinkerName.equals_lower("ld")) {
10147 D.Diag(diag::err_drv_unsupported_linker) << LinkerName;
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010148 }
10149
Yaron Keren1c0070c2015-07-02 04:45:27 +000010150 if (!D.SysRoot.empty())
10151 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10152
10153 if (Args.hasArg(options::OPT_s))
10154 CmdArgs.push_back("-s");
10155
10156 CmdArgs.push_back("-m");
10157 if (TC.getArch() == llvm::Triple::x86)
10158 CmdArgs.push_back("i386pe");
10159 if (TC.getArch() == llvm::Triple::x86_64)
10160 CmdArgs.push_back("i386pep");
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010161 if (TC.getArch() == llvm::Triple::arm)
10162 CmdArgs.push_back("thumb2pe");
Yaron Keren1c0070c2015-07-02 04:45:27 +000010163
10164 if (Args.hasArg(options::OPT_mwindows)) {
10165 CmdArgs.push_back("--subsystem");
10166 CmdArgs.push_back("windows");
10167 } else if (Args.hasArg(options::OPT_mconsole)) {
10168 CmdArgs.push_back("--subsystem");
10169 CmdArgs.push_back("console");
10170 }
10171
10172 if (Args.hasArg(options::OPT_static))
10173 CmdArgs.push_back("-Bstatic");
10174 else {
10175 if (Args.hasArg(options::OPT_mdll))
10176 CmdArgs.push_back("--dll");
10177 else if (Args.hasArg(options::OPT_shared))
10178 CmdArgs.push_back("--shared");
10179 CmdArgs.push_back("-Bdynamic");
10180 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
10181 CmdArgs.push_back("-e");
10182 if (TC.getArch() == llvm::Triple::x86)
10183 CmdArgs.push_back("_DllMainCRTStartup@12");
10184 else
10185 CmdArgs.push_back("DllMainCRTStartup");
10186 CmdArgs.push_back("--enable-auto-image-base");
10187 }
10188 }
10189
10190 CmdArgs.push_back("-o");
10191 CmdArgs.push_back(Output.getFilename());
10192
10193 Args.AddAllArgs(CmdArgs, options::OPT_e);
10194 // FIXME: add -N, -n flags
10195 Args.AddLastArg(CmdArgs, options::OPT_r);
10196 Args.AddLastArg(CmdArgs, options::OPT_s);
10197 Args.AddLastArg(CmdArgs, options::OPT_t);
10198 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
10199 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
10200
Douglas Katzman78b37b02015-11-17 20:28:07 +000010201 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Yaron Keren1c0070c2015-07-02 04:45:27 +000010202 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
10203 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
10204 } else {
10205 if (Args.hasArg(options::OPT_municode))
10206 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
10207 else
10208 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
10209 }
10210 if (Args.hasArg(options::OPT_pg))
10211 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
10212 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
10213 }
10214
10215 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010216 TC.AddFilePathLibArgs(Args, CmdArgs);
Yaron Keren1c0070c2015-07-02 04:45:27 +000010217 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
10218
10219 // TODO: Add ASan stuff here
10220
10221 // TODO: Add profile stuff here
10222
Douglas Katzman78b37b02015-11-17 20:28:07 +000010223 if (D.CCCIsCXX() &&
10224 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Yaron Keren1c0070c2015-07-02 04:45:27 +000010225 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
10226 !Args.hasArg(options::OPT_static);
10227 if (OnlyLibstdcxxStatic)
10228 CmdArgs.push_back("-Bstatic");
10229 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
10230 if (OnlyLibstdcxxStatic)
10231 CmdArgs.push_back("-Bdynamic");
10232 }
10233
10234 if (!Args.hasArg(options::OPT_nostdlib)) {
10235 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
10236 if (Args.hasArg(options::OPT_static))
10237 CmdArgs.push_back("--start-group");
10238
10239 if (Args.hasArg(options::OPT_fstack_protector) ||
10240 Args.hasArg(options::OPT_fstack_protector_strong) ||
10241 Args.hasArg(options::OPT_fstack_protector_all)) {
10242 CmdArgs.push_back("-lssp_nonshared");
10243 CmdArgs.push_back("-lssp");
10244 }
10245 if (Args.hasArg(options::OPT_fopenmp))
10246 CmdArgs.push_back("-lgomp");
10247
10248 AddLibGCC(Args, CmdArgs);
10249
10250 if (Args.hasArg(options::OPT_pg))
10251 CmdArgs.push_back("-lgmon");
10252
Yaron Kerenadce68e2015-07-06 18:52:19 +000010253 if (Args.hasArg(options::OPT_pthread))
10254 CmdArgs.push_back("-lpthread");
Yaron Keren1c0070c2015-07-02 04:45:27 +000010255
10256 // add system libraries
10257 if (Args.hasArg(options::OPT_mwindows)) {
10258 CmdArgs.push_back("-lgdi32");
10259 CmdArgs.push_back("-lcomdlg32");
10260 }
10261 CmdArgs.push_back("-ladvapi32");
10262 CmdArgs.push_back("-lshell32");
10263 CmdArgs.push_back("-luser32");
10264 CmdArgs.push_back("-lkernel32");
10265
10266 if (Args.hasArg(options::OPT_static))
10267 CmdArgs.push_back("--end-group");
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010268 else if (!LinkerName.equals_lower("lld"))
Yaron Keren1c0070c2015-07-02 04:45:27 +000010269 AddLibGCC(Args, CmdArgs);
10270 }
10271
10272 if (!Args.hasArg(options::OPT_nostartfiles)) {
10273 // Add crtfastmath.o if available and fast math is enabled.
10274 TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
10275
10276 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
10277 }
10278 }
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010279 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
Justin Bognerd3371d82015-07-17 03:35:54 +000010280 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +000010281}
10282
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010283/// XCore Tools
10284// We pass assemble and link construction to the xcc tool.
10285
Douglas Katzman95354292015-06-23 20:42:09 +000010286void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10287 const InputInfo &Output,
10288 const InputInfoList &Inputs,
10289 const ArgList &Args,
10290 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +000010291 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010292 ArgStringList CmdArgs;
10293
10294 CmdArgs.push_back("-o");
10295 CmdArgs.push_back(Output.getFilename());
10296
10297 CmdArgs.push_back("-c");
10298
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010299 if (Args.hasArg(options::OPT_v))
10300 CmdArgs.push_back("-v");
10301
Robert Lytton894d25c2014-05-02 09:33:25 +000010302 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
10303 if (!A->getOption().matches(options::OPT_g0))
10304 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010305
Robert Lytton8e95d4e2014-02-11 10:34:45 +000010306 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
10307 false))
10308 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010309
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010310 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010311
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010312 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010313 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010314
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010315 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010316 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010317}
10318
Douglas Katzman95354292015-06-23 20:42:09 +000010319void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10320 const InputInfo &Output,
10321 const InputInfoList &Inputs,
10322 const ArgList &Args,
10323 const char *LinkingOutput) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010324 ArgStringList CmdArgs;
10325
10326 if (Output.isFilename()) {
10327 CmdArgs.push_back("-o");
10328 CmdArgs.push_back(Output.getFilename());
10329 } else {
10330 assert(Output.isNothing() && "Invalid output.");
10331 }
10332
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010333 if (Args.hasArg(options::OPT_v))
10334 CmdArgs.push_back("-v");
10335
Reid Kleckner0bb1fc42015-07-10 22:25:44 +000010336 // Pass -fexceptions through to the linker if it was present.
10337 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
10338 false))
Robert Lyttonf7e03c12014-02-13 10:34:44 +000010339 CmdArgs.push_back("-fexceptions");
10340
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010341 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
10342
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010343 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010344 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010345}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010346
Douglas Katzman95354292015-06-23 20:42:09 +000010347void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10348 const InputInfo &Output,
10349 const InputInfoList &Inputs,
10350 const ArgList &Args,
10351 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +000010352 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010353 const auto &TC =
10354 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
10355 ArgStringList CmdArgs;
10356 const char *Exec;
10357
10358 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010359 default:
10360 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010361 case llvm::Triple::arm:
10362 case llvm::Triple::thumb:
10363 break;
10364 case llvm::Triple::x86:
10365 CmdArgs.push_back("--32");
10366 break;
10367 case llvm::Triple::x86_64:
10368 CmdArgs.push_back("--64");
10369 break;
10370 }
10371
10372 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10373
10374 CmdArgs.push_back("-o");
10375 CmdArgs.push_back(Output.getFilename());
10376
10377 for (const auto &Input : Inputs)
10378 CmdArgs.push_back(Input.getFilename());
10379
10380 const std::string Assembler = TC.GetProgramPath("as");
10381 Exec = Args.MakeArgString(Assembler);
10382
Justin Bognerd3371d82015-07-17 03:35:54 +000010383 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010384}
10385
Douglas Katzman95354292015-06-23 20:42:09 +000010386void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10387 const InputInfo &Output,
10388 const InputInfoList &Inputs,
10389 const ArgList &Args,
10390 const char *LinkingOutput) const {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010391 const auto &TC =
10392 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
10393 const llvm::Triple &T = TC.getTriple();
10394 const Driver &D = TC.getDriver();
10395 SmallString<128> EntryPoint;
10396 ArgStringList CmdArgs;
10397 const char *Exec;
10398
10399 // Silence warning for "clang -g foo.o -o foo"
10400 Args.ClaimAllArgs(options::OPT_g_Group);
10401 // and "clang -emit-llvm foo.o -o foo"
10402 Args.ClaimAllArgs(options::OPT_emit_llvm);
10403 // and for "clang -w foo.o -o foo"
10404 Args.ClaimAllArgs(options::OPT_w);
10405 // Other warning options are already handled somewhere else.
10406
10407 if (!D.SysRoot.empty())
10408 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10409
10410 if (Args.hasArg(options::OPT_pie))
10411 CmdArgs.push_back("-pie");
10412 if (Args.hasArg(options::OPT_rdynamic))
10413 CmdArgs.push_back("-export-dynamic");
10414 if (Args.hasArg(options::OPT_s))
10415 CmdArgs.push_back("--strip-all");
10416
10417 CmdArgs.push_back("-m");
10418 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010419 default:
10420 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010421 case llvm::Triple::arm:
10422 case llvm::Triple::thumb:
10423 // FIXME: this is incorrect for WinCE
10424 CmdArgs.push_back("thumb2pe");
10425 break;
10426 case llvm::Triple::x86:
10427 CmdArgs.push_back("i386pe");
10428 EntryPoint.append("_");
10429 break;
10430 case llvm::Triple::x86_64:
10431 CmdArgs.push_back("i386pep");
10432 break;
10433 }
10434
10435 if (Args.hasArg(options::OPT_shared)) {
10436 switch (T.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010437 default:
10438 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010439 case llvm::Triple::arm:
10440 case llvm::Triple::thumb:
10441 case llvm::Triple::x86_64:
10442 EntryPoint.append("_DllMainCRTStartup");
10443 break;
10444 case llvm::Triple::x86:
10445 EntryPoint.append("_DllMainCRTStartup@12");
10446 break;
10447 }
10448
10449 CmdArgs.push_back("-shared");
10450 CmdArgs.push_back("-Bdynamic");
10451
10452 CmdArgs.push_back("--enable-auto-image-base");
10453
10454 CmdArgs.push_back("--entry");
10455 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10456 } else {
10457 EntryPoint.append("mainCRTStartup");
10458
10459 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
10460 : "-Bdynamic");
10461
Douglas Katzman78b37b02015-11-17 20:28:07 +000010462 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010463 CmdArgs.push_back("--entry");
10464 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10465 }
10466
10467 // FIXME: handle subsystem
10468 }
10469
10470 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +000010471 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010472
10473 CmdArgs.push_back("-o");
10474 CmdArgs.push_back(Output.getFilename());
10475
10476 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
10477 SmallString<261> ImpLib(Output.getFilename());
10478 llvm::sys::path::replace_extension(ImpLib, ".lib");
10479
10480 CmdArgs.push_back("--out-implib");
10481 CmdArgs.push_back(Args.MakeArgString(ImpLib));
10482 }
10483
Douglas Katzman78b37b02015-11-17 20:28:07 +000010484 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010485 const std::string CRTPath(D.SysRoot + "/usr/lib/");
10486 const char *CRTBegin;
10487
10488 CRTBegin =
10489 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
10490 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
10491 }
10492
10493 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010494 TC.AddFilePathLibArgs(Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010495 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
10496
10497 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
10498 !Args.hasArg(options::OPT_nodefaultlibs)) {
10499 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
10500 !Args.hasArg(options::OPT_static);
10501 if (StaticCXX)
10502 CmdArgs.push_back("-Bstatic");
10503 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
10504 if (StaticCXX)
10505 CmdArgs.push_back("-Bdynamic");
10506 }
10507
10508 if (!Args.hasArg(options::OPT_nostdlib)) {
10509 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
10510 // TODO handle /MT[d] /MD[d]
10511 CmdArgs.push_back("-lmsvcrt");
10512 AddRunTimeLibs(TC, D, CmdArgs, Args);
10513 }
10514 }
10515
Saleem Abdulrasoolbb2e5e42015-10-29 03:36:45 +000010516 if (TC.getSanitizerArgs().needsAsanRt()) {
10517 // TODO handle /MT[d] /MD[d]
10518 if (Args.hasArg(options::OPT_shared)) {
10519 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
10520 } else {
10521 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
10522 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Marcin Koscielnicki10721432016-05-12 10:27:59 +000010523 // Make sure the dynamic runtime thunk is not optimized out at link time
10524 // to ensure proper SEH handling.
10525 CmdArgs.push_back(Args.MakeArgString("--undefined"));
10526 CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
10527 ? "___asan_seh_interceptor"
10528 : "__asan_seh_interceptor"));
Saleem Abdulrasoolbb2e5e42015-10-29 03:36:45 +000010529 }
10530 }
10531
Saleem Abdulrasoolfd80f832015-10-28 04:45:58 +000010532 Exec = Args.MakeArgString(TC.GetLinkerPath());
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010533
Justin Bognerd3371d82015-07-17 03:35:54 +000010534 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010535}
Douglas Katzman84a75642015-06-19 14:55:19 +000010536
Douglas Katzman95354292015-06-23 20:42:09 +000010537void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
10538 const InputInfo &Output,
10539 const InputInfoList &Inputs,
10540 const ArgList &Args,
10541 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +000010542 ArgStringList CmdArgs;
Douglas Katzman84a75642015-06-19 14:55:19 +000010543 assert(Inputs.size() == 1);
10544 const InputInfo &II = Inputs[0];
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010545 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX ||
10546 II.getType() == types::TY_PP_CXX);
Douglas Katzman84a75642015-06-19 14:55:19 +000010547
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010548 if (JA.getKind() == Action::PreprocessJobClass) {
10549 Args.ClaimAllArgs();
10550 CmdArgs.push_back("-E");
10551 } else {
10552 assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm.
10553 CmdArgs.push_back("-S");
10554 CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified.
10555 }
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010556 CmdArgs.push_back("-DMYRIAD2");
Douglas Katzman84a75642015-06-19 14:55:19 +000010557
Douglas Katzmanf6071112015-08-03 14:34:22 +000010558 // Append all -I, -iquote, -isystem paths, defines/undefines,
10559 // 'f' flags, optimize flags, and warning options.
10560 // These are spelled the same way in clang and moviCompile.
Douglas Katzman38dca882015-09-08 19:29:55 +000010561 Args.AddAllArgs(CmdArgs, {options::OPT_I_Group, options::OPT_clang_i_Group,
Douglas Katzman642e5f92015-11-16 15:38:40 +000010562 options::OPT_std_EQ, options::OPT_D, options::OPT_U,
Douglas Katzman38dca882015-09-08 19:29:55 +000010563 options::OPT_f_Group, options::OPT_f_clang_Group,
10564 options::OPT_g_Group, options::OPT_M_Group,
Douglas Katzman4c125082016-03-15 16:41:31 +000010565 options::OPT_O_Group, options::OPT_W_Group,
10566 options::OPT_mcpu_EQ});
Douglas Katzman38dca882015-09-08 19:29:55 +000010567
10568 // If we're producing a dependency file, and assembly is the final action,
10569 // then the name of the target in the dependency file should be the '.o'
10570 // file, not the '.s' file produced by this step. For example, instead of
10571 // /tmp/mumble.s: mumble.c .../someheader.h
10572 // the filename on the lefthand side should be "mumble.o"
10573 if (Args.getLastArg(options::OPT_MF) && !Args.getLastArg(options::OPT_MT) &&
10574 C.getActions().size() == 1 &&
10575 C.getActions()[0]->getKind() == Action::AssembleJobClass) {
10576 Arg *A = Args.getLastArg(options::OPT_o);
10577 if (A) {
10578 CmdArgs.push_back("-MT");
10579 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
10580 }
10581 }
10582
Douglas Katzman84a75642015-06-19 14:55:19 +000010583 CmdArgs.push_back(II.getFilename());
10584 CmdArgs.push_back("-o");
10585 CmdArgs.push_back(Output.getFilename());
10586
10587 std::string Exec =
10588 Args.MakeArgString(getToolChain().GetProgramPath("moviCompile"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010589 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10590 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +000010591}
10592
Douglas Katzman95354292015-06-23 20:42:09 +000010593void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10594 const InputInfo &Output,
10595 const InputInfoList &Inputs,
10596 const ArgList &Args,
10597 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +000010598 ArgStringList CmdArgs;
10599
10600 assert(Inputs.size() == 1);
10601 const InputInfo &II = Inputs[0];
10602 assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input.
10603 assert(Output.getType() == types::TY_Object);
10604
10605 CmdArgs.push_back("-no6thSlotCompression");
Douglas Katzman4c125082016-03-15 16:41:31 +000010606 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
10607 if (CPUArg)
10608 CmdArgs.push_back(
10609 Args.MakeArgString("-cv:" + StringRef(CPUArg->getValue())));
Douglas Katzman84a75642015-06-19 14:55:19 +000010610 CmdArgs.push_back("-noSPrefixing");
10611 CmdArgs.push_back("-a"); // Mystery option.
Douglas Katzmanae2f3582015-09-11 21:13:46 +000010612 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10613 for (const Arg *A : Args.filtered(options::OPT_I, options::OPT_isystem)) {
10614 A->claim();
Douglas Katzman84a75642015-06-19 14:55:19 +000010615 CmdArgs.push_back(
Douglas Katzmanae2f3582015-09-11 21:13:46 +000010616 Args.MakeArgString(std::string("-i:") + A->getValue(0)));
Douglas Katzman84a75642015-06-19 14:55:19 +000010617 }
10618 CmdArgs.push_back("-elf"); // Output format.
10619 CmdArgs.push_back(II.getFilename());
10620 CmdArgs.push_back(
10621 Args.MakeArgString(std::string("-o:") + Output.getFilename()));
10622
10623 std::string Exec =
10624 Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010625 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10626 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +000010627}
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010628
10629void tools::Myriad::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10630 const InputInfo &Output,
10631 const InputInfoList &Inputs,
10632 const ArgList &Args,
10633 const char *LinkingOutput) const {
10634 const auto &TC =
10635 static_cast<const toolchains::MyriadToolChain &>(getToolChain());
10636 const llvm::Triple &T = TC.getTriple();
10637 ArgStringList CmdArgs;
Eric Christopher3f5d2bc2015-12-08 00:10:13 +000010638 bool UseStartfiles =
10639 !Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles);
Douglas Katzman78b37b02015-11-17 20:28:07 +000010640 bool UseDefaultLibs =
10641 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010642
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010643 if (T.getArch() == llvm::Triple::sparc)
10644 CmdArgs.push_back("-EB");
10645 else // SHAVE assumes little-endian, and sparcel is expressly so.
10646 CmdArgs.push_back("-EL");
10647
10648 // The remaining logic is mostly like gnutools::Linker::ConstructJob,
10649 // but we never pass through a --sysroot option and various other bits.
10650 // For example, there are no sanitizers (yet) nor gold linker.
10651
10652 // Eat some arguments that may be present but have no effect.
10653 Args.ClaimAllArgs(options::OPT_g_Group);
10654 Args.ClaimAllArgs(options::OPT_w);
10655 Args.ClaimAllArgs(options::OPT_static_libgcc);
10656
10657 if (Args.hasArg(options::OPT_s)) // Pass the 'strip' option.
10658 CmdArgs.push_back("-s");
10659
10660 CmdArgs.push_back("-o");
10661 CmdArgs.push_back(Output.getFilename());
10662
10663 if (UseStartfiles) {
10664 // If you want startfiles, it means you want the builtin crti and crtbegin,
10665 // but not crt0. Myriad link commands provide their own crt0.o as needed.
Douglas Katzman674a3122015-11-18 16:24:46 +000010666 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crti.o")));
10667 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010668 }
10669
10670 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
10671 options::OPT_e, options::OPT_s, options::OPT_t,
10672 options::OPT_Z_Flag, options::OPT_r});
10673
Douglas Katzman674a3122015-11-18 16:24:46 +000010674 TC.AddFilePathLibArgs(Args, CmdArgs);
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010675
10676 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
10677
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010678 if (UseDefaultLibs) {
Douglas Katzman795f57f2015-10-09 20:26:20 +000010679 if (C.getDriver().CCCIsCXX())
10680 CmdArgs.push_back("-lstdc++");
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010681 if (T.getOS() == llvm::Triple::RTEMS) {
10682 CmdArgs.push_back("--start-group");
10683 CmdArgs.push_back("-lc");
10684 // You must provide your own "-L" option to enable finding these.
10685 CmdArgs.push_back("-lrtemscpu");
10686 CmdArgs.push_back("-lrtemsbsp");
10687 CmdArgs.push_back("--end-group");
10688 } else {
10689 CmdArgs.push_back("-lc");
10690 }
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010691 CmdArgs.push_back("-lgcc");
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010692 }
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010693 if (UseStartfiles) {
Douglas Katzman674a3122015-11-18 16:24:46 +000010694 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
10695 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtn.o")));
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010696 }
10697
10698 std::string Exec =
10699 Args.MakeArgString(TC.GetProgramPath("sparc-myriad-elf-ld"));
10700 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10701 CmdArgs, Inputs));
10702}
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010703
10704void PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
10705 const InputInfo &Output,
10706 const InputInfoList &Inputs,
10707 const ArgList &Args,
10708 const char *LinkingOutput) const {
10709 claimNoWarnArgs(Args);
10710 ArgStringList CmdArgs;
10711
10712 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10713
10714 CmdArgs.push_back("-o");
10715 CmdArgs.push_back(Output.getFilename());
10716
10717 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
10718 const InputInfo &Input = Inputs[0];
10719 assert(Input.isFilename() && "Invalid input.");
10720 CmdArgs.push_back(Input.getFilename());
10721
10722 const char *Exec =
Paul Robinson9d613612016-05-16 17:22:25 +000010723 Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010724 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
10725}
10726
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010727static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
10728 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
10729 if (SanArgs.needsUbsanRt()) {
10730 CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
10731 }
10732 if (SanArgs.needsAsanRt()) {
10733 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
10734 }
10735}
10736
10737static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
10738 const JobAction &JA, const InputInfo &Output,
10739 const InputInfoList &Inputs,
10740 const ArgList &Args,
10741 const char *LinkingOutput) {
10742 const toolchains::FreeBSD &ToolChain =
10743 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10744 const Driver &D = ToolChain.getDriver();
10745 ArgStringList CmdArgs;
10746
10747 // Silence warning for "clang -g foo.o -o foo"
10748 Args.ClaimAllArgs(options::OPT_g_Group);
10749 // and "clang -emit-llvm foo.o -o foo"
10750 Args.ClaimAllArgs(options::OPT_emit_llvm);
10751 // and for "clang -w foo.o -o foo". Other warning options are already
10752 // handled somewhere else.
10753 Args.ClaimAllArgs(options::OPT_w);
10754
10755 if (!D.SysRoot.empty())
10756 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10757
10758 if (Args.hasArg(options::OPT_pie))
10759 CmdArgs.push_back("-pie");
10760
10761 if (Args.hasArg(options::OPT_rdynamic))
10762 CmdArgs.push_back("-export-dynamic");
10763 if (Args.hasArg(options::OPT_shared))
10764 CmdArgs.push_back("--oformat=so");
10765
10766 if (Output.isFilename()) {
10767 CmdArgs.push_back("-o");
10768 CmdArgs.push_back(Output.getFilename());
10769 } else {
10770 assert(Output.isNothing() && "Invalid output.");
10771 }
10772
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010773 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10774
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010775 Args.AddAllArgs(CmdArgs, options::OPT_L);
10776 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10777 Args.AddAllArgs(CmdArgs, options::OPT_e);
10778 Args.AddAllArgs(CmdArgs, options::OPT_s);
10779 Args.AddAllArgs(CmdArgs, options::OPT_t);
10780 Args.AddAllArgs(CmdArgs, options::OPT_r);
10781
10782 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10783 CmdArgs.push_back("--no-demangle");
10784
10785 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10786
10787 if (Args.hasArg(options::OPT_pthread)) {
10788 CmdArgs.push_back("-lpthread");
10789 }
10790
Paul Robinson9d613612016-05-16 17:22:25 +000010791 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010792
10793 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10794}
10795
10796static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
10797 const JobAction &JA, const InputInfo &Output,
10798 const InputInfoList &Inputs,
10799 const ArgList &Args,
10800 const char *LinkingOutput) {
10801 const toolchains::FreeBSD &ToolChain =
10802 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10803 const Driver &D = ToolChain.getDriver();
10804 ArgStringList CmdArgs;
10805
10806 // Silence warning for "clang -g foo.o -o foo"
10807 Args.ClaimAllArgs(options::OPT_g_Group);
10808 // and "clang -emit-llvm foo.o -o foo"
10809 Args.ClaimAllArgs(options::OPT_emit_llvm);
10810 // and for "clang -w foo.o -o foo". Other warning options are already
10811 // handled somewhere else.
10812 Args.ClaimAllArgs(options::OPT_w);
10813
10814 if (!D.SysRoot.empty())
10815 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10816
10817 if (Args.hasArg(options::OPT_pie))
10818 CmdArgs.push_back("-pie");
10819
10820 if (Args.hasArg(options::OPT_static)) {
10821 CmdArgs.push_back("-Bstatic");
10822 } else {
10823 if (Args.hasArg(options::OPT_rdynamic))
10824 CmdArgs.push_back("-export-dynamic");
10825 CmdArgs.push_back("--eh-frame-hdr");
10826 if (Args.hasArg(options::OPT_shared)) {
10827 CmdArgs.push_back("-Bshareable");
10828 } else {
10829 CmdArgs.push_back("-dynamic-linker");
10830 CmdArgs.push_back("/libexec/ld-elf.so.1");
10831 }
10832 CmdArgs.push_back("--enable-new-dtags");
10833 }
10834
10835 if (Output.isFilename()) {
10836 CmdArgs.push_back("-o");
10837 CmdArgs.push_back(Output.getFilename());
10838 } else {
10839 assert(Output.isNothing() && "Invalid output.");
10840 }
10841
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010842 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10843
Douglas Katzman78b37b02015-11-17 20:28:07 +000010844 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010845 const char *crt1 = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010846 if (!Args.hasArg(options::OPT_shared)) {
10847 if (Args.hasArg(options::OPT_pg))
10848 crt1 = "gcrt1.o";
10849 else if (Args.hasArg(options::OPT_pie))
10850 crt1 = "Scrt1.o";
10851 else
10852 crt1 = "crt1.o";
10853 }
10854 if (crt1)
10855 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
10856
10857 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
10858
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010859 const char *crtbegin = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010860 if (Args.hasArg(options::OPT_static))
10861 crtbegin = "crtbeginT.o";
10862 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10863 crtbegin = "crtbeginS.o";
10864 else
10865 crtbegin = "crtbegin.o";
10866
10867 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
10868 }
10869
10870 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010871 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010872 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10873 Args.AddAllArgs(CmdArgs, options::OPT_e);
10874 Args.AddAllArgs(CmdArgs, options::OPT_s);
10875 Args.AddAllArgs(CmdArgs, options::OPT_t);
10876 Args.AddAllArgs(CmdArgs, options::OPT_r);
10877
10878 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10879 CmdArgs.push_back("--no-demangle");
10880
10881 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10882
Douglas Katzman78b37b02015-11-17 20:28:07 +000010883 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010884 // For PS4, we always want to pass libm, libstdc++ and libkernel
10885 // libraries for both C and C++ compilations.
10886 CmdArgs.push_back("-lkernel");
10887 if (D.CCCIsCXX()) {
10888 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
10889 if (Args.hasArg(options::OPT_pg))
10890 CmdArgs.push_back("-lm_p");
10891 else
10892 CmdArgs.push_back("-lm");
10893 }
10894 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
10895 // the default system libraries. Just mimic this for now.
10896 if (Args.hasArg(options::OPT_pg))
10897 CmdArgs.push_back("-lgcc_p");
10898 else
10899 CmdArgs.push_back("-lcompiler_rt");
10900 if (Args.hasArg(options::OPT_static)) {
10901 CmdArgs.push_back("-lstdc++");
10902 } else if (Args.hasArg(options::OPT_pg)) {
10903 CmdArgs.push_back("-lgcc_eh_p");
10904 } else {
10905 CmdArgs.push_back("--as-needed");
10906 CmdArgs.push_back("-lstdc++");
10907 CmdArgs.push_back("--no-as-needed");
10908 }
10909
10910 if (Args.hasArg(options::OPT_pthread)) {
10911 if (Args.hasArg(options::OPT_pg))
10912 CmdArgs.push_back("-lpthread_p");
10913 else
10914 CmdArgs.push_back("-lpthread");
10915 }
10916
10917 if (Args.hasArg(options::OPT_pg)) {
10918 if (Args.hasArg(options::OPT_shared))
10919 CmdArgs.push_back("-lc");
10920 else {
10921 if (Args.hasArg(options::OPT_static)) {
10922 CmdArgs.push_back("--start-group");
10923 CmdArgs.push_back("-lc_p");
10924 CmdArgs.push_back("-lpthread_p");
10925 CmdArgs.push_back("--end-group");
10926 } else {
10927 CmdArgs.push_back("-lc_p");
10928 }
10929 }
10930 CmdArgs.push_back("-lgcc_p");
10931 } else {
10932 if (Args.hasArg(options::OPT_static)) {
10933 CmdArgs.push_back("--start-group");
10934 CmdArgs.push_back("-lc");
10935 CmdArgs.push_back("-lpthread");
10936 CmdArgs.push_back("--end-group");
10937 } else {
10938 CmdArgs.push_back("-lc");
10939 }
10940 CmdArgs.push_back("-lcompiler_rt");
10941 }
10942
10943 if (Args.hasArg(options::OPT_static)) {
10944 CmdArgs.push_back("-lstdc++");
10945 } else if (Args.hasArg(options::OPT_pg)) {
10946 CmdArgs.push_back("-lgcc_eh_p");
10947 } else {
10948 CmdArgs.push_back("--as-needed");
10949 CmdArgs.push_back("-lstdc++");
10950 CmdArgs.push_back("--no-as-needed");
10951 }
10952 }
10953
Douglas Katzman78b37b02015-11-17 20:28:07 +000010954 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010955 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10956 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
10957 else
10958 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
10959 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
10960 }
10961
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010962 const char *Exec =
10963#ifdef LLVM_ON_WIN32
Paul Robinson9d613612016-05-16 17:22:25 +000010964 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010965#else
Paul Robinson9d613612016-05-16 17:22:25 +000010966 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010967#endif
10968
10969 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10970}
10971
10972void PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
10973 const InputInfo &Output,
10974 const InputInfoList &Inputs,
10975 const ArgList &Args,
10976 const char *LinkingOutput) const {
10977 const toolchains::FreeBSD &ToolChain =
10978 static_cast<const toolchains::FreeBSD &>(getToolChain());
10979 const Driver &D = ToolChain.getDriver();
10980 bool PS4Linker;
10981 StringRef LinkerOptName;
10982 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
10983 LinkerOptName = A->getValue();
10984 if (LinkerOptName != "ps4" && LinkerOptName != "gold")
10985 D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
10986 }
10987
10988 if (LinkerOptName == "gold")
10989 PS4Linker = false;
10990 else if (LinkerOptName == "ps4")
10991 PS4Linker = true;
10992 else
10993 PS4Linker = !Args.hasArg(options::OPT_shared);
10994
10995 if (PS4Linker)
10996 ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10997 else
10998 ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10999}
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011000
11001void NVPTX::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
11002 const InputInfo &Output,
11003 const InputInfoList &Inputs,
11004 const ArgList &Args,
11005 const char *LinkingOutput) const {
11006 const auto &TC =
11007 static_cast<const toolchains::CudaToolChain &>(getToolChain());
Justin Lebarb2db4502016-01-23 21:28:08 +000011008 assert(TC.getTriple().isNVPTX() && "Wrong platform");
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011009
11010 std::vector<std::string> gpu_archs =
11011 Args.getAllArgValues(options::OPT_march_EQ);
11012 assert(gpu_archs.size() == 1 && "Exactly one GPU Arch required for ptxas.");
11013 const std::string& gpu_arch = gpu_archs[0];
11014
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011015 ArgStringList CmdArgs;
11016 CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-m64" : "-m32");
Justin Lebarb41f33c2016-04-19 02:27:11 +000011017 if (Args.hasFlag(options::OPT_cuda_noopt_device_debug,
11018 options::OPT_no_cuda_noopt_device_debug, false)) {
Artem Belevich0a0e54c2016-02-16 22:03:20 +000011019 // ptxas does not accept -g option if optimization is enabled, so
11020 // we ignore the compiler's -O* options if we want debug info.
11021 CmdArgs.push_back("-g");
11022 CmdArgs.push_back("--dont-merge-basicblocks");
11023 CmdArgs.push_back("--return-at-end");
11024 } else if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
11025 // Map the -O we received to -O{0,1,2,3}.
11026 //
11027 // TODO: Perhaps we should map host -O2 to ptxas -O3. -O3 is ptxas's
11028 // default, so it may correspond more closely to the spirit of clang -O2.
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011029
Justin Lebar2836dcd2016-01-19 19:52:21 +000011030 // -O3 seems like the least-bad option when -Osomething is specified to
11031 // clang but it isn't handled below.
11032 StringRef OOpt = "3";
11033 if (A->getOption().matches(options::OPT_O4) ||
11034 A->getOption().matches(options::OPT_Ofast))
11035 OOpt = "3";
11036 else if (A->getOption().matches(options::OPT_O0))
11037 OOpt = "0";
11038 else if (A->getOption().matches(options::OPT_O)) {
11039 // -Os, -Oz, and -O(anything else) map to -O2, for lack of better options.
11040 OOpt = llvm::StringSwitch<const char *>(A->getValue())
11041 .Case("1", "1")
11042 .Case("2", "2")
11043 .Case("3", "3")
11044 .Case("s", "2")
11045 .Case("z", "2")
11046 .Default("2");
11047 }
11048 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-O") + OOpt));
11049 } else {
11050 // If no -O was passed, pass -O0 to ptxas -- no opt flag should correspond
11051 // to no optimizations, but ptxas's default is -O3.
11052 CmdArgs.push_back("-O0");
11053 }
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011054
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011055 CmdArgs.push_back("--gpu-name");
11056 CmdArgs.push_back(Args.MakeArgString(gpu_arch));
11057 CmdArgs.push_back("--output-file");
11058 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
11059 for (const auto& II : Inputs)
11060 CmdArgs.push_back(Args.MakeArgString(II.getFilename()));
11061
11062 for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
11063 CmdArgs.push_back(Args.MakeArgString(A));
11064
11065 const char *Exec = Args.MakeArgString(TC.GetProgramPath("ptxas"));
11066 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
11067}
11068
11069// All inputs to this linker must be from CudaDeviceActions, as we need to look
11070// at the Inputs' Actions in order to figure out which GPU architecture they
11071// correspond to.
11072void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
11073 const InputInfo &Output,
11074 const InputInfoList &Inputs,
11075 const ArgList &Args,
11076 const char *LinkingOutput) const {
11077 const auto &TC =
11078 static_cast<const toolchains::CudaToolChain &>(getToolChain());
Justin Lebarb2db4502016-01-23 21:28:08 +000011079 assert(TC.getTriple().isNVPTX() && "Wrong platform");
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011080
11081 ArgStringList CmdArgs;
11082 CmdArgs.push_back("--cuda");
11083 CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-64" : "-32");
11084 CmdArgs.push_back(Args.MakeArgString("--create"));
11085 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
11086
11087 for (const auto& II : Inputs) {
11088 auto* A = cast<const CudaDeviceAction>(II.getAction());
11089 // We need to pass an Arch of the form "sm_XX" for cubin files and
11090 // "compute_XX" for ptx.
11091 const char *Arch = (II.getType() == types::TY_PP_Asm)
11092 ? A->getComputeArchName()
11093 : A->getGpuArchName();
11094 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("--image=profile=") +
11095 Arch + ",file=" + II.getFilename()));
11096 }
11097
11098 for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
11099 CmdArgs.push_back(Args.MakeArgString(A));
11100
11101 const char *Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
11102 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
11103}