blob: 003313692497ed80f3a181dd22b0fdb07aa5a01c [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
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00001643sparc::FloatABI sparc::getSparcFloatABI(const Driver &D,
1644 const ArgList &Args) {
1645 sparc::FloatABI ABI = sparc::FloatABI::Invalid;
1646 if (Arg *A =
1647 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1648 options::OPT_mfloat_abi_EQ)) {
1649 if (A->getOption().matches(options::OPT_msoft_float))
1650 ABI = sparc::FloatABI::Soft;
1651 else if (A->getOption().matches(options::OPT_mhard_float))
1652 ABI = sparc::FloatABI::Hard;
1653 else {
1654 ABI = llvm::StringSwitch<sparc::FloatABI>(A->getValue())
1655 .Case("soft", sparc::FloatABI::Soft)
1656 .Case("hard", sparc::FloatABI::Hard)
1657 .Default(sparc::FloatABI::Invalid);
1658 if (ABI == sparc::FloatABI::Invalid &&
1659 !StringRef(A->getValue()).empty()) {
1660 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1661 ABI = sparc::FloatABI::Hard;
1662 }
1663 }
1664 }
1665
1666 // If unspecified, choose the default based on the platform.
1667 // Only the hard-float ABI on Sparc is standardized, and it is the
1668 // default. GCC also supports a nonstandard soft-float ABI mode, also
1669 // implemented in LLVM. However as this is not standard we set the default
1670 // to be hard-float.
1671 if (ABI == sparc::FloatABI::Invalid) {
1672 ABI = sparc::FloatABI::Hard;
1673 }
1674
1675 return ABI;
1676}
1677
1678static void getSparcTargetFeatures(const Driver &D, const ArgList &Args,
1679 std::vector<const char *> &Features) {
1680 sparc::FloatABI FloatABI = sparc::getSparcFloatABI(D, Args);
1681 if (FloatABI == sparc::FloatABI::Soft)
1682 Features.push_back("+soft-float");
1683}
1684
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001685void Clang::AddSparcTargetArgs(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001686 ArgStringList &CmdArgs) const {
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00001687 //const Driver &D = getToolChain().getDriver();
James Y Knightb2406522015-06-15 20:51:24 +00001688 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001689
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00001690 sparc::FloatABI FloatABI =
1691 sparc::getSparcFloatABI(getToolChain().getDriver(), Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001692
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00001693 if (FloatABI == sparc::FloatABI::Soft) {
1694 // Floating point operations and argument passing are soft.
1695 CmdArgs.push_back("-msoft-float");
1696 CmdArgs.push_back("-mfloat-abi");
1697 CmdArgs.push_back("soft");
1698 } else {
1699 // Floating point operations and argument passing are hard.
1700 assert(FloatABI == sparc::FloatABI::Hard && "Invalid float abi!");
1701 CmdArgs.push_back("-mfloat-abi");
1702 CmdArgs.push_back("hard");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001703 }
1704}
1705
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +00001706void Clang::AddSystemZTargetArgs(const ArgList &Args,
1707 ArgStringList &CmdArgs) const {
1708 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false))
1709 CmdArgs.push_back("-mbackchain");
1710}
1711
Richard Sandiford4652d892013-07-19 16:51:51 +00001712static const char *getSystemZTargetCPU(const ArgList &Args) {
1713 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1714 return A->getValue();
1715 return "z10";
1716}
1717
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001718static void getSystemZTargetFeatures(const ArgList &Args,
1719 std::vector<const char *> &Features) {
1720 // -m(no-)htm overrides use of the transactional-execution facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001721 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001722 if (A->getOption().matches(options::OPT_mhtm))
1723 Features.push_back("+transactional-execution");
1724 else
1725 Features.push_back("-transactional-execution");
1726 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001727 // -m(no-)vx overrides use of the vector facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001728 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001729 if (A->getOption().matches(options::OPT_mvx))
1730 Features.push_back("+vector");
1731 else
1732 Features.push_back("-vector");
1733 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001734}
1735
Chandler Carruth953fb082013-01-13 11:46:33 +00001736static const char *getX86TargetCPU(const ArgList &Args,
1737 const llvm::Triple &Triple) {
1738 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001739 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001740 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001741 return "core-avx2";
1742
Chandler Carruth953fb082013-01-13 11:46:33 +00001743 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001744 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001745
1746 // FIXME: Reject attempts to use -march=native unless the target matches
1747 // the host.
1748 //
1749 // FIXME: We should also incorporate the detected target features for use
1750 // with -native.
1751 std::string CPU = llvm::sys::getHostCPUName();
1752 if (!CPU.empty() && CPU != "generic")
1753 return Args.MakeArgString(CPU);
1754 }
1755
Reid Kleckner3123eff2015-06-30 16:32:04 +00001756 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1757 // Mapping built by referring to X86TargetInfo::getDefaultFeatures().
1758 StringRef Arch = A->getValue();
1759 const char *CPU;
1760 if (Triple.getArch() == llvm::Triple::x86) {
1761 CPU = llvm::StringSwitch<const char *>(Arch)
1762 .Case("IA32", "i386")
1763 .Case("SSE", "pentium3")
1764 .Case("SSE2", "pentium4")
1765 .Case("AVX", "sandybridge")
1766 .Case("AVX2", "haswell")
1767 .Default(nullptr);
1768 } else {
1769 CPU = llvm::StringSwitch<const char *>(Arch)
1770 .Case("AVX", "sandybridge")
1771 .Case("AVX2", "haswell")
1772 .Default(nullptr);
1773 }
1774 if (CPU)
1775 return CPU;
1776 }
1777
Chandler Carruth953fb082013-01-13 11:46:33 +00001778 // Select the default CPU if none was given (or detection failed).
1779
1780 if (Triple.getArch() != llvm::Triple::x86_64 &&
1781 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001782 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001783
1784 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1785
1786 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001787 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001788 if (Triple.getArchName() == "x86_64h")
1789 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001790 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001791 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001792
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001793 // Set up default CPU name for PS4 compilers.
1794 if (Triple.isPS4CPU())
1795 return "btver2";
1796
Alexey Bataev286d1b92014-01-31 04:07:13 +00001797 // On Android use targets compatible with gcc
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001798 if (Triple.isAndroid())
Alexey Bataev286d1b92014-01-31 04:07:13 +00001799 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001800
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001801 // Everything else goes to x86-64 in 64-bit mode.
1802 if (Is64Bit)
1803 return "x86-64";
1804
1805 switch (Triple.getOS()) {
1806 case llvm::Triple::FreeBSD:
1807 case llvm::Triple::NetBSD:
1808 case llvm::Triple::OpenBSD:
1809 return "i486";
1810 case llvm::Triple::Haiku:
1811 return "i586";
1812 case llvm::Triple::Bitrig:
1813 return "i686";
1814 default:
1815 // Fallback to p4.
1816 return "pentium4";
1817 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001818}
1819
Dan Gohmanc2853072015-09-03 22:51:53 +00001820/// Get the (LLVM) name of the WebAssembly cpu we are targeting.
1821static StringRef getWebAssemblyTargetCPU(const ArgList &Args) {
1822 // If we have -mcpu=, use that.
1823 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1824 StringRef CPU = A->getValue();
1825
1826#ifdef __wasm__
1827 // Handle "native" by examining the host. "native" isn't meaningful when
1828 // cross compiling, so only support this when the host is also WebAssembly.
1829 if (CPU == "native")
1830 return llvm::sys::getHostCPUName();
1831#endif
1832
1833 return CPU;
1834 }
1835
1836 return "generic";
1837}
1838
Renato Golin7c542b42015-07-27 23:44:45 +00001839static std::string getCPUName(const ArgList &Args, const llvm::Triple &T,
1840 bool FromAs = false) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001841 switch (T.getArch()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001842 default:
1843 return "";
1844
Amara Emerson703da2e2013-10-31 09:32:33 +00001845 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001846 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001847 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001848
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001849 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001850 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001851 case llvm::Triple::thumb:
Renato Goline17c5802015-07-27 23:44:42 +00001852 case llvm::Triple::thumbeb: {
1853 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00001854 getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs);
Renato Goline17c5802015-07-27 23:44:42 +00001855 return arm::getARMTargetCPU(MCPU, MArch, T);
1856 }
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001857 case llvm::Triple::mips:
1858 case llvm::Triple::mipsel:
1859 case llvm::Triple::mips64:
1860 case llvm::Triple::mips64el: {
1861 StringRef CPUName;
1862 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001863 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001864 return CPUName;
1865 }
1866
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001867 case llvm::Triple::nvptx:
1868 case llvm::Triple::nvptx64:
1869 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1870 return A->getValue();
1871 return "";
1872
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001873 case llvm::Triple::ppc:
1874 case llvm::Triple::ppc64:
1875 case llvm::Triple::ppc64le: {
1876 std::string TargetCPUName = getPPCTargetCPU(Args);
1877 // LLVM may default to generating code for the native CPU,
1878 // but, like gcc, we default to a more generic option for
1879 // each architecture. (except on Darwin)
1880 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1881 if (T.getArch() == llvm::Triple::ppc64)
1882 TargetCPUName = "ppc64";
1883 else if (T.getArch() == llvm::Triple::ppc64le)
1884 TargetCPUName = "ppc64le";
1885 else
1886 TargetCPUName = "ppc";
1887 }
1888 return TargetCPUName;
1889 }
1890
1891 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001892 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001893 case llvm::Triple::sparcv9:
1894 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001895 return A->getValue();
1896 return "";
1897
1898 case llvm::Triple::x86:
1899 case llvm::Triple::x86_64:
1900 return getX86TargetCPU(Args, T);
1901
1902 case llvm::Triple::hexagon:
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00001903 return "hexagon" +
1904 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001905
Jacques Pienaard964cc22016-03-28 21:02:54 +00001906 case llvm::Triple::lanai:
1907 return getLanaiTargetCPU(Args);
1908
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001909 case llvm::Triple::systemz:
1910 return getSystemZTargetCPU(Args);
1911
1912 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001913 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001914 return getR600TargetGPU(Args);
Dan Gohmanc2853072015-09-03 22:51:53 +00001915
1916 case llvm::Triple::wasm32:
1917 case llvm::Triple::wasm64:
1918 return getWebAssemblyTargetCPU(Args);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001919 }
1920}
1921
Alp Tokerce365ca2013-12-02 12:43:03 +00001922static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
Teresa Johnson945bc502015-10-15 20:35:53 +00001923 ArgStringList &CmdArgs, bool IsThinLTO) {
Alp Tokerce365ca2013-12-02 12:43:03 +00001924 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1925 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1926 // forward.
1927 CmdArgs.push_back("-plugin");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001928 std::string Plugin =
1929 ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001930 CmdArgs.push_back(Args.MakeArgString(Plugin));
1931
1932 // Try to pass driver level flags relevant to LTO code generation down to
1933 // the plugin.
1934
1935 // Handle flags for selecting CPU variants.
1936 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1937 if (!CPU.empty())
1938 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
Teresa Johnson945bc502015-10-15 20:35:53 +00001939
James Molloyf97fdae2015-12-21 10:44:36 +00001940 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1941 StringRef OOpt;
1942 if (A->getOption().matches(options::OPT_O4) ||
1943 A->getOption().matches(options::OPT_Ofast))
1944 OOpt = "3";
1945 else if (A->getOption().matches(options::OPT_O))
1946 OOpt = A->getValue();
1947 else if (A->getOption().matches(options::OPT_O0))
1948 OOpt = "0";
1949 if (!OOpt.empty())
1950 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=O") + OOpt));
1951 }
1952
Teresa Johnson6ef80dc2015-11-02 18:03:12 +00001953 if (IsThinLTO)
1954 CmdArgs.push_back("-plugin-opt=thinlto");
Paul Robinson4391d092016-01-25 19:46:40 +00001955
1956 // If an explicit debugger tuning argument appeared, pass it along.
1957 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
1958 options::OPT_ggdbN_Group)) {
1959 if (A->getOption().matches(options::OPT_glldb))
1960 CmdArgs.push_back("-plugin-opt=-debugger-tune=lldb");
1961 else if (A->getOption().matches(options::OPT_gsce))
1962 CmdArgs.push_back("-plugin-opt=-debugger-tune=sce");
1963 else
1964 CmdArgs.push_back("-plugin-opt=-debugger-tune=gdb");
1965 }
Alp Tokerce365ca2013-12-02 12:43:03 +00001966}
1967
Sanjay Patel2987c292015-06-11 14:53:41 +00001968/// This is a helper function for validating the optional refinement step
1969/// parameter in reciprocal argument strings. Return false if there is an error
1970/// parsing the refinement step. Otherwise, return true and set the Position
1971/// of the refinement step in the input string.
Craig Topper3db9ba42015-09-21 00:20:04 +00001972static bool getRefinementStep(StringRef In, const Driver &D,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001973 const Arg &A, size_t &Position) {
Sanjay Patel2987c292015-06-11 14:53:41 +00001974 const char RefinementStepToken = ':';
1975 Position = In.find(RefinementStepToken);
1976 if (Position != StringRef::npos) {
1977 StringRef Option = A.getOption().getName();
1978 StringRef RefStep = In.substr(Position + 1);
1979 // Allow exactly one numeric character for the additional refinement
1980 // step parameter. This is reasonable for all currently-supported
1981 // operations and architectures because we would expect that a larger value
1982 // of refinement steps would cause the estimate "optimization" to
1983 // under-perform the native operation. Also, if the estimate does not
1984 // converge quickly, it probably will not ever converge, so further
1985 // refinement steps will not produce a better answer.
1986 if (RefStep.size() != 1) {
1987 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1988 return false;
1989 }
1990 char RefStepChar = RefStep[0];
1991 if (RefStepChar < '0' || RefStepChar > '9') {
1992 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1993 return false;
1994 }
1995 }
1996 return true;
1997}
1998
1999/// The -mrecip flag requires processing of many optional parameters.
2000static void ParseMRecip(const Driver &D, const ArgList &Args,
2001 ArgStringList &OutStrings) {
2002 StringRef DisabledPrefixIn = "!";
2003 StringRef DisabledPrefixOut = "!";
2004 StringRef EnabledPrefixOut = "";
2005 StringRef Out = "-mrecip=";
2006
2007 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
2008 if (!A)
2009 return;
2010
2011 unsigned NumOptions = A->getNumValues();
2012 if (NumOptions == 0) {
2013 // No option is the same as "all".
2014 OutStrings.push_back(Args.MakeArgString(Out + "all"));
2015 return;
2016 }
2017
2018 // Pass through "all", "none", or "default" with an optional refinement step.
2019 if (NumOptions == 1) {
2020 StringRef Val = A->getValue(0);
2021 size_t RefStepLoc;
2022 if (!getRefinementStep(Val, D, *A, RefStepLoc))
2023 return;
2024 StringRef ValBase = Val.slice(0, RefStepLoc);
2025 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
2026 OutStrings.push_back(Args.MakeArgString(Out + Val));
2027 return;
2028 }
2029 }
2030
2031 // Each reciprocal type may be enabled or disabled individually.
2032 // Check each input value for validity, concatenate them all back together,
2033 // and pass through.
2034
2035 llvm::StringMap<bool> OptionStrings;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002036 OptionStrings.insert(std::make_pair("divd", false));
2037 OptionStrings.insert(std::make_pair("divf", false));
2038 OptionStrings.insert(std::make_pair("vec-divd", false));
2039 OptionStrings.insert(std::make_pair("vec-divf", false));
2040 OptionStrings.insert(std::make_pair("sqrtd", false));
2041 OptionStrings.insert(std::make_pair("sqrtf", false));
2042 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
2043 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
Sanjay Patel2987c292015-06-11 14:53:41 +00002044
2045 for (unsigned i = 0; i != NumOptions; ++i) {
2046 StringRef Val = A->getValue(i);
2047
2048 bool IsDisabled = Val.startswith(DisabledPrefixIn);
2049 // Ignore the disablement token for string matching.
2050 if (IsDisabled)
2051 Val = Val.substr(1);
2052
2053 size_t RefStep;
2054 if (!getRefinementStep(Val, D, *A, RefStep))
2055 return;
2056
2057 StringRef ValBase = Val.slice(0, RefStep);
2058 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
2059 if (OptionIter == OptionStrings.end()) {
2060 // Try again specifying float suffix.
2061 OptionIter = OptionStrings.find(ValBase.str() + 'f');
2062 if (OptionIter == OptionStrings.end()) {
2063 // The input name did not match any known option string.
2064 D.Diag(diag::err_drv_unknown_argument) << Val;
2065 return;
2066 }
2067 // The option was specified without a float or double suffix.
2068 // Make sure that the double entry was not already specified.
2069 // The float entry will be checked below.
2070 if (OptionStrings[ValBase.str() + 'd']) {
2071 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
2072 return;
2073 }
2074 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002075
Sanjay Patel2987c292015-06-11 14:53:41 +00002076 if (OptionIter->second == true) {
2077 // Duplicate option specified.
2078 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
2079 return;
2080 }
2081
2082 // Mark the matched option as found. Do not allow duplicate specifiers.
2083 OptionIter->second = true;
2084
2085 // If the precision was not specified, also mark the double entry as found.
2086 if (ValBase.back() != 'f' && ValBase.back() != 'd')
2087 OptionStrings[ValBase.str() + 'd'] = true;
2088
2089 // Build the output string.
2090 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
2091 Out = Args.MakeArgString(Out + Prefix + Val);
2092 if (i != NumOptions - 1)
2093 Out = Args.MakeArgString(Out + ",");
2094 }
2095
2096 OutStrings.push_back(Args.MakeArgString(Out));
2097}
2098
Eric Christopherc54920a2015-03-23 19:26:05 +00002099static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00002100 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002101 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00002102 // If -march=native, autodetect the feature list.
2103 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
2104 if (StringRef(A->getValue()) == "native") {
2105 llvm::StringMap<bool> HostFeatures;
2106 if (llvm::sys::getHostCPUFeatures(HostFeatures))
2107 for (auto &F : HostFeatures)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002108 Features.push_back(
2109 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
Craig Toppera8bd6002015-03-31 05:45:00 +00002110 }
2111 }
2112
Jim Grosbach82eee262013-11-16 00:53:35 +00002113 if (Triple.getArchName() == "x86_64h") {
2114 // x86_64h implies quite a few of the more modern subtarget features
2115 // for Haswell class CPUs, but not all of them. Opt-out of a few.
2116 Features.push_back("-rdrnd");
2117 Features.push_back("-aes");
2118 Features.push_back("-pclmul");
2119 Features.push_back("-rtm");
2120 Features.push_back("-hle");
2121 Features.push_back("-fsgsbase");
2122 }
2123
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002124 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00002125 // Add features to be compatible with gcc for Android.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00002126 if (Triple.isAndroid()) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002127 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00002128 Features.push_back("+sse4.2");
2129 Features.push_back("+popcnt");
2130 } else
2131 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00002132 }
2133
Eric Christopherc54920a2015-03-23 19:26:05 +00002134 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002135 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
2136 StringRef Arch = A->getValue();
2137 bool ArchUsed = false;
2138 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002139 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002140 if (Arch == "AVX" || Arch == "AVX2") {
2141 ArchUsed = true;
2142 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
2143 }
2144 }
2145 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00002146 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002147 if (Arch == "IA32") {
2148 ArchUsed = true;
2149 } else if (Arch == "SSE" || Arch == "SSE2") {
2150 ArchUsed = true;
2151 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
2152 }
2153 }
2154 if (!ArchUsed)
2155 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
2156 }
2157
Jim Grosbach82eee262013-11-16 00:53:35 +00002158 // Now add any that the user explicitly requested on the command line,
2159 // which may override the defaults.
Eric Christopher49062a52015-12-22 03:12:34 +00002160 handleTargetFeaturesGroup(Args, Features, options::OPT_m_x86_Features_Group);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002161}
2162
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002163void Clang::AddX86TargetArgs(const ArgList &Args,
2164 ArgStringList &CmdArgs) const {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002165 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00002166 Args.hasArg(options::OPT_mkernel) ||
2167 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002168 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00002169
Bob Wilson2616e2e2013-02-10 16:01:41 +00002170 // Default to avoid implicit floating-point for kernel/kext code, but allow
2171 // that to be overridden with -mno-soft-float.
2172 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2173 Args.hasArg(options::OPT_fapple_kext));
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002174 if (Arg *A = Args.getLastArg(
2175 options::OPT_msoft_float, options::OPT_mno_soft_float,
2176 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
Bob Wilson2616e2e2013-02-10 16:01:41 +00002177 const Option &O = A->getOption();
2178 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2179 O.matches(options::OPT_msoft_float));
2180 }
2181 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00002182 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00002183
2184 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2185 StringRef Value = A->getValue();
2186 if (Value == "intel" || Value == "att") {
2187 CmdArgs.push_back("-mllvm");
2188 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
2189 } else {
2190 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
2191 << A->getOption().getName() << Value;
2192 }
2193 }
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +00002194
2195 // Set flags to support MCU ABI.
2196 if (Args.hasArg(options::OPT_miamcu)) {
2197 CmdArgs.push_back("-mfloat-abi");
2198 CmdArgs.push_back("soft");
2199 CmdArgs.push_back("-mstack-alignment=4");
2200 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00002201}
2202
Tony Linthicum76329bf2011-12-12 21:14:55 +00002203void Clang::AddHexagonTargetArgs(const ArgList &Args,
2204 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00002205 CmdArgs.push_back("-mqdsp6-compat");
2206 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00002207
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002208 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
2209 std::string N = llvm::utostr(G.getValue());
2210 std::string Opt = std::string("-hexagon-small-data-threshold=") + N;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002211 CmdArgs.push_back("-mllvm");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002212 CmdArgs.push_back(Args.MakeArgString(Opt));
Tony Linthicum76329bf2011-12-12 21:14:55 +00002213 }
2214
Sirish Pande11ebc4e2012-05-10 20:19:54 +00002215 if (!Args.hasArg(options::OPT_fno_short_enums))
2216 CmdArgs.push_back("-fshort-enums");
2217 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002218 CmdArgs.push_back("-mllvm");
2219 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00002220 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002221 CmdArgs.push_back("-mllvm");
2222 CmdArgs.push_back("-machine-sink-split=0");
Tony Linthicum76329bf2011-12-12 21:14:55 +00002223}
2224
Jacques Pienaard964cc22016-03-28 21:02:54 +00002225void Clang::AddLanaiTargetArgs(const ArgList &Args,
2226 ArgStringList &CmdArgs) const {
2227 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2228 StringRef CPUName = A->getValue();
2229
2230 CmdArgs.push_back("-target-cpu");
2231 CmdArgs.push_back(Args.MakeArgString(CPUName));
2232 }
2233 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2234 StringRef Value = A->getValue();
2235 // Only support mregparm=4 to support old usage. Report error for all other
2236 // cases.
2237 int Mregparm;
2238 if (Value.getAsInteger(10, Mregparm)) {
2239 if (Mregparm != 4) {
2240 getToolChain().getDriver().Diag(
2241 diag::err_drv_unsupported_option_argument)
2242 << A->getOption().getName() << Value;
2243 }
2244 }
2245 }
2246}
2247
Dan Gohmane3d71e12016-01-07 01:00:21 +00002248void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
2249 ArgStringList &CmdArgs) const {
2250 // Default to "hidden" visibility.
2251 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2252 options::OPT_fvisibility_ms_compat)) {
2253 CmdArgs.push_back("-fvisibility");
2254 CmdArgs.push_back("hidden");
2255 }
2256}
2257
Kevin Qin110db6f2014-07-18 07:03:22 +00002258// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00002259static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00002260 std::vector<const char *> &Features) {
2261 SmallVector<StringRef, 8> Split;
2262 text.split(Split, StringRef("+"), -1, false);
2263
Benjamin Kramer72e64312015-09-24 14:48:49 +00002264 for (StringRef Feature : Split) {
Renato Golin3b8709c2016-05-25 12:36:31 +00002265 const char *result = llvm::StringSwitch<const char *>(Feature)
2266 .Case("fp", "+fp-armv8")
2267 .Case("simd", "+neon")
2268 .Case("crc", "+crc")
2269 .Case("crypto", "+crypto")
2270 .Case("fp16", "+fullfp16")
2271 .Case("profile", "+spe")
2272 .Case("nofp", "-fp-armv8")
2273 .Case("nosimd", "-neon")
2274 .Case("nocrc", "-crc")
2275 .Case("nocrypto", "-crypto")
2276 .Case("nofp16", "-fullfp16")
2277 .Case("noprofile", "-spe")
2278 .Default(nullptr);
2279 if (result)
2280 Features.push_back(result);
Douglas Katzman2675d012015-06-29 19:12:56 +00002281 else if (Feature == "neon" || Feature == "noneon")
Kevin Qin110db6f2014-07-18 07:03:22 +00002282 D.Diag(diag::err_drv_no_neon_modifier);
2283 else
2284 return false;
2285 }
2286 return true;
2287}
2288
2289// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
2290// decode CPU and feature.
2291static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
2292 std::vector<const char *> &Features) {
2293 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
2294 CPU = Split.first;
Renato Golin3b8709c2016-05-25 12:36:31 +00002295 if (CPU == "cortex-a53" || CPU == "cortex-a57" ||
2296 CPU == "cortex-a72" || CPU == "cortex-a35" || CPU == "exynos-m1" ||
2297 CPU == "kryo") {
2298 Features.push_back("+neon");
2299 Features.push_back("+crc");
2300 Features.push_back("+crypto");
2301 } else if (CPU == "cyclone") {
2302 Features.push_back("+neon");
2303 Features.push_back("+crypto");
2304 } else if (CPU == "generic") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002305 Features.push_back("+neon");
2306 } else {
Renato Golin3b8709c2016-05-25 12:36:31 +00002307 return false;
2308 }
Kevin Qin110db6f2014-07-18 07:03:22 +00002309
2310 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
2311 return false;
2312
2313 return true;
2314}
2315
2316static bool
2317getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
2318 const ArgList &Args,
2319 std::vector<const char *> &Features) {
Gabor Ballabas36451492015-06-18 14:23:12 +00002320 std::string MarchLowerCase = March.lower();
2321 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002322
Renato Golin3b8709c2016-05-25 12:36:31 +00002323 if (Split.first == "armv8-a" || Split.first == "armv8a") {
2324 // ok, no additional features.
2325 } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") {
2326 Features.push_back("+v8.1a");
2327 } else if (Split.first == "armv8.2-a" || Split.first == "armv8.2a" ) {
2328 Features.push_back("+v8.2a");
2329 } else {
2330 return false;
2331 }
2332
2333 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00002334 return false;
2335
2336 return true;
2337}
2338
2339static bool
2340getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2341 const ArgList &Args,
2342 std::vector<const char *> &Features) {
2343 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002344 std::string McpuLowerCase = Mcpu.lower();
2345 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00002346 return false;
2347
2348 return true;
2349}
2350
2351static bool
2352getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
2353 const ArgList &Args,
2354 std::vector<const char *> &Features) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002355 std::string MtuneLowerCase = Mtune.lower();
Kevin Qin110db6f2014-07-18 07:03:22 +00002356 // Handle CPU name is 'native'.
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002357 if (MtuneLowerCase == "native")
2358 MtuneLowerCase = llvm::sys::getHostCPUName();
2359 if (MtuneLowerCase == "cyclone") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002360 Features.push_back("+zcm");
2361 Features.push_back("+zcz");
2362 }
2363 return true;
2364}
2365
2366static bool
2367getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2368 const ArgList &Args,
2369 std::vector<const char *> &Features) {
2370 StringRef CPU;
2371 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002372 std::string McpuLowerCase = Mcpu.lower();
2373 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00002374 return false;
2375
2376 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
2377}
2378
Justin Bognerf9052562015-11-13 23:07:31 +00002379static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002380 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00002381 Arg *A;
2382 bool success = true;
2383 // Enable NEON by default.
2384 Features.push_back("+neon");
2385 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2386 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
2387 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2388 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002389 else if (Args.hasArg(options::OPT_arch))
2390 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
2391 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002392
2393 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2394 success =
2395 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
2396 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2397 success =
2398 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002399 else if (Args.hasArg(options::OPT_arch))
2400 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
2401 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002402
2403 if (!success)
2404 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00002405
2406 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2407 Features.push_back("-fp-armv8");
2408 Features.push_back("-crypto");
2409 Features.push_back("-neon");
2410 }
Bradley Smith418c5932014-05-02 15:17:51 +00002411
2412 // En/disable crc
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002413 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bradley Smith418c5932014-05-02 15:17:51 +00002414 if (A->getOption().matches(options::OPT_mcrc))
2415 Features.push_back("+crc");
2416 else
2417 Features.push_back("-crc");
2418 }
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002419
Akira Hatanaka085da7e2015-07-29 14:25:58 +00002420 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2421 options::OPT_munaligned_access))
2422 if (A->getOption().matches(options::OPT_mno_unaligned_access))
2423 Features.push_back("+strict-align");
2424
Justin Bognerf9052562015-11-13 23:07:31 +00002425 if (Args.hasArg(options::OPT_ffixed_x18))
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002426 Features.push_back("+reserve-x18");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002427}
2428
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002429static void getHexagonTargetFeatures(const ArgList &Args,
2430 std::vector<const char *> &Features) {
2431 bool HasHVX = false, HasHVXD = false;
2432
Eric Christopher49062a52015-12-22 03:12:34 +00002433 // FIXME: This should be able to use handleTargetFeaturesGroup except it is
2434 // doing dependent option handling here rather than in initFeatureMap or a
2435 // similar handler.
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002436 for (auto &A : Args) {
2437 auto &Opt = A->getOption();
2438 if (Opt.matches(options::OPT_mhexagon_hvx))
2439 HasHVX = true;
2440 else if (Opt.matches(options::OPT_mno_hexagon_hvx))
2441 HasHVXD = HasHVX = false;
2442 else if (Opt.matches(options::OPT_mhexagon_hvx_double))
2443 HasHVXD = HasHVX = true;
2444 else if (Opt.matches(options::OPT_mno_hexagon_hvx_double))
2445 HasHVXD = false;
2446 else
2447 continue;
2448 A->claim();
2449 }
2450
2451 Features.push_back(HasHVX ? "+hvx" : "-hvx");
2452 Features.push_back(HasHVXD ? "+hvx-double" : "-hvx-double");
2453}
2454
Dan Gohmanc2853072015-09-03 22:51:53 +00002455static void getWebAssemblyTargetFeatures(const ArgList &Args,
2456 std::vector<const char *> &Features) {
Eric Christopher49062a52015-12-22 03:12:34 +00002457 handleTargetFeaturesGroup(Args, Features, options::OPT_m_wasm_Features_Group);
Dan Gohmanc2853072015-09-03 22:51:53 +00002458}
2459
Konstantin Zhuravlyov5124bf82016-04-12 21:42:15 +00002460static void getAMDGPUTargetFeatures(const Driver &D, const ArgList &Args,
2461 std::vector<const char *> &Features) {
2462 if (const Arg *dAbi = Args.getLastArg(options::OPT_mamdgpu_debugger_abi)) {
2463 StringRef value = dAbi->getValue();
2464 if (value == "1.0") {
2465 Features.push_back("+amdgpu-debugger-insert-nops");
2466 Features.push_back("+amdgpu-debugger-reserve-trap-regs");
2467 } else {
2468 D.Diag(diag::err_drv_clang_unsupported) << dAbi->getAsString(Args);
2469 }
2470 }
2471
2472 handleTargetFeaturesGroup(
2473 Args, Features, options::OPT_m_amdgpu_Features_Group);
2474}
2475
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002476static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002477 const ArgList &Args, ArgStringList &CmdArgs,
2478 bool ForAS) {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002479 const Driver &D = TC.getDriver();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002480 std::vector<const char *> Features;
2481 switch (Triple.getArch()) {
2482 default:
2483 break;
2484 case llvm::Triple::mips:
2485 case llvm::Triple::mipsel:
2486 case llvm::Triple::mips64:
2487 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00002488 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002489 break;
2490
2491 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002492 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002493 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002494 case llvm::Triple::thumbeb:
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002495 getARMTargetFeatures(TC, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002496 break;
2497
2498 case llvm::Triple::ppc:
2499 case llvm::Triple::ppc64:
2500 case llvm::Triple::ppc64le:
Petar Jovanovic88a328f2015-12-14 17:51:50 +00002501 getPPCTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002502 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00002503 case llvm::Triple::systemz:
2504 getSystemZTargetFeatures(Args, Features);
2505 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002506 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00002507 case llvm::Triple::aarch64_be:
Justin Bognerf9052562015-11-13 23:07:31 +00002508 getAArch64TargetFeatures(D, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002509 break;
2510 case llvm::Triple::x86:
2511 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002512 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002513 break;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00002514 case llvm::Triple::hexagon:
2515 getHexagonTargetFeatures(Args, Features);
2516 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00002517 case llvm::Triple::wasm32:
2518 case llvm::Triple::wasm64:
2519 getWebAssemblyTargetFeatures(Args, Features);
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00002520 break;
2521 case llvm::Triple::sparc:
2522 case llvm::Triple::sparcel:
2523 case llvm::Triple::sparcv9:
2524 getSparcTargetFeatures(D, Args, Features);
Dan Gohmanc2853072015-09-03 22:51:53 +00002525 break;
Konstantin Zhuravlyov5124bf82016-04-12 21:42:15 +00002526 case llvm::Triple::r600:
2527 case llvm::Triple::amdgcn:
2528 getAMDGPUTargetFeatures(D, Args, Features);
2529 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002530 }
Rafael Espindola43964802013-08-21 17:34:32 +00002531
2532 // Find the last of each feature.
2533 llvm::StringMap<unsigned> LastOpt;
2534 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2535 const char *Name = Features[I];
2536 assert(Name[0] == '-' || Name[0] == '+');
2537 LastOpt[Name + 1] = I;
2538 }
2539
2540 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2541 // If this feature was overridden, ignore it.
2542 const char *Name = Features[I];
2543 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2544 assert(LastI != LastOpt.end());
2545 unsigned Last = LastI->second;
2546 if (Last != I)
2547 continue;
2548
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002549 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002550 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002551 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002552}
2553
David Majnemerae394812014-12-09 00:12:30 +00002554static bool
2555shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2556 const llvm::Triple &Triple) {
2557 // We use the zero-cost exception tables for Objective-C if the non-fragile
2558 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2559 // later.
2560 if (runtime.isNonFragile())
2561 return true;
2562
2563 if (!Triple.isMacOSX())
2564 return false;
2565
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002566 return (!Triple.isMacOSXVersionLT(10, 5) &&
David Majnemerae394812014-12-09 00:12:30 +00002567 (Triple.getArch() == llvm::Triple::x86_64 ||
2568 Triple.getArch() == llvm::Triple::arm));
2569}
2570
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002571/// Adds exception related arguments to the driver command arguments. There's a
2572/// master flag, -fexceptions and also language specific flags to enable/disable
2573/// C++ and Objective-C exceptions. This makes it possible to for example
2574/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002575static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002576 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002577 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002578 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002579 const Driver &D = TC.getDriver();
2580 const llvm::Triple &Triple = TC.getTriple();
2581
Chad Rosier4fab82c2012-03-26 22:04:46 +00002582 if (KernelOrKext) {
2583 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2584 // arguments now to avoid warnings about unused arguments.
2585 Args.ClaimAllArgs(options::OPT_fexceptions);
2586 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2587 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2588 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2589 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2590 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002591 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002592 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002593
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002594 // See if the user explicitly enabled exceptions.
2595 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2596 false);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002597
David Majnemerae394812014-12-09 00:12:30 +00002598 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2599 // is not necessarily sensible, but follows GCC.
2600 if (types::isObjC(InputType) &&
2601 Args.hasFlag(options::OPT_fobjc_exceptions,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002602 options::OPT_fno_objc_exceptions, true)) {
David Majnemerae394812014-12-09 00:12:30 +00002603 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002604
David Majnemerae394812014-12-09 00:12:30 +00002605 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002606 }
2607
2608 if (types::isCXX(InputType)) {
David Majnemer59729392016-02-18 08:15:05 +00002609 // Disable C++ EH by default on XCore and PS4.
2610 bool CXXExceptionsEnabled =
2611 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002612 Arg *ExceptionArg = Args.getLastArg(
2613 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2614 options::OPT_fexceptions, options::OPT_fno_exceptions);
2615 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002616 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002617 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2618 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002619
2620 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002621 if (Triple.isPS4CPU()) {
2622 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2623 assert(ExceptionArg &&
2624 "On the PS4 exceptions should only be enabled if passing "
2625 "an argument");
2626 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2627 const Arg *RTTIArg = TC.getRTTIArg();
2628 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2629 D.Diag(diag::err_drv_argument_not_allowed_with)
2630 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2631 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2632 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2633 } else
2634 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2635
Anders Carlssone96ab552011-02-28 02:27:16 +00002636 CmdArgs.push_back("-fcxx-exceptions");
2637
David Majnemer8de68642014-12-05 08:11:58 +00002638 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002639 }
2640 }
2641
David Majnemer8de68642014-12-05 08:11:58 +00002642 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002643 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002644}
2645
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002646static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) {
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002647 bool Default = true;
2648 if (TC.getTriple().isOSDarwin()) {
2649 // The native darwin assembler doesn't support the linker_option directives,
2650 // so we disable them if we think the .s file will be passed to it.
2651 Default = TC.useIntegratedAs();
2652 }
2653 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2654 Default);
2655}
2656
Ted Kremenek62093662013-03-12 17:02:12 +00002657static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2658 const ToolChain &TC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002659 bool UseDwarfDirectory =
2660 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2661 options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002662 return !UseDwarfDirectory;
2663}
2664
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002665/// \brief Check whether the given input tree contains any compilation actions.
2666static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002667 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002668 return true;
2669
Nico Weber5a459f82016-02-23 19:30:43 +00002670 for (const auto &AI : A->inputs())
2671 if (ContainsCompileAction(AI))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002672 return true;
2673
2674 return false;
2675}
2676
2677/// \brief Check if -relax-all should be passed to the internal assembler.
2678/// This is done by default when compiling non-assembler source with -O0.
2679static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2680 bool RelaxDefault = true;
2681
2682 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2683 RelaxDefault = A->getOption().matches(options::OPT_O0);
2684
2685 if (RelaxDefault) {
2686 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002687 for (const auto &Act : C.getActions()) {
2688 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002689 RelaxDefault = true;
2690 break;
2691 }
2692 }
2693 }
2694
2695 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002696 RelaxDefault);
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002697}
2698
Paul Robinson0334a042015-12-19 19:41:48 +00002699// Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases
2700// to the corresponding DebugInfoKind.
Benjamin Kramer8c305922016-02-02 11:06:51 +00002701static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A) {
Paul Robinson0334a042015-12-19 19:41:48 +00002702 assert(A.getOption().matches(options::OPT_gN_Group) &&
2703 "Not a -g option that specifies a debug-info level");
2704 if (A.getOption().matches(options::OPT_g0) ||
2705 A.getOption().matches(options::OPT_ggdb0))
Benjamin Kramer8c305922016-02-02 11:06:51 +00002706 return codegenoptions::NoDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00002707 if (A.getOption().matches(options::OPT_gline_tables_only) ||
2708 A.getOption().matches(options::OPT_ggdb1))
Benjamin Kramer8c305922016-02-02 11:06:51 +00002709 return codegenoptions::DebugLineTablesOnly;
2710 return codegenoptions::LimitedDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00002711}
2712
Douglas Katzman3459ce22015-10-08 04:24:12 +00002713// Extract the integer N from a string spelled "-dwarf-N", returning 0
2714// on mismatch. The StringRef input (rather than an Arg) allows
2715// for use by the "-Xassembler" option parser.
2716static unsigned DwarfVersionNum(StringRef ArgValue) {
2717 return llvm::StringSwitch<unsigned>(ArgValue)
2718 .Case("-gdwarf-2", 2)
2719 .Case("-gdwarf-3", 3)
2720 .Case("-gdwarf-4", 4)
Eric Christopher3cb592d2015-12-28 19:58:44 +00002721 .Case("-gdwarf-5", 5)
Douglas Katzman3459ce22015-10-08 04:24:12 +00002722 .Default(0);
2723}
2724
2725static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
Benjamin Kramer8c305922016-02-02 11:06:51 +00002726 codegenoptions::DebugInfoKind DebugInfoKind,
Paul Robinson0334a042015-12-19 19:41:48 +00002727 unsigned DwarfVersion,
2728 llvm::DebuggerKind DebuggerTuning) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00002729 switch (DebugInfoKind) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002730 case codegenoptions::DebugLineTablesOnly:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002731 CmdArgs.push_back("-debug-info-kind=line-tables-only");
2732 break;
Benjamin Kramer8c305922016-02-02 11:06:51 +00002733 case codegenoptions::LimitedDebugInfo:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002734 CmdArgs.push_back("-debug-info-kind=limited");
2735 break;
Benjamin Kramer8c305922016-02-02 11:06:51 +00002736 case codegenoptions::FullDebugInfo:
Douglas Katzman3459ce22015-10-08 04:24:12 +00002737 CmdArgs.push_back("-debug-info-kind=standalone");
2738 break;
2739 default:
2740 break;
2741 }
2742 if (DwarfVersion > 0)
2743 CmdArgs.push_back(
Benjamin Kramer32bd3c82015-10-08 10:31:17 +00002744 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
Paul Robinson0334a042015-12-19 19:41:48 +00002745 switch (DebuggerTuning) {
2746 case llvm::DebuggerKind::GDB:
2747 CmdArgs.push_back("-debugger-tuning=gdb");
2748 break;
2749 case llvm::DebuggerKind::LLDB:
2750 CmdArgs.push_back("-debugger-tuning=lldb");
2751 break;
2752 case llvm::DebuggerKind::SCE:
2753 CmdArgs.push_back("-debugger-tuning=sce");
2754 break;
2755 default:
2756 break;
2757 }
Douglas Katzman3459ce22015-10-08 04:24:12 +00002758}
2759
David Blaikie9260ed62013-07-25 21:19:01 +00002760static void CollectArgsForIntegratedAssembler(Compilation &C,
2761 const ArgList &Args,
2762 ArgStringList &CmdArgs,
2763 const Driver &D) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002764 if (UseRelaxAll(C, Args))
2765 CmdArgs.push_back("-mrelax-all");
David Blaikie9260ed62013-07-25 21:19:01 +00002766
David Majnemer2b9349d2015-12-21 22:09:34 +00002767 // Only default to -mincremental-linker-compatible if we think we are
2768 // targeting the MSVC linker.
2769 bool DefaultIncrementalLinkerCompatible =
2770 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2771 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2772 options::OPT_mno_incremental_linker_compatible,
2773 DefaultIncrementalLinkerCompatible))
2774 CmdArgs.push_back("-mincremental-linker-compatible");
2775
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002776 // When passing -I arguments to the assembler we sometimes need to
2777 // unconditionally take the next argument. For example, when parsing
2778 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2779 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2780 // arg after parsing the '-I' arg.
2781 bool TakeNextArg = false;
David Peixottodfb66142013-11-14 22:52:58 +00002782
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002783 // When using an integrated assembler, translate -Wa, and -Xassembler
2784 // options.
2785 bool CompressDebugSections = false;
Scott Egertonb67d4692016-01-14 13:01:48 +00002786 const char *MipsTargetFeature = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002787 for (const Arg *A :
2788 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2789 A->claim();
David Blaikie9260ed62013-07-25 21:19:01 +00002790
Benjamin Kramer72e64312015-09-24 14:48:49 +00002791 for (StringRef Value : A->getValues()) {
Renato Golin7c542b42015-07-27 23:44:45 +00002792 if (TakeNextArg) {
2793 CmdArgs.push_back(Value.data());
2794 TakeNextArg = false;
2795 continue;
2796 }
David Blaikie9260ed62013-07-25 21:19:01 +00002797
Daniel Sanders3d5e5682015-10-27 18:04:42 +00002798 switch (C.getDefaultToolChain().getArch()) {
2799 default:
2800 break;
2801 case llvm::Triple::mips:
2802 case llvm::Triple::mipsel:
2803 case llvm::Triple::mips64:
2804 case llvm::Triple::mips64el:
2805 if (Value == "--trap") {
2806 CmdArgs.push_back("-target-feature");
2807 CmdArgs.push_back("+use-tcc-in-div");
2808 continue;
2809 }
2810 if (Value == "--break") {
2811 CmdArgs.push_back("-target-feature");
2812 CmdArgs.push_back("-use-tcc-in-div");
2813 continue;
2814 }
2815 if (Value.startswith("-msoft-float")) {
2816 CmdArgs.push_back("-target-feature");
2817 CmdArgs.push_back("+soft-float");
2818 continue;
2819 }
2820 if (Value.startswith("-mhard-float")) {
2821 CmdArgs.push_back("-target-feature");
2822 CmdArgs.push_back("-soft-float");
2823 continue;
2824 }
Scott Egertonb67d4692016-01-14 13:01:48 +00002825
2826 MipsTargetFeature = llvm::StringSwitch<const char *>(Value)
2827 .Case("-mips1", "+mips1")
2828 .Case("-mips2", "+mips2")
2829 .Case("-mips3", "+mips3")
2830 .Case("-mips4", "+mips4")
2831 .Case("-mips5", "+mips5")
2832 .Case("-mips32", "+mips32")
2833 .Case("-mips32r2", "+mips32r2")
2834 .Case("-mips32r3", "+mips32r3")
2835 .Case("-mips32r5", "+mips32r5")
2836 .Case("-mips32r6", "+mips32r6")
2837 .Case("-mips64", "+mips64")
2838 .Case("-mips64r2", "+mips64r2")
2839 .Case("-mips64r3", "+mips64r3")
2840 .Case("-mips64r5", "+mips64r5")
2841 .Case("-mips64r6", "+mips64r6")
2842 .Default(nullptr);
2843 if (MipsTargetFeature)
2844 continue;
Daniel Sanders3d5e5682015-10-27 18:04:42 +00002845 }
2846
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002847 if (Value == "-force_cpusubtype_ALL") {
2848 // Do nothing, this is the default and we don't support anything else.
2849 } else if (Value == "-L") {
2850 CmdArgs.push_back("-msave-temp-labels");
2851 } else if (Value == "--fatal-warnings") {
2852 CmdArgs.push_back("-massembler-fatal-warnings");
2853 } else if (Value == "--noexecstack") {
2854 CmdArgs.push_back("-mnoexecstack");
2855 } else if (Value == "-compress-debug-sections" ||
2856 Value == "--compress-debug-sections") {
2857 CompressDebugSections = true;
2858 } else if (Value == "-nocompress-debug-sections" ||
2859 Value == "--nocompress-debug-sections") {
2860 CompressDebugSections = false;
2861 } else if (Value.startswith("-I")) {
2862 CmdArgs.push_back(Value.data());
2863 // We need to consume the next argument if the current arg is a plain
2864 // -I. The next arg will be the include directory.
2865 if (Value == "-I")
2866 TakeNextArg = true;
2867 } else if (Value.startswith("-gdwarf-")) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00002868 // "-gdwarf-N" options are not cc1as options.
2869 unsigned DwarfVersion = DwarfVersionNum(Value);
2870 if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.
2871 CmdArgs.push_back(Value.data());
2872 } else {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002873 RenderDebugEnablingArgs(Args, CmdArgs,
2874 codegenoptions::LimitedDebugInfo,
2875 DwarfVersion, llvm::DebuggerKind::Default);
Douglas Katzman3459ce22015-10-08 04:24:12 +00002876 }
Renato Golin7c542b42015-07-27 23:44:45 +00002877 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
2878 Value.startswith("-mhwdiv") || Value.startswith("-march")) {
2879 // Do nothing, we'll validate it later.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002880 } else {
2881 D.Diag(diag::err_drv_unsupported_option_argument)
David Blaikie9260ed62013-07-25 21:19:01 +00002882 << A->getOption().getName() << Value;
David Blaikie9260ed62013-07-25 21:19:01 +00002883 }
2884 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002885 }
2886 if (CompressDebugSections) {
2887 if (llvm::zlib::isAvailable())
2888 CmdArgs.push_back("-compress-debug-sections");
2889 else
2890 D.Diag(diag::warn_debug_compression_unavailable);
2891 }
Scott Egertonb67d4692016-01-14 13:01:48 +00002892 if (MipsTargetFeature != nullptr) {
2893 CmdArgs.push_back("-target-feature");
2894 CmdArgs.push_back(MipsTargetFeature);
2895 }
David Blaikie9260ed62013-07-25 21:19:01 +00002896}
2897
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002898// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002899// FIXME: Make sure we can also emit shared objects if they're requested
2900// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002901static void addClangRT(const ToolChain &TC, const ArgList &Args,
2902 ArgStringList &CmdArgs) {
Xinliang David Li69306c02015-10-22 06:15:31 +00002903 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins"));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002904}
2905
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002906namespace {
2907enum OpenMPRuntimeKind {
2908 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2909 /// without knowing what runtime to target.
2910 OMPRT_Unknown,
2911
2912 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2913 /// the default for Clang.
2914 OMPRT_OMP,
2915
2916 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2917 /// this runtime but can swallow the pragmas, and find and link against the
2918 /// runtime library itself.
2919 OMPRT_GOMP,
2920
Chandler Carruthc6625c62015-05-28 21:10:31 +00002921 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002922 /// OpenMP runtime. We support this mode for users with existing dependencies
2923 /// on this runtime library name.
2924 OMPRT_IOMP5
2925};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002926}
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002927
2928/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002929static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2930 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002931 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2932
2933 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2934 if (A)
2935 RuntimeName = A->getValue();
2936
2937 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002938 .Case("libomp", OMPRT_OMP)
2939 .Case("libgomp", OMPRT_GOMP)
2940 .Case("libiomp5", OMPRT_IOMP5)
2941 .Default(OMPRT_Unknown);
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002942
2943 if (RT == OMPRT_Unknown) {
2944 if (A)
2945 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002946 << A->getOption().getName() << A->getValue();
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002947 else
2948 // FIXME: We could use a nicer diagnostic here.
2949 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2950 }
2951
2952 return RT;
2953}
2954
Joerg Sonnenberger95a90132015-09-23 14:06:52 +00002955static void addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC,
2956 const ArgList &Args) {
2957 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
2958 options::OPT_fno_openmp, false))
2959 return;
2960
2961 switch (getOpenMPRuntime(TC, Args)) {
2962 case OMPRT_OMP:
2963 CmdArgs.push_back("-lomp");
2964 break;
2965 case OMPRT_GOMP:
2966 CmdArgs.push_back("-lgomp");
2967 break;
2968 case OMPRT_IOMP5:
2969 CmdArgs.push_back("-liomp5");
2970 break;
2971 case OMPRT_Unknown:
2972 // Already diagnosed.
2973 break;
2974 }
2975}
2976
Alexey Samsonov52550342014-09-15 19:58:40 +00002977static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2978 ArgStringList &CmdArgs, StringRef Sanitizer,
Peter Collingbournedc134532016-01-16 00:31:22 +00002979 bool IsShared, bool IsWhole) {
2980 // Wrap any static runtimes that must be forced into executable in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002981 // whole-archive.
Peter Collingbournedc134532016-01-16 00:31:22 +00002982 if (IsWhole) CmdArgs.push_back("-whole-archive");
Xinliang David Li69306c02015-10-22 06:15:31 +00002983 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Sanitizer, IsShared));
Peter Collingbournedc134532016-01-16 00:31:22 +00002984 if (IsWhole) CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002985}
2986
Alexey Samsonov52550342014-09-15 19:58:40 +00002987// Tries to use a file with the list of dynamic symbols that need to be exported
2988// from the runtime library. Returns true if the file was found.
2989static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2990 ArgStringList &CmdArgs,
2991 StringRef Sanitizer) {
Vasileios Kalintiris447e3572015-10-01 16:54:58 +00002992 SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer));
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002993 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2994 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002995 return true;
2996 }
2997 return false;
2998}
2999
3000static void linkSanitizerRuntimeDeps(const ToolChain &TC,
3001 ArgStringList &CmdArgs) {
3002 // Force linking against the system libraries sanitizers depends on
3003 // (see PR15823 why this is necessary).
3004 CmdArgs.push_back("--no-as-needed");
3005 CmdArgs.push_back("-lpthread");
3006 CmdArgs.push_back("-lrt");
3007 CmdArgs.push_back("-lm");
3008 // There's no libdl on FreeBSD.
3009 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
3010 CmdArgs.push_back("-ldl");
3011}
3012
3013static void
3014collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
3015 SmallVectorImpl<StringRef> &SharedRuntimes,
3016 SmallVectorImpl<StringRef> &StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00003017 SmallVectorImpl<StringRef> &NonWholeStaticRuntimes,
3018 SmallVectorImpl<StringRef> &HelperStaticRuntimes,
3019 SmallVectorImpl<StringRef> &RequiredSymbols) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003020 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
3021 // Collect shared runtimes.
3022 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
3023 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00003024 }
Peter Collingbournedc134532016-01-16 00:31:22 +00003025 // The stats_client library is also statically linked into DSOs.
3026 if (SanArgs.needsStatsRt())
3027 StaticRuntimes.push_back("stats_client");
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00003028
Alexey Samsonov52550342014-09-15 19:58:40 +00003029 // Collect static runtimes.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00003030 if (Args.hasArg(options::OPT_shared) || TC.getTriple().isAndroid()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003031 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00003032 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00003033 }
3034 if (SanArgs.needsAsanRt()) {
3035 if (SanArgs.needsSharedAsanRt()) {
3036 HelperStaticRuntimes.push_back("asan-preinit");
3037 } else {
3038 StaticRuntimes.push_back("asan");
3039 if (SanArgs.linkCXXRuntimes())
3040 StaticRuntimes.push_back("asan_cxx");
3041 }
3042 }
3043 if (SanArgs.needsDfsanRt())
3044 StaticRuntimes.push_back("dfsan");
3045 if (SanArgs.needsLsanRt())
3046 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003047 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003048 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003049 if (SanArgs.linkCXXRuntimes())
3050 StaticRuntimes.push_back("msan_cxx");
3051 }
3052 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003053 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00003054 if (SanArgs.linkCXXRuntimes())
3055 StaticRuntimes.push_back("tsan_cxx");
3056 }
Alexey Samsonov52550342014-09-15 19:58:40 +00003057 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00003058 StaticRuntimes.push_back("ubsan_standalone");
3059 if (SanArgs.linkCXXRuntimes())
3060 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00003061 }
Peter Collingbournec4122c12015-06-15 21:08:13 +00003062 if (SanArgs.needsSafeStackRt())
3063 StaticRuntimes.push_back("safestack");
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00003064 if (SanArgs.needsCfiRt())
3065 StaticRuntimes.push_back("cfi");
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00003066 if (SanArgs.needsCfiDiagRt()) {
Evgeniy Stepanove3fb51c2015-12-16 00:38:42 +00003067 StaticRuntimes.push_back("cfi_diag");
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00003068 if (SanArgs.linkCXXRuntimes())
3069 StaticRuntimes.push_back("ubsan_standalone_cxx");
3070 }
Peter Collingbournedc134532016-01-16 00:31:22 +00003071 if (SanArgs.needsStatsRt()) {
3072 NonWholeStaticRuntimes.push_back("stats");
3073 RequiredSymbols.push_back("__sanitizer_stats_register");
3074 }
Derek Bruening256c2e12016-04-21 21:32:04 +00003075 if (SanArgs.needsEsanRt())
3076 StaticRuntimes.push_back("esan");
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00003077}
3078
Alexey Samsonov52550342014-09-15 19:58:40 +00003079// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
3080// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
3081static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00003082 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00003083 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00003084 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
Alexey Samsonov52550342014-09-15 19:58:40 +00003085 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
Peter Collingbournedc134532016-01-16 00:31:22 +00003086 NonWholeStaticRuntimes, HelperStaticRuntimes,
3087 RequiredSymbols);
Alexey Samsonov52550342014-09-15 19:58:40 +00003088 for (auto RT : SharedRuntimes)
Peter Collingbournedc134532016-01-16 00:31:22 +00003089 addSanitizerRuntime(TC, Args, CmdArgs, RT, true, false);
Alexey Samsonov52550342014-09-15 19:58:40 +00003090 for (auto RT : HelperStaticRuntimes)
Peter Collingbournedc134532016-01-16 00:31:22 +00003091 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
Alexey Samsonov52550342014-09-15 19:58:40 +00003092 bool AddExportDynamic = false;
3093 for (auto RT : StaticRuntimes) {
Peter Collingbournedc134532016-01-16 00:31:22 +00003094 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
Alexey Samsonov52550342014-09-15 19:58:40 +00003095 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
3096 }
Peter Collingbournedc134532016-01-16 00:31:22 +00003097 for (auto RT : NonWholeStaticRuntimes) {
3098 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, false);
3099 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
3100 }
3101 for (auto S : RequiredSymbols) {
3102 CmdArgs.push_back("-u");
3103 CmdArgs.push_back(Args.MakeArgString(S));
3104 }
Alexey Samsonov52550342014-09-15 19:58:40 +00003105 // If there is a static runtime with no dynamic list, force all the symbols
3106 // to be dynamic to be sure we export sanitizer interface functions.
3107 if (AddExportDynamic)
3108 CmdArgs.push_back("-export-dynamic");
3109 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00003110}
3111
Reid Kleckner86ea7702015-02-04 23:45:07 +00003112static bool areOptimizationsEnabled(const ArgList &Args) {
3113 // Find the last -O arg and see if it is non-zero.
3114 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
3115 return !A->getOption().matches(options::OPT_O0);
3116 // Defaults to -O0.
3117 return false;
3118}
3119
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003120static bool shouldUseFramePointerForTarget(const ArgList &Args,
3121 const llvm::Triple &Triple) {
Dan Gohmanc2853072015-09-03 22:51:53 +00003122 switch (Triple.getArch()) {
3123 case llvm::Triple::xcore:
3124 case llvm::Triple::wasm32:
3125 case llvm::Triple::wasm64:
3126 // XCore never wants frame pointers, regardless of OS.
3127 // WebAssembly never wants frame pointers.
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003128 return false;
Dan Gohmanc2853072015-09-03 22:51:53 +00003129 default:
3130 break;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003131 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00003132
3133 if (Triple.isOSLinux()) {
3134 switch (Triple.getArch()) {
3135 // Don't use a frame pointer on linux if optimizing for certain targets.
3136 case llvm::Triple::mips64:
3137 case llvm::Triple::mips64el:
3138 case llvm::Triple::mips:
3139 case llvm::Triple::mipsel:
3140 case llvm::Triple::systemz:
3141 case llvm::Triple::x86:
3142 case llvm::Triple::x86_64:
3143 return !areOptimizationsEnabled(Args);
3144 default:
3145 return true;
3146 }
3147 }
3148
3149 if (Triple.isOSWindows()) {
3150 switch (Triple.getArch()) {
3151 case llvm::Triple::x86:
3152 return !areOptimizationsEnabled(Args);
Akira Hatanaka8f5866a2016-02-26 05:07:00 +00003153 case llvm::Triple::x86_64:
3154 return Triple.isOSBinFormatMachO();
Saleem Abdulrasoola8180a22015-10-03 03:39:28 +00003155 case llvm::Triple::arm:
3156 case llvm::Triple::thumb:
3157 // Windows on ARM builds with FPO disabled to aid fast stack walking
3158 return true;
Reid Kleckner86ea7702015-02-04 23:45:07 +00003159 default:
3160 // All other supported Windows ISAs use xdata unwind information, so frame
3161 // pointers are not generally useful.
3162 return false;
3163 }
3164 }
3165
3166 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003167}
3168
Rafael Espindola224dd632011-12-14 21:02:23 +00003169static bool shouldUseFramePointer(const ArgList &Args,
3170 const llvm::Triple &Triple) {
3171 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
3172 options::OPT_fomit_frame_pointer))
3173 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
Xinliang David Li4dff8752015-11-23 17:30:31 +00003174 if (Args.hasArg(options::OPT_pg))
3175 return true;
Rafael Espindola224dd632011-12-14 21:02:23 +00003176
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003177 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00003178}
3179
Eric Christopherb7d97e92013-04-03 01:58:53 +00003180static bool shouldUseLeafFramePointer(const ArgList &Args,
3181 const llvm::Triple &Triple) {
3182 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
3183 options::OPT_momit_leaf_frame_pointer))
3184 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
Xinliang David Li4dff8752015-11-23 17:30:31 +00003185 if (Args.hasArg(options::OPT_pg))
3186 return true;
Eric Christopherb7d97e92013-04-03 01:58:53 +00003187
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00003188 if (Triple.isPS4CPU())
3189 return false;
3190
Benjamin Kramer34cb0432013-10-16 17:42:39 +00003191 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00003192}
3193
Rafael Espindolac7367ff2013-08-10 01:40:10 +00003194/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003195static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00003196 SmallString<128> cwd;
3197 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00003198 CmdArgs.push_back("-fdebug-compilation-dir");
3199 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00003200 }
3201}
3202
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003203static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00003204 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
3205 if (FinalOutput && Args.hasArg(options::OPT_c)) {
3206 SmallString<128> T(FinalOutput->getValue());
3207 llvm::sys::path::replace_extension(T, "dwo");
3208 return Args.MakeArgString(T);
3209 } else {
3210 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00003211 SmallString<128> T(
3212 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00003213 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00003214 llvm::sys::path::replace_extension(F, "dwo");
3215 T += F;
3216 return Args.MakeArgString(F);
3217 }
3218}
3219
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003220static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
3221 const JobAction &JA, const ArgList &Args,
3222 const InputInfo &Output, const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00003223 ArgStringList ExtractArgs;
3224 ExtractArgs.push_back("--extract-dwo");
3225
3226 ArgStringList StripArgs;
3227 StripArgs.push_back("--strip-dwo");
3228
3229 // Grabbing the output of the earlier compile step.
3230 StripArgs.push_back(Output.getFilename());
3231 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00003232 ExtractArgs.push_back(OutFile);
3233
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003234 const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
Justin Lebard98cea82016-01-11 23:15:21 +00003235 InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00003236
3237 // First extract the dwo sections.
Justin Bognerd3371d82015-07-17 03:35:54 +00003238 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00003239
3240 // Then remove them from the original .o file.
Justin Bognerd3371d82015-07-17 03:35:54 +00003241 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00003242}
3243
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003244/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003245/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
3246static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003247 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00003248 if (A->getOption().matches(options::OPT_O4) ||
3249 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003250 return true;
3251
3252 if (A->getOption().matches(options::OPT_O0))
3253 return false;
3254
3255 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
3256
Rafael Espindola91780de2013-08-26 14:05:41 +00003257 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003258 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00003259 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003260 return true;
3261
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003262 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003263 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00003264 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00003265
3266 unsigned OptLevel = 0;
3267 if (S.getAsInteger(10, OptLevel))
3268 return false;
3269
3270 return OptLevel > 1;
3271 }
3272
3273 return false;
3274}
3275
Ben Langmuir2cb4a782014-02-05 22:21:15 +00003276/// Add -x lang to \p CmdArgs for \p Input.
3277static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
3278 ArgStringList &CmdArgs) {
3279 // When using -verify-pch, we don't want to provide the type
3280 // 'precompiled-header' if it was inferred from the file extension
3281 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
3282 return;
3283
3284 CmdArgs.push_back("-x");
3285 if (Args.hasArg(options::OPT_rewrite_objc))
3286 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3287 else
3288 CmdArgs.push_back(types::getTypeName(Input.getType()));
3289}
3290
David Majnemerc371ff02015-03-22 08:39:22 +00003291static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003292 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00003293 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003294
3295 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00003296 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003297
3298 unsigned Build = 0, Factor = 1;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003299 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003300 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00003301 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00003302}
3303
Rafael Espindola577637a2015-01-03 00:06:04 +00003304// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00003305// options that build systems might add but are unused when assembling or only
3306// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00003307static void claimNoWarnArgs(const ArgList &Args) {
3308 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00003309 // preprocessing, precompiling or assembling.
Teresa Johnson945bc502015-10-15 20:35:53 +00003310 Args.ClaimAllArgs(options::OPT_flto_EQ);
Rafael Espindola577637a2015-01-03 00:06:04 +00003311 Args.ClaimAllArgs(options::OPT_flto);
3312 Args.ClaimAllArgs(options::OPT_fno_lto);
3313}
3314
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003315static void appendUserToPath(SmallVectorImpl<char> &Result) {
3316#ifdef LLVM_ON_UNIX
3317 const char *Username = getenv("LOGNAME");
3318#else
3319 const char *Username = getenv("USERNAME");
3320#endif
3321 if (Username) {
3322 // Validate that LoginName can be used in a path, and get its length.
3323 size_t Len = 0;
3324 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00003325 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003326 Username = nullptr;
3327 break;
3328 }
3329 }
3330
3331 if (Username && Len > 0) {
3332 Result.append(Username, Username + Len);
3333 return;
3334 }
3335 }
3336
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003337// Fallback to user id.
Ben Langmuir3b7b5402015-02-03 19:28:37 +00003338#ifdef LLVM_ON_UNIX
3339 std::string UID = llvm::utostr(getuid());
3340#else
3341 // FIXME: Windows seems to have an 'SID' that might work.
3342 std::string UID = "9999";
3343#endif
3344 Result.append(UID.begin(), UID.end());
3345}
3346
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00003347VersionTuple visualstudio::getMSVCVersion(const Driver *D, const ToolChain &TC,
David Majnemere11d3732015-06-08 00:22:46 +00003348 const llvm::Triple &Triple,
3349 const llvm::opt::ArgList &Args,
3350 bool IsWindowsMSVC) {
3351 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3352 IsWindowsMSVC) ||
3353 Args.hasArg(options::OPT_fmsc_version) ||
3354 Args.hasArg(options::OPT_fms_compatibility_version)) {
3355 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3356 const Arg *MSCompatibilityVersion =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003357 Args.getLastArg(options::OPT_fms_compatibility_version);
David Majnemere11d3732015-06-08 00:22:46 +00003358
3359 if (MSCVersion && MSCompatibilityVersion) {
3360 if (D)
3361 D->Diag(diag::err_drv_argument_not_allowed_with)
3362 << MSCVersion->getAsString(Args)
3363 << MSCompatibilityVersion->getAsString(Args);
3364 return VersionTuple();
3365 }
3366
3367 if (MSCompatibilityVersion) {
3368 VersionTuple MSVT;
3369 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
3370 D->Diag(diag::err_drv_invalid_value)
3371 << MSCompatibilityVersion->getAsString(Args)
3372 << MSCompatibilityVersion->getValue();
3373 return MSVT;
3374 }
3375
3376 if (MSCVersion) {
3377 unsigned Version = 0;
3378 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
3379 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
3380 << MSCVersion->getValue();
3381 return getMSCompatibilityVersion(Version);
3382 }
3383
3384 unsigned Major, Minor, Micro;
3385 Triple.getEnvironmentVersion(Major, Minor, Micro);
3386 if (Major || Minor || Micro)
3387 return VersionTuple(Major, Minor, Micro);
3388
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00003389 if (IsWindowsMSVC) {
3390 VersionTuple MSVT = TC.getMSVCVersionFromExe();
3391 if (!MSVT.empty())
3392 return MSVT;
3393
3394 // FIXME: Consider bumping this to 19 (MSVC2015) soon.
3395 return VersionTuple(18);
3396 }
David Majnemere11d3732015-06-08 00:22:46 +00003397 }
3398 return VersionTuple();
3399}
3400
Diego Novilloa0545962015-07-10 18:00:07 +00003401static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
3402 const InputInfo &Output, const ArgList &Args,
3403 ArgStringList &CmdArgs) {
3404 auto *ProfileGenerateArg = Args.getLastArg(
3405 options::OPT_fprofile_instr_generate,
3406 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
Diego Novillo758f3f52015-08-05 21:49:51 +00003407 options::OPT_fprofile_generate_EQ,
3408 options::OPT_fno_profile_instr_generate);
3409 if (ProfileGenerateArg &&
3410 ProfileGenerateArg->getOption().matches(
3411 options::OPT_fno_profile_instr_generate))
3412 ProfileGenerateArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00003413
3414 auto *ProfileUseArg = Args.getLastArg(
3415 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
Diego Novillo758f3f52015-08-05 21:49:51 +00003416 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
3417 options::OPT_fno_profile_instr_use);
3418 if (ProfileUseArg &&
3419 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
3420 ProfileUseArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00003421
3422 if (ProfileGenerateArg && ProfileUseArg)
3423 D.Diag(diag::err_drv_argument_not_allowed_with)
Renato Golin7c542b42015-07-27 23:44:45 +00003424 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
Diego Novilloa0545962015-07-10 18:00:07 +00003425
Diego Novillo758f3f52015-08-05 21:49:51 +00003426 if (ProfileGenerateArg) {
3427 if (ProfileGenerateArg->getOption().matches(
3428 options::OPT_fprofile_instr_generate_EQ))
Rong Xu9837ef52016-02-04 18:39:09 +00003429 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
3430 ProfileGenerateArg->getValue()));
Diego Novillo758f3f52015-08-05 21:49:51 +00003431 else if (ProfileGenerateArg->getOption().matches(
3432 options::OPT_fprofile_generate_EQ)) {
3433 SmallString<128> Path(ProfileGenerateArg->getValue());
3434 llvm::sys::path::append(Path, "default.profraw");
3435 CmdArgs.push_back(
Rong Xu9837ef52016-02-04 18:39:09 +00003436 Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
3437 }
3438 // The default is to use Clang Instrumentation.
3439 CmdArgs.push_back("-fprofile-instrument=clang");
Diego Novillo758f3f52015-08-05 21:49:51 +00003440 }
Diego Novilloa0545962015-07-10 18:00:07 +00003441
Diego Novillo758f3f52015-08-05 21:49:51 +00003442 if (ProfileUseArg) {
3443 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
Rong Xu9c6f1532016-03-02 20:59:36 +00003444 CmdArgs.push_back(Args.MakeArgString(
3445 Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
Diego Novillo758f3f52015-08-05 21:49:51 +00003446 else if ((ProfileUseArg->getOption().matches(
3447 options::OPT_fprofile_use_EQ) ||
3448 ProfileUseArg->getOption().matches(
3449 options::OPT_fprofile_instr_use))) {
3450 SmallString<128> Path(
3451 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
3452 if (Path.empty() || llvm::sys::fs::is_directory(Path))
3453 llvm::sys::path::append(Path, "default.profdata");
3454 CmdArgs.push_back(
Rong Xu9c6f1532016-03-02 20:59:36 +00003455 Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
Diego Novillo758f3f52015-08-05 21:49:51 +00003456 }
Diego Novilloa0545962015-07-10 18:00:07 +00003457 }
3458
3459 if (Args.hasArg(options::OPT_ftest_coverage) ||
3460 Args.hasArg(options::OPT_coverage))
3461 CmdArgs.push_back("-femit-coverage-notes");
3462 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3463 false) ||
3464 Args.hasArg(options::OPT_coverage))
3465 CmdArgs.push_back("-femit-coverage-data");
3466
Diego Novilloc4b94da2015-08-05 23:27:40 +00003467 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3468 options::OPT_fno_coverage_mapping, false) &&
3469 !ProfileGenerateArg)
Diego Novilloa0545962015-07-10 18:00:07 +00003470 D.Diag(diag::err_drv_argument_only_allowed_with)
3471 << "-fcoverage-mapping"
3472 << "-fprofile-instr-generate";
3473
Diego Novilloc4b94da2015-08-05 23:27:40 +00003474 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3475 options::OPT_fno_coverage_mapping, false))
Diego Novilloa0545962015-07-10 18:00:07 +00003476 CmdArgs.push_back("-fcoverage-mapping");
3477
3478 if (C.getArgs().hasArg(options::OPT_c) ||
3479 C.getArgs().hasArg(options::OPT_S)) {
3480 if (Output.isFilename()) {
3481 CmdArgs.push_back("-coverage-file");
3482 SmallString<128> CoverageFilename;
3483 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
3484 CoverageFilename = FinalOutput->getValue();
3485 } else {
3486 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3487 }
3488 if (llvm::sys::path::is_relative(CoverageFilename)) {
3489 SmallString<128> Pwd;
3490 if (!llvm::sys::fs::current_path(Pwd)) {
3491 llvm::sys::path::append(Pwd, CoverageFilename);
3492 CoverageFilename.swap(Pwd);
3493 }
3494 }
3495 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
3496 }
3497 }
3498}
3499
Paul Robinsond083b9a2015-12-16 17:25:27 +00003500static void addPS4ProfileRTArgs(const ToolChain &TC, const ArgList &Args,
3501 ArgStringList &CmdArgs) {
3502 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3503 false) ||
3504 Args.hasFlag(options::OPT_fprofile_generate,
3505 options::OPT_fno_profile_instr_generate, false) ||
3506 Args.hasFlag(options::OPT_fprofile_generate_EQ,
3507 options::OPT_fno_profile_instr_generate, false) ||
3508 Args.hasFlag(options::OPT_fprofile_instr_generate,
3509 options::OPT_fno_profile_instr_generate, false) ||
3510 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
3511 options::OPT_fno_profile_instr_generate, false) ||
3512 Args.hasArg(options::OPT_fcreate_profile) ||
3513 Args.hasArg(options::OPT_coverage)))
3514 CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
3515}
3516
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003517/// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
3518/// smooshes them together with platform defaults, to decide whether
3519/// this compile should be using PIC mode or not. Returns a tuple of
3520/// (RelocationModel, PICLevel, IsPIE).
3521static std::tuple<llvm::Reloc::Model, unsigned, bool>
3522ParsePICArgs(const ToolChain &ToolChain, const llvm::Triple &Triple,
3523 const ArgList &Args) {
3524 // FIXME: why does this code...and so much everywhere else, use both
3525 // ToolChain.getTriple() and Triple?
3526 bool PIE = ToolChain.isPIEDefault();
3527 bool PIC = PIE || ToolChain.isPICDefault();
Bob Wilson0a15e6c2016-01-13 01:19:02 +00003528 // The Darwin/MachO default to use PIC does not apply when using -static.
3529 if (ToolChain.getTriple().isOSBinFormatMachO() &&
3530 Args.hasArg(options::OPT_static))
Bob Wilson2b2a0ae2015-12-18 20:37:54 +00003531 PIE = PIC = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003532 bool IsPICLevelTwo = PIC;
3533
3534 bool KernelOrKext =
3535 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3536
3537 // Android-specific defaults for PIC/PIE
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00003538 if (ToolChain.getTriple().isAndroid()) {
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003539 switch (ToolChain.getArch()) {
3540 case llvm::Triple::arm:
3541 case llvm::Triple::armeb:
3542 case llvm::Triple::thumb:
3543 case llvm::Triple::thumbeb:
3544 case llvm::Triple::aarch64:
3545 case llvm::Triple::mips:
3546 case llvm::Triple::mipsel:
3547 case llvm::Triple::mips64:
3548 case llvm::Triple::mips64el:
3549 PIC = true; // "-fpic"
3550 break;
3551
3552 case llvm::Triple::x86:
3553 case llvm::Triple::x86_64:
3554 PIC = true; // "-fPIC"
3555 IsPICLevelTwo = true;
3556 break;
3557
3558 default:
3559 break;
3560 }
3561 }
3562
3563 // OpenBSD-specific defaults for PIE
3564 if (ToolChain.getTriple().getOS() == llvm::Triple::OpenBSD) {
3565 switch (ToolChain.getArch()) {
3566 case llvm::Triple::mips64:
3567 case llvm::Triple::mips64el:
3568 case llvm::Triple::sparcel:
3569 case llvm::Triple::x86:
3570 case llvm::Triple::x86_64:
3571 IsPICLevelTwo = false; // "-fpie"
3572 break;
3573
3574 case llvm::Triple::ppc:
3575 case llvm::Triple::sparc:
3576 case llvm::Triple::sparcv9:
3577 IsPICLevelTwo = true; // "-fPIE"
3578 break;
3579
3580 default:
3581 break;
3582 }
3583 }
3584
3585 // The last argument relating to either PIC or PIE wins, and no
3586 // other argument is used. If the last argument is any flavor of the
3587 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
3588 // option implicitly enables PIC at the same level.
3589 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3590 options::OPT_fpic, options::OPT_fno_pic,
3591 options::OPT_fPIE, options::OPT_fno_PIE,
3592 options::OPT_fpie, options::OPT_fno_pie);
3593 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3594 // is forced, then neither PIC nor PIE flags will have no effect.
3595 if (!ToolChain.isPICDefaultForced()) {
3596 if (LastPICArg) {
3597 Option O = LastPICArg->getOption();
3598 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3599 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3600 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3601 PIC =
3602 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3603 IsPICLevelTwo =
3604 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3605 } else {
3606 PIE = PIC = false;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003607 if (Triple.isPS4CPU()) {
3608 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
3609 StringRef Model = ModelArg ? ModelArg->getValue() : "";
3610 if (Model != "kernel") {
3611 PIC = true;
3612 ToolChain.getDriver().Diag(diag::warn_drv_ps4_force_pic)
3613 << LastPICArg->getSpelling();
3614 }
3615 }
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003616 }
3617 }
3618 }
3619
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003620 // Introduce a Darwin and PS4-specific hack. If the default is PIC, but the
3621 // PIC level would've been set to level 1, force it back to level 2 PIC
3622 // instead.
3623 if (PIC && (ToolChain.getTriple().isOSDarwin() || Triple.isPS4CPU()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003624 IsPICLevelTwo |= ToolChain.isPICDefault();
3625
James Y Knightc4015d32015-08-21 04:14:55 +00003626 // This kernel flags are a trump-card: they will disable PIC/PIE
3627 // generation, independent of the argument order.
Tim Northover6f3ff222015-10-30 16:30:27 +00003628 if (KernelOrKext && ((!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
3629 !Triple.isWatchOS()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003630 PIC = PIE = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003631
3632 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3633 // This is a very special mode. It trumps the other modes, almost no one
3634 // uses it, and it isn't even valid on any OS but Darwin.
3635 if (!ToolChain.getTriple().isOSDarwin())
3636 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
3637 << A->getSpelling() << ToolChain.getTriple().str();
3638
3639 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3640
3641 // Only a forced PIC mode can cause the actual compile to have PIC defines
3642 // etc., no flags are sufficient. This behavior was selected to closely
3643 // match that of llvm-gcc and Apple GCC before that.
3644 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
3645
3646 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2 : 0, false);
3647 }
3648
3649 if (PIC)
3650 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2 : 1, PIE);
3651
3652 return std::make_tuple(llvm::Reloc::Static, 0, false);
3653}
3654
3655static const char *RelocationModelName(llvm::Reloc::Model Model) {
3656 switch (Model) {
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003657 case llvm::Reloc::Static:
3658 return "static";
3659 case llvm::Reloc::PIC_:
3660 return "pic";
3661 case llvm::Reloc::DynamicNoPIC:
3662 return "dynamic-no-pic";
3663 }
Aaron Ballman2ec49282015-08-20 13:31:16 +00003664 llvm_unreachable("Unknown Reloc::Model kind");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003665}
3666
3667static void AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
3668 ArgStringList &CmdArgs) {
3669 llvm::Reloc::Model RelocationModel;
3670 unsigned PICLevel;
3671 bool IsPIE;
3672 std::tie(RelocationModel, PICLevel, IsPIE) =
3673 ParsePICArgs(ToolChain, ToolChain.getTriple(), Args);
3674
3675 if (RelocationModel != llvm::Reloc::Static)
3676 CmdArgs.push_back("-KPIC");
3677}
3678
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003679void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003680 const InputInfo &Output, const InputInfoList &Inputs,
3681 const ArgList &Args, const char *LinkingOutput) const {
James Y Knight2db38f32015-08-15 03:45:25 +00003682 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3683 const llvm::Triple Triple(TripleStr);
3684
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003685 bool KernelOrKext =
3686 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00003687 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003688 ArgStringList CmdArgs;
3689
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003690 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00003691 bool IsWindowsCygnus =
3692 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003693 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003694 bool IsPS4CPU = getToolChain().getTriple().isPS4CPU();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003695
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003696 // Check number of inputs for sanity. We need at least one input.
3697 assert(Inputs.size() >= 1 && "Must have at least one input.");
Artem Belevichba558952015-05-06 18:20:23 +00003698 const InputInfo &Input = Inputs[0];
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003699 // CUDA compilation may have multiple inputs (source file + results of
3700 // device-side compilations). All other jobs are expected to have exactly one
3701 // input.
3702 bool IsCuda = types::isCuda(Input.getType());
3703 assert((IsCuda || Inputs.size() == 1) && "Unable to handle multiple inputs.");
Daniel Dunbare521a892009-03-31 20:53:55 +00003704
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003705 // Invoke ourselves in -cc1 mode.
3706 //
3707 // FIXME: Implement custom jobs for internal actions.
3708 CmdArgs.push_back("-cc1");
3709
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003710 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00003711 CmdArgs.push_back("-triple");
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003712 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00003713
Artem Belevichfa11ab52015-11-17 22:28:46 +00003714 const ToolChain *AuxToolChain = nullptr;
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00003715 if (IsCuda) {
3716 // FIXME: We need a (better) way to pass information about
3717 // particular compilation pass we're constructing here. For now we
3718 // can check which toolchain we're using and pick the other one to
3719 // extract the triple.
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00003720 if (&getToolChain() == C.getCudaDeviceToolChain())
3721 AuxToolChain = C.getCudaHostToolChain();
3722 else if (&getToolChain() == C.getCudaHostToolChain())
3723 AuxToolChain = C.getCudaDeviceToolChain();
3724 else
3725 llvm_unreachable("Can't figure out CUDA compilation mode.");
3726 assert(AuxToolChain != nullptr && "No aux toolchain.");
3727 CmdArgs.push_back("-aux-triple");
3728 CmdArgs.push_back(Args.MakeArgString(AuxToolChain->getTriple().str()));
3729 }
3730
James Y Knight2db38f32015-08-15 03:45:25 +00003731 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3732 Triple.getArch() == llvm::Triple::thumb)) {
3733 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003734 unsigned Version;
James Y Knight2db38f32015-08-15 03:45:25 +00003735 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003736 if (Version < 7)
James Y Knight2db38f32015-08-15 03:45:25 +00003737 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
Nico Webere8e53112014-05-11 01:04:02 +00003738 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003739 }
3740
Tim Northover336f1892014-03-29 13:16:12 +00003741 // Push all default warning arguments that are specific to
3742 // the given target. These come before user provided warning options
3743 // are provided.
3744 getToolChain().addClangWarningOptions(CmdArgs);
3745
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003746 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00003747 RewriteKind rewriteKind = RK_None;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003748
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003749 if (isa<AnalyzeJobAction>(JA)) {
3750 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
3751 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003752 } else if (isa<MigrateJobAction>(JA)) {
3753 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003754 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003755 if (Output.getType() == types::TY_Dependencies)
3756 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003757 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003758 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003759 if (Args.hasArg(options::OPT_rewrite_objc) &&
3760 !Args.hasArg(options::OPT_g_Group))
3761 CmdArgs.push_back("-P");
3762 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00003763 } else if (isa<AssembleJobAction>(JA)) {
3764 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003765
David Blaikie9260ed62013-07-25 21:19:01 +00003766 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00003767
3768 // Also ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003769 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003770 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00003771 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003772 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003773
Aaron Ballman1f10cc52012-07-31 01:21:00 +00003774 if (JA.getType() == types::TY_Nothing)
3775 CmdArgs.push_back("-fsyntax-only");
3776 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00003777 CmdArgs.push_back("-emit-pch");
3778 else
3779 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003780 } else if (isa<VerifyPCHJobAction>(JA)) {
3781 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003782 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00003783 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3784 "Invalid action for clang tool.");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003785 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003786 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003787 } else if (JA.getType() == types::TY_LLVM_IR ||
3788 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003789 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003790 } else if (JA.getType() == types::TY_LLVM_BC ||
3791 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003792 CmdArgs.push_back("-emit-llvm-bc");
3793 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00003794 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003795 } else if (JA.getType() == types::TY_AST) {
3796 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00003797 } else if (JA.getType() == types::TY_ModuleFile) {
3798 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003799 } else if (JA.getType() == types::TY_RewrittenObjC) {
3800 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003801 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00003802 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
3803 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003804 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003805 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003806 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003807 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00003808
3809 // Preserve use-list order by default when emitting bitcode, so that
3810 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
3811 // same result as running passes here. For LTO, we don't need to preserve
3812 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00003813 if (JA.getType() == types::TY_LLVM_BC)
3814 CmdArgs.push_back("-emit-llvm-uselists");
Teresa Johnson945bc502015-10-15 20:35:53 +00003815
3816 if (D.isUsingLTO())
3817 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003818 }
3819
Teresa Johnsonaff22322015-12-07 19:21:34 +00003820 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3821 if (!types::isLLVMIR(Input.getType()))
3822 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3823 << "-x ir";
3824 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3825 }
3826
Steven Wu574b0f22016-03-01 01:07:58 +00003827 // Embed-bitcode option.
3828 if (C.getDriver().embedBitcodeEnabled() &&
3829 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
3830 // Add flags implied by -fembed-bitcode.
Steven Wu27fb5222016-05-11 16:26:03 +00003831 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
Steven Wu574b0f22016-03-01 01:07:58 +00003832 // Disable all llvm IR level optimizations.
3833 CmdArgs.push_back("-disable-llvm-optzns");
3834 }
3835 if (C.getDriver().embedBitcodeMarkerOnly())
Steven Wu27fb5222016-05-11 16:26:03 +00003836 CmdArgs.push_back("-fembed-bitcode=marker");
Steven Wu574b0f22016-03-01 01:07:58 +00003837
Justin Bognera88f0122014-06-20 22:59:50 +00003838 // We normally speed up the clang process a bit by skipping destructors at
3839 // exit, but when we're generating diagnostics we can rely on some of the
3840 // cleanup.
3841 if (!C.isForDiagnostics())
3842 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003843
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003844// Disable the verification pass in -asserts builds.
John McCallbb79b5f2010-02-13 03:50:24 +00003845#ifdef NDEBUG
3846 CmdArgs.push_back("-disable-llvm-verifier");
Mehdi Amini557c20a2016-03-13 21:05:23 +00003847 // Discard LLVM value names in -asserts builds.
3848 CmdArgs.push_back("-discard-value-names");
John McCallbb79b5f2010-02-13 03:50:24 +00003849#endif
3850
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003851 // Set the main file name, so that debug info works even with
3852 // -save-temps.
3853 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00003854 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003855
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003856 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00003857 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003858 if (Args.hasArg(options::OPT_static))
3859 CmdArgs.push_back("-static-define");
3860
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003861 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00003862 // Enable region store model by default.
3863 CmdArgs.push_back("-analyzer-store=region");
3864
Ted Kremenek7bea9a12009-12-07 22:26:14 +00003865 // Treat blocks as analysis entry points.
3866 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
3867
Ted Kremenek49c79792011-03-24 00:28:47 +00003868 CmdArgs.push_back("-analyzer-eagerly-assume");
3869
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003870 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003871 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003872 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00003873
Devin Coughlin65c77082016-01-21 20:09:49 +00003874 if (!IsWindowsMSVC) {
3875 CmdArgs.push_back("-analyzer-checker=unix");
3876 } else {
3877 // Enable "unix" checkers that also work on Windows.
3878 CmdArgs.push_back("-analyzer-checker=unix.API");
3879 CmdArgs.push_back("-analyzer-checker=unix.Malloc");
3880 CmdArgs.push_back("-analyzer-checker=unix.MallocSizeof");
3881 CmdArgs.push_back("-analyzer-checker=unix.MismatchedDeallocator");
3882 CmdArgs.push_back("-analyzer-checker=unix.cstring.BadSizeArg");
3883 CmdArgs.push_back("-analyzer-checker=unix.cstring.NullArg");
3884 }
Ted Kremenek49c79792011-03-24 00:28:47 +00003885
Sean Evesonb38c32b2016-01-06 10:03:58 +00003886 // Disable some unix checkers for PS4.
3887 if (IsPS4CPU) {
3888 CmdArgs.push_back("-analyzer-disable-checker=unix.API");
3889 CmdArgs.push_back("-analyzer-disable-checker=unix.Vfork");
3890 }
3891
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003892 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00003893 CmdArgs.push_back("-analyzer-checker=osx");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003894
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00003895 CmdArgs.push_back("-analyzer-checker=deadcode");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003896
Artem Belevichba558952015-05-06 18:20:23 +00003897 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00003898 CmdArgs.push_back("-analyzer-checker=cplusplus");
3899
Sean Evesonb38c32b2016-01-06 10:03:58 +00003900 if (!IsPS4CPU) {
3901 CmdArgs.push_back(
3902 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
3903 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
3904 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
3905 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
3906 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
3907 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
3908 }
Gabor Horvathe3085992015-09-14 20:34:06 +00003909
3910 // Default nullability checks.
3911 CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull");
3912 CmdArgs.push_back(
3913 "-analyzer-checker=nullability.NullReturnedFromNonnull");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003914 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003915
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003916 // Set the output format. The default is plist, for (lame) historical
3917 // reasons.
3918 CmdArgs.push_back("-analyzer-output");
3919 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00003920 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003921 else
3922 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003923
Ted Kremenekfe449a22010-03-22 22:32:05 +00003924 // Disable the presentation of standard compiler warnings when
3925 // using --analyze. We only want to show static analyzer diagnostics
3926 // or frontend errors.
3927 CmdArgs.push_back("-w");
3928
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003929 // Add -Xanalyzer arguments when running as analyzer.
3930 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00003931 }
3932
Daniel Dunbar4eadb602009-09-10 01:21:12 +00003933 CheckCodeGenerationOptions(D, Args);
3934
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003935 llvm::Reloc::Model RelocationModel;
3936 unsigned PICLevel;
3937 bool IsPIE;
3938 std::tie(RelocationModel, PICLevel, IsPIE) =
3939 ParsePICArgs(getToolChain(), Triple, Args);
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003940
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003941 const char *RMName = RelocationModelName(RelocationModel);
3942 if (RMName) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003943 CmdArgs.push_back("-mrelocation-model");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003944 CmdArgs.push_back(RMName);
3945 }
3946 if (PICLevel > 0) {
3947 CmdArgs.push_back("-pic-level");
3948 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
3949 if (IsPIE) {
3950 CmdArgs.push_back("-pie-level");
3951 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003952 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003953 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003954
Renato Golin4854d802015-11-09 12:40:41 +00003955 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3956 CmdArgs.push_back("-meabi");
3957 CmdArgs.push_back(A->getValue());
3958 }
3959
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003960 CmdArgs.push_back("-mthread-model");
3961 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3962 CmdArgs.push_back(A->getValue());
3963 else
3964 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3965
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003966 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3967
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003968 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3969 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003970 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003971
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003972 // LLVM Code Generator Options.
3973
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003974 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3975 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003976 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3977 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003978 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003979 CmdArgs.push_back(A->getValue());
3980 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003981 }
3982 }
3983
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003984 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3985 StringRef v = A->getValue();
3986 CmdArgs.push_back("-mllvm");
3987 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3988 A->claim();
3989 }
3990
Nirav Daved2f44d82016-04-05 17:50:43 +00003991 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
3992 true))
3993 CmdArgs.push_back("-fno-jump-tables");
3994
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003995 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3996 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003997 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003998 }
3999
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00004000 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
4001 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004002 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00004003 D.Diag(diag::err_drv_unsupported_opt_for_target)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004004 << A->getSpelling() << getToolChain().getTriple().str();
John McCall1fe2a8c2013-06-18 02:46:29 +00004005 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
4006 CmdArgs.push_back("-fpcc-struct-return");
4007 } else {
4008 assert(A->getOption().matches(options::OPT_freg_struct_return));
4009 CmdArgs.push_back("-freg-struct-return");
4010 }
4011 }
4012
Roman Divacky65b88cd2011-03-01 17:40:53 +00004013 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
Alexey Bataeva7547182016-05-18 09:06:38 +00004014 CmdArgs.push_back("-fdefault-calling-conv=stdcall");
Roman Divacky65b88cd2011-03-01 17:40:53 +00004015
Rafael Espindola224dd632011-12-14 21:02:23 +00004016 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004017 CmdArgs.push_back("-mdisable-fp-elim");
4018 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
4019 options::OPT_fno_zero_initialized_in_bss))
4020 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004021
4022 bool OFastEnabled = isOptimizationLevelFast(Args);
4023 // If -Ofast is the optimization level, then -fstrict-aliasing should be
4024 // enabled. This alias option is being used to simplify the hasFlag logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004025 OptSpecifier StrictAliasingAliasOption =
4026 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00004027 // We turn strict aliasing off by default if we're in CL mode, since MSVC
4028 // doesn't do any TBAA.
4029 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004030 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00004031 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00004032 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00004033 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
4034 options::OPT_fno_struct_path_tbaa))
4035 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00004036 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
4037 false))
4038 CmdArgs.push_back("-fstrict-enums");
Piotr Padlewski338c9d02015-09-15 21:46:47 +00004039 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
4040 options::OPT_fno_strict_vtable_pointers,
4041 false))
4042 CmdArgs.push_back("-fstrict-vtable-pointers");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00004043 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4044 options::OPT_fno_optimize_sibling_calls))
4045 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004046
Eric Christopher006208c2013-04-04 06:29:47 +00004047 // Handle segmented stacks.
4048 if (Args.hasArg(options::OPT_fsplit_stack))
4049 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004050
4051 // If -Ofast is the optimization level, then -ffast-math should be enabled.
4052 // This alias option is being used to simplify the getLastArg logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004053 OptSpecifier FastMathAliasOption =
4054 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
4055
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004056 // Handle various floating point optimization flags, mapping them to the
4057 // appropriate LLVM code generation flags. The pattern for all of these is to
4058 // default off the codegen optimizations, and if any flag enables them and no
4059 // flag disables them after the flag enabling them, enable the codegen
4060 // optimization. This is complicated by several "umbrella" flags.
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_ffinite_math_only,
4064 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
4065 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004066 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4067 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004068 A->getOption().getID() != options::OPT_fhonor_infinities)
4069 CmdArgs.push_back("-menable-no-infs");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004070 if (Arg *A = Args.getLastArg(
4071 options::OPT_ffast_math, FastMathAliasOption,
4072 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
4073 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
4074 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004075 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4076 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004077 A->getOption().getID() != options::OPT_fhonor_nans)
4078 CmdArgs.push_back("-menable-no-nans");
4079
Benjamin Kramerc242ef22012-05-02 14:55:48 +00004080 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
4081 bool MathErrno = getToolChain().IsMathErrnoDefault();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004082 if (Arg *A =
4083 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
4084 options::OPT_fno_fast_math, options::OPT_fmath_errno,
4085 options::OPT_fno_math_errno)) {
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00004086 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
4087 // However, turning *off* -ffast_math merely restores the toolchain default
4088 // (which may be false).
4089 if (A->getOption().getID() == options::OPT_fno_math_errno ||
4090 A->getOption().getID() == options::OPT_ffast_math ||
4091 A->getOption().getID() == options::OPT_Ofast)
4092 MathErrno = false;
4093 else if (A->getOption().getID() == options::OPT_fmath_errno)
4094 MathErrno = true;
4095 }
Chandler Carruth3634c662012-04-26 02:10:51 +00004096 if (MathErrno)
4097 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004098
4099 // There are several flags which require disabling very specific
4100 // optimizations. Any of these being disabled forces us to turn off the
4101 // entire set of LLVM optimizations, so collect them through all the flag
4102 // madness.
4103 bool AssociativeMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004104 if (Arg *A = Args.getLastArg(
4105 options::OPT_ffast_math, FastMathAliasOption,
4106 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4107 options::OPT_fno_unsafe_math_optimizations,
4108 options::OPT_fassociative_math, options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004109 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4110 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004111 A->getOption().getID() != options::OPT_fno_associative_math)
4112 AssociativeMath = true;
4113 bool ReciprocalMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004114 if (Arg *A = Args.getLastArg(
4115 options::OPT_ffast_math, FastMathAliasOption,
4116 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4117 options::OPT_fno_unsafe_math_optimizations,
4118 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004119 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4120 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004121 A->getOption().getID() != options::OPT_fno_reciprocal_math)
4122 ReciprocalMath = true;
4123 bool SignedZeros = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004124 if (Arg *A = Args.getLastArg(
4125 options::OPT_ffast_math, FastMathAliasOption,
4126 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4127 options::OPT_fno_unsafe_math_optimizations,
4128 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004129 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4130 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004131 A->getOption().getID() != options::OPT_fsigned_zeros)
4132 SignedZeros = false;
4133 bool TrappingMath = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004134 if (Arg *A = Args.getLastArg(
4135 options::OPT_ffast_math, FastMathAliasOption,
4136 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
4137 options::OPT_fno_unsafe_math_optimizations,
4138 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004139 if (A->getOption().getID() != options::OPT_fno_fast_math &&
4140 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004141 A->getOption().getID() != options::OPT_ftrapping_math)
4142 TrappingMath = false;
4143 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
4144 !TrappingMath)
4145 CmdArgs.push_back("-menable-unsafe-fp-math");
4146
Sanjay Patel76c9e092015-01-23 16:40:50 +00004147 if (!SignedZeros)
4148 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00004149
Sanjay Patel359b1052015-04-09 15:03:23 +00004150 if (ReciprocalMath)
4151 CmdArgs.push_back("-freciprocal-math");
4152
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004153 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004154 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004155 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00004156 options::OPT_ffp_contract)) {
4157 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004158 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00004159 if (Val == "fast" || Val == "on" || Val == "off") {
4160 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
4161 } else {
4162 D.Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004163 << A->getOption().getName() << Val;
Lang Hamesaa53b932012-07-06 00:59:19 +00004164 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004165 } else if (A->getOption().matches(options::OPT_ffast_math) ||
4166 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00004167 // If fast-math is set then set the fp-contract mode to fast.
4168 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
4169 }
4170 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004171
Sanjay Patel2987c292015-06-11 14:53:41 +00004172 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00004173
Bob Wilson6a039162012-07-19 03:52:53 +00004174 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
4175 // and if we find them, tell the frontend to provide the appropriate
4176 // preprocessor macros. This is distinct from enabling any optimizations as
4177 // these options induce language changes which must survive serialization
4178 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00004179 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
4180 options::OPT_fno_fast_math))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004181 if (!A->getOption().matches(options::OPT_fno_fast_math))
4182 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00004183 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
4184 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00004185 if (A->getOption().matches(options::OPT_ffinite_math_only))
4186 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00004187
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004188 // Decide whether to use verbose asm. Verbose assembly is the default on
4189 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004190 bool IsIntegratedAssemblerDefault =
4191 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004192 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004193 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004194 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004195 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00004196
Rafael Espindolab8a12932015-05-22 20:44:03 +00004197 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
4198 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00004199 CmdArgs.push_back("-no-integrated-as");
4200
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004201 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
4202 CmdArgs.push_back("-mdebug-pass");
4203 CmdArgs.push_back("Structure");
4204 }
4205 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
4206 CmdArgs.push_back("-mdebug-pass");
4207 CmdArgs.push_back("Arguments");
4208 }
4209
Justin Lebar710a35f2016-01-25 22:36:35 +00004210 // Enable -mconstructor-aliases except on darwin, where we have to work around
4211 // a linker bug (see <rdar://problem/7651567>), and CUDA device code, where
4212 // aliases aren't supported.
4213 if (!getToolChain().getTriple().isOSDarwin() &&
4214 !getToolChain().getTriple().isNVPTX())
John McCall8517abc2010-02-19 02:45:38 +00004215 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004216
John McCall7ef5cb32011-03-18 02:56:14 +00004217 // Darwin's kernel doesn't support guard variables; just die if we
4218 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00004219 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00004220 CmdArgs.push_back("-fforbid-guard-variables");
4221
Akira Hatanaka02028482015-11-12 17:21:22 +00004222 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
4223 false)) {
Douglas Gregordbe39272011-02-01 15:15:22 +00004224 CmdArgs.push_back("-mms-bitfields");
4225 }
John McCall8517abc2010-02-19 02:45:38 +00004226
Daniel Dunbar306945d2009-09-16 06:17:29 +00004227 // This is a coarse approximation of what llvm-gcc actually does, both
4228 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
4229 // complicated ways.
4230 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00004231 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
4232 options::OPT_fno_asynchronous_unwind_tables,
4233 (getToolChain().IsUnwindTablesDefault() ||
4234 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
4235 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00004236 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
4237 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004238 CmdArgs.push_back("-munwind-tables");
4239
Chandler Carruth05fb5852012-11-21 23:40:23 +00004240 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00004241
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004242 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
4243 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00004244 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004245 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00004246
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00004247 // FIXME: Handle -mtune=.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004248 (void)Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00004249
Benjamin Kramercf4371a2009-08-05 14:30:52 +00004250 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00004251 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00004252 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00004253 }
4254
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004255 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00004256 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004257 if (!CPU.empty()) {
4258 CmdArgs.push_back("-target-cpu");
4259 CmdArgs.push_back(Args.MakeArgString(CPU));
4260 }
4261
Rafael Espindolaeb265472013-08-21 21:59:03 +00004262 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
4263 CmdArgs.push_back("-mfpmath");
4264 CmdArgs.push_back(A->getValue());
4265 }
4266
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004267 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00004268 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00004269
Rafael Espindola22ce34a2013-08-20 22:12:08 +00004270 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004271 switch (getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00004272 default:
4273 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00004274
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004275 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004276 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004277 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004278 case llvm::Triple::thumbeb:
Saleem Abdulrasoolce63ce92015-09-19 18:19:44 +00004279 // Use the effective triple, which takes into account the deployment target.
4280 AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00004281 break;
4282
Tim Northover573cbee2014-05-24 12:52:07 +00004283 case llvm::Triple::aarch64:
4284 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00004285 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00004286 break;
4287
Eric Christopher0b26a612010-03-02 02:41:08 +00004288 case llvm::Triple::mips:
4289 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00004290 case llvm::Triple::mips64:
4291 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00004292 AddMIPSTargetArgs(Args, CmdArgs);
4293 break;
4294
Ulrich Weigand8afad612014-07-28 13:17:52 +00004295 case llvm::Triple::ppc:
4296 case llvm::Triple::ppc64:
4297 case llvm::Triple::ppc64le:
4298 AddPPCTargetArgs(Args, CmdArgs);
4299 break;
4300
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004301 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00004302 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00004303 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004304 AddSparcTargetArgs(Args, CmdArgs);
4305 break;
4306
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +00004307 case llvm::Triple::systemz:
4308 AddSystemZTargetArgs(Args, CmdArgs);
4309 break;
4310
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00004311 case llvm::Triple::x86:
4312 case llvm::Triple::x86_64:
4313 AddX86TargetArgs(Args, CmdArgs);
4314 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004315
Jacques Pienaard964cc22016-03-28 21:02:54 +00004316 case llvm::Triple::lanai:
4317 AddLanaiTargetArgs(Args, CmdArgs);
4318 break;
4319
Tony Linthicum76329bf2011-12-12 21:14:55 +00004320 case llvm::Triple::hexagon:
4321 AddHexagonTargetArgs(Args, CmdArgs);
4322 break;
Dan Gohmane3d71e12016-01-07 01:00:21 +00004323
4324 case llvm::Triple::wasm32:
4325 case llvm::Triple::wasm64:
4326 AddWebAssemblyTargetArgs(Args, CmdArgs);
4327 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00004328 }
4329
Douglas Katzman3459ce22015-10-08 04:24:12 +00004330 // The 'g' groups options involve a somewhat intricate sequence of decisions
4331 // about what to pass from the driver to the frontend, but by the time they
Paul Robinson0334a042015-12-19 19:41:48 +00004332 // reach cc1 they've been factored into three well-defined orthogonal choices:
Douglas Katzman3459ce22015-10-08 04:24:12 +00004333 // * what level of debug info to generate
4334 // * what dwarf version to write
Paul Robinson0334a042015-12-19 19:41:48 +00004335 // * what debugger tuning to use
Douglas Katzman3459ce22015-10-08 04:24:12 +00004336 // This avoids having to monkey around further in cc1 other than to disable
4337 // codeview if not running in a Windows environment. Perhaps even that
4338 // decision should be made in the driver as well though.
Paul Robinson0334a042015-12-19 19:41:48 +00004339 unsigned DwarfVersion = 0;
4340 llvm::DebuggerKind DebuggerTuning = getToolChain().getDefaultDebuggerTuning();
4341 // These two are potentially updated by AddClangCLArgs.
Benjamin Kramer8c305922016-02-02 11:06:51 +00004342 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo;
Douglas Katzman3459ce22015-10-08 04:24:12 +00004343 bool EmitCodeView = false;
4344
Hans Wennborg75958c42013-08-08 00:17:41 +00004345 // Add clang-cl arguments.
David Majnemercd5855e2016-02-29 01:40:36 +00004346 types::ID InputType = Input.getType();
Hans Wennborg75958c42013-08-08 00:17:41 +00004347 if (getToolChain().getDriver().IsCLMode())
David Majnemercd5855e2016-02-29 01:40:36 +00004348 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
Hans Wennborg75958c42013-08-08 00:17:41 +00004349
Daniel Dunbar976a2f52010-08-11 23:07:47 +00004350 // Pass the linker version in use.
4351 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4352 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00004353 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00004354 }
4355
Eric Christopherb7d97e92013-04-03 01:58:53 +00004356 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00004357 CmdArgs.push_back("-momit-leaf-frame-pointer");
4358
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00004359 // Explicitly error on some things we know we don't support and can't just
4360 // ignore.
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00004361 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4362 Arg *Unsupported;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004363 if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00004364 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00004365 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4366 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004367 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004368 << Unsupported->getOption().getName();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00004369 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00004370 }
4371
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004372 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00004373 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00004374 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00004375 CmdArgs.push_back("-header-include-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004376 CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
4377 : "-");
Daniel Dunbarac540b32011-02-02 21:11:35 +00004378 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004379 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00004380 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004381
Chad Rosierbe10f982011-08-02 17:58:04 +00004382 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00004383 CmdArgs.push_back("-diagnostic-log-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004384 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
4385 : "-");
Daniel Dunbar529c03b2011-04-07 18:01:20 +00004386 }
4387
Rafael Espindola08a692a2010-03-07 04:46:18 +00004388 Args.ClaimAllArgs(options::OPT_g_Group);
David Blaikiece3e7a62015-07-30 21:42:22 +00004389 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00004390 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Paul Robinson0334a042015-12-19 19:41:48 +00004391 // If the last option explicitly specified a debug-info level, use it.
4392 if (A->getOption().matches(options::OPT_gN_Group)) {
4393 DebugInfoKind = DebugLevelToInfoKind(*A);
4394 // If you say "-gsplit-dwarf -gline-tables-only", -gsplit-dwarf loses.
4395 // But -gsplit-dwarf is not a g_group option, hence we have to check the
4396 // order explicitly. (If -gsplit-dwarf wins, we fix DebugInfoKind later.)
Benjamin Kramer8c305922016-02-02 11:06:51 +00004397 if (SplitDwarfArg && DebugInfoKind < codegenoptions::LimitedDebugInfo &&
Paul Robinson0334a042015-12-19 19:41:48 +00004398 A->getIndex() > SplitDwarfArg->getIndex())
4399 SplitDwarfArg = nullptr;
4400 } else
4401 // For any other 'g' option, use Limited.
Benjamin Kramer8c305922016-02-02 11:06:51 +00004402 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00004403 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004404
Paul Robinson0334a042015-12-19 19:41:48 +00004405 // If a debugger tuning argument appeared, remember it.
4406 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
4407 options::OPT_ggdbN_Group)) {
4408 if (A->getOption().matches(options::OPT_glldb))
4409 DebuggerTuning = llvm::DebuggerKind::LLDB;
4410 else if (A->getOption().matches(options::OPT_gsce))
4411 DebuggerTuning = llvm::DebuggerKind::SCE;
4412 else
4413 DebuggerTuning = llvm::DebuggerKind::GDB;
4414 }
4415
4416 // If a -gdwarf argument appeared, remember it.
Douglas Katzman3459ce22015-10-08 04:24:12 +00004417 if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
Eric Christopher3cb592d2015-12-28 19:58:44 +00004418 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
Douglas Katzman3459ce22015-10-08 04:24:12 +00004419 DwarfVersion = DwarfVersionNum(A->getSpelling());
4420
Reid Kleckner124955a2015-08-05 18:51:13 +00004421 // Forward -gcodeview.
Douglas Katzman3459ce22015-10-08 04:24:12 +00004422 // 'EmitCodeView might have been set by CL-compatibility argument parsing.
4423 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
4424 // DwarfVersion remains at 0 if no explicit choice was made.
4425 CmdArgs.push_back("-gcodeview");
4426 } else if (DwarfVersion == 0 &&
Benjamin Kramer8c305922016-02-02 11:06:51 +00004427 DebugInfoKind != codegenoptions::NoDebugInfo) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00004428 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
4429 }
Reid Kleckner124955a2015-08-05 18:51:13 +00004430
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00004431 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
4432 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004433
4434 // PS4 defaults to no column info
Diego Novillo94b276d2014-07-10 23:29:28 +00004435 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004436 /*Default=*/ !IsPS4CPU))
Eric Christophera2f7eb72012-10-18 21:52:18 +00004437 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00004438
Eric Christopher138c32b2013-09-13 22:37:55 +00004439 // FIXME: Move backend command line options to the module.
Adrian Prantl6b21ab22015-08-27 19:46:20 +00004440 if (Args.hasArg(options::OPT_gmodules)) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004441 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Adrian Prantl6b21ab22015-08-27 19:46:20 +00004442 CmdArgs.push_back("-dwarf-ext-refs");
4443 CmdArgs.push_back("-fmodule-format=obj");
4444 }
4445
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00004446 // -gsplit-dwarf should turn on -g and enable the backend dwarf
4447 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00004448 // FIXME: Currently only works on Linux.
David Blaikiece3e7a62015-07-30 21:42:22 +00004449 if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004450 DebugInfoKind = codegenoptions::LimitedDebugInfo;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00004451 CmdArgs.push_back("-backend-option");
4452 CmdArgs.push_back("-split-dwarf=Enable");
4453 }
4454
Douglas Katzman3459ce22015-10-08 04:24:12 +00004455 // After we've dealt with all combinations of things that could
4456 // make DebugInfoKind be other than None or DebugLineTablesOnly,
4457 // figure out if we need to "upgrade" it to standalone debug info.
4458 // We parse these two '-f' options whether or not they will be used,
4459 // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"
4460 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
4461 options::OPT_fno_standalone_debug,
4462 getToolChain().GetDefaultStandaloneDebug());
Benjamin Kramer8c305922016-02-02 11:06:51 +00004463 if (DebugInfoKind == codegenoptions::LimitedDebugInfo && NeedFullDebug)
4464 DebugInfoKind = codegenoptions::FullDebugInfo;
Paul Robinson0334a042015-12-19 19:41:48 +00004465 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
4466 DebuggerTuning);
Douglas Katzman3459ce22015-10-08 04:24:12 +00004467
Eric Christopher138c32b2013-09-13 22:37:55 +00004468 // -ggnu-pubnames turns on gnu style pubnames in the backend.
4469 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
4470 CmdArgs.push_back("-backend-option");
4471 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
4472 }
Eric Christophereec89c22013-06-18 00:03:50 +00004473
Eric Christopher0d403d22014-02-14 01:27:03 +00004474 // -gdwarf-aranges turns on the emission of the aranges section in the
4475 // backend.
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00004476 // Always enabled on the PS4.
4477 if (Args.hasArg(options::OPT_gdwarf_aranges) || IsPS4CPU) {
Eric Christopher0d403d22014-02-14 01:27:03 +00004478 CmdArgs.push_back("-backend-option");
4479 CmdArgs.push_back("-generate-arange-section");
4480 }
4481
David Blaikief36d9ba2014-01-27 18:52:43 +00004482 if (Args.hasFlag(options::OPT_fdebug_types_section,
4483 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00004484 CmdArgs.push_back("-backend-option");
4485 CmdArgs.push_back("-generate-type-units");
4486 }
Eric Christophereec89c22013-06-18 00:03:50 +00004487
Dan Gohmana5b804b2016-01-07 00:50:27 +00004488 // CloudABI and WebAssembly use -ffunction-sections and -fdata-sections by
4489 // default.
4490 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI ||
4491 Triple.getArch() == llvm::Triple::wasm32 ||
4492 Triple.getArch() == llvm::Triple::wasm64;
Ed Schouten6e576152015-03-26 17:50:28 +00004493
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004494 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00004495 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004496 CmdArgs.push_back("-ffunction-sections");
4497 }
4498
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004499 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4500 UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00004501 CmdArgs.push_back("-fdata-sections");
4502 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00004503
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00004504 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00004505 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00004506 CmdArgs.push_back("-fno-unique-section-names");
4507
Chris Lattner3c77a352010-06-22 00:03:40 +00004508 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
4509
Diego Novilloa0545962015-07-10 18:00:07 +00004510 addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
Nick Lewycky480cb992011-05-04 20:46:58 +00004511
Paul Robinsond083b9a2015-12-16 17:25:27 +00004512 // Add runtime flag for PS4 when PGO or Coverage are enabled.
4513 if (getToolChain().getTriple().isPS4CPU())
4514 addPS4ProfileRTArgs(getToolChain(), Args, CmdArgs);
4515
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00004516 // Pass options for controlling the default header search paths.
4517 if (Args.hasArg(options::OPT_nostdinc)) {
4518 CmdArgs.push_back("-nostdsysteminc");
4519 CmdArgs.push_back("-nobuiltininc");
4520 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00004521 if (Args.hasArg(options::OPT_nostdlibinc))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004522 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00004523 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4524 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4525 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004526
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00004527 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00004528 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00004529 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00004530
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00004531 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4532
Ted Kremenekf7639e12012-03-06 20:06:33 +00004533 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00004534 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004535 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004536 options::OPT_ccc_arcmt_modify,
4537 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004538 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00004539 switch (A->getOption().getID()) {
4540 default:
4541 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004542 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00004543 CmdArgs.push_back("-arcmt-check");
4544 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004545 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00004546 CmdArgs.push_back("-arcmt-modify");
4547 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004548 case options::OPT_ccc_arcmt_migrate:
4549 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004550 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004551 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00004552
4553 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
4554 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004555 break;
John McCalld70fb982011-06-15 23:25:17 +00004556 }
4557 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00004558 } else {
4559 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
4560 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
4561 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00004562 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004563
Ted Kremenekf7639e12012-03-06 20:06:33 +00004564 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
4565 if (ARCMTEnabled) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004566 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4567 << "-ccc-arcmt-migrate";
Ted Kremenekf7639e12012-03-06 20:06:33 +00004568 }
4569 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004570 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00004571
4572 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004573 options::OPT_objcmt_migrate_subscripting,
4574 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004575 // None specified, means enable them all.
4576 CmdArgs.push_back("-objcmt-migrate-literals");
4577 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004578 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004579 } else {
4580 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4581 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004582 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004583 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004584 } else {
4585 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4586 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4587 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4588 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4589 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4590 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00004591 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004592 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4593 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4594 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4595 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4596 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4597 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4598 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00004599 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00004600 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004601 }
4602
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004603 // Add preprocessing options like -I, -D, etc. if we are using the
4604 // preprocessor.
4605 //
4606 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004607 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Artem Belevichfa11ab52015-11-17 22:28:46 +00004608 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs,
4609 AuxToolChain);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004610
Rafael Espindolaa7431922011-07-21 23:40:37 +00004611 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
4612 // that "The compiler can only warn and ignore the option if not recognized".
4613 // When building with ccache, it will pass -D options to clang even on
4614 // preprocessed inputs and configure concludes that -fPIC is not supported.
4615 Args.ClaimAllArgs(options::OPT_D);
4616
Alp Toker7874bdc2013-11-15 20:40:58 +00004617 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00004618 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4619 if (A->getOption().matches(options::OPT_O4)) {
4620 CmdArgs.push_back("-O3");
4621 D.Diag(diag::warn_O4_is_O3);
4622 } else {
4623 A->render(Args, CmdArgs);
4624 }
4625 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004626
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004627 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00004628 for (const Arg *A :
4629 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4630 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Douglas Katzman8b50e012015-08-05 18:03:47 +00004631 A->claim();
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004632 }
4633
Rafael Espindola577637a2015-01-03 00:06:04 +00004634 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00004635
Richard Smith3be1cb22014-08-07 00:24:21 +00004636 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00004637 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00004638 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
4639 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00004640 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004641 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004642
4643 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00004644 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004645 //
4646 // If a std is supplied, only add -trigraphs if it follows the
4647 // option.
David Majnemer8db91762015-05-18 04:49:30 +00004648 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004649 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4650 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00004651 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004652 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00004653 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004654 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004655 else
4656 Std->render(Args, CmdArgs);
4657
Nico Weber00721502014-12-23 22:32:37 +00004658 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004659 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00004660 options::OPT_ftrigraphs,
4661 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004662 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004663 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004664 } else {
4665 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00004666 //
4667 // FIXME: Clang doesn't correctly handle -std= when the input language
4668 // doesn't match. For the time being just ignore this for C++ inputs;
4669 // eventually we want to do all the standard defaulting here instead of
4670 // splitting it between the driver and clang -cc1.
4671 if (!types::isCXX(InputType))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004672 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
4673 /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004674 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00004675 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00004676
Nico Weber00721502014-12-23 22:32:37 +00004677 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4678 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004679 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004680
Richard Smith282b4492013-09-04 22:50:31 +00004681 // GCC's behavior for -Wwrite-strings is a bit strange:
4682 // * In C, this "warning flag" changes the types of string literals from
4683 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
4684 // for the discarded qualifier.
4685 // * In C++, this is just a normal warning flag.
4686 //
4687 // Implementing this warning correctly in C is hard, so we follow GCC's
4688 // behavior for now. FIXME: Directly diagnose uses of a string literal as
4689 // a non-const char* in C, rather than using this crude hack.
4690 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00004691 // FIXME: This should behave just like a warning flag, and thus should also
4692 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
4693 Arg *WriteStrings =
4694 Args.getLastArg(options::OPT_Wwrite_strings,
4695 options::OPT_Wno_write_strings, options::OPT_w);
4696 if (WriteStrings &&
4697 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00004698 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00004699 }
4700
Chandler Carruth61fbf622011-04-23 09:27:53 +00004701 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00004702 // during C++ compilation, which it is by default. GCC keeps this define even
4703 // in the presence of '-w', match this behavior bug-for-bug.
4704 if (types::isCXX(InputType) &&
4705 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4706 true)) {
4707 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00004708 }
4709
Chandler Carruthe0391482010-05-22 02:21:53 +00004710 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
4711 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4712 if (Asm->getOption().matches(options::OPT_fasm))
4713 CmdArgs.push_back("-fgnu-keywords");
4714 else
4715 CmdArgs.push_back("-fno-gnu-keywords");
4716 }
4717
Nick Lewycky1d617ac2011-10-17 23:05:52 +00004718 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
4719 CmdArgs.push_back("-fno-dwarf-directory-asm");
4720
Daniel Dunbare246fbe2013-04-16 18:21:19 +00004721 if (ShouldDisableAutolink(Args, getToolChain()))
4722 CmdArgs.push_back("-fno-autolink");
4723
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004724 // Add in -fdebug-compilation-dir if necessary.
4725 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00004726
Saleem Abdulrasool436256a2015-10-12 20:21:08 +00004727 for (const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
4728 StringRef Map = A->getValue();
4729 if (Map.find('=') == StringRef::npos)
4730 D.Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
4731 else
4732 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
4733 A->claim();
4734 }
4735
Richard Smith9a568822011-11-21 19:36:32 +00004736 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4737 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004738 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004739 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004740 }
4741
Richard Smith79c927b2013-11-06 19:31:51 +00004742 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4743 CmdArgs.push_back("-foperator-arrow-depth");
4744 CmdArgs.push_back(A->getValue());
4745 }
4746
Richard Smith9a568822011-11-21 19:36:32 +00004747 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4748 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004749 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00004750 }
4751
Richard Smitha3d3bd22013-05-08 02:12:03 +00004752 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4753 CmdArgs.push_back("-fconstexpr-steps");
4754 CmdArgs.push_back(A->getValue());
4755 }
4756
Richard Smithb3a14522013-02-22 01:59:51 +00004757 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4758 CmdArgs.push_back("-fbracket-depth");
4759 CmdArgs.push_back(A->getValue());
4760 }
4761
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00004762 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4763 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004764 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004765 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004766 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
4767 } else
4768 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00004769 }
4770
Michael J. Spencer929fccd2012-10-22 22:13:48 +00004771 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00004772 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00004773
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004774 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4775 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00004776 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004777 }
David Chisnall5778fce2009-08-31 16:41:57 +00004778
Chris Lattnere23003d2010-01-09 21:54:33 +00004779 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4780 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00004781 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00004782 }
4783
Chris Lattnerb35583d2010-04-07 20:49:23 +00004784 CmdArgs.push_back("-ferror-limit");
4785 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00004786 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00004787 else
4788 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00004789
Chandler Carrutha77a7272010-05-06 04:55:18 +00004790 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4791 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004792 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004793 }
4794
4795 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4796 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004797 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004798 }
4799
Richard Smithf6f003a2011-12-16 19:06:07 +00004800 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4801 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004802 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00004803 }
4804
Nick Lewycky24653262014-12-16 21:39:02 +00004805 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4806 CmdArgs.push_back("-fspell-checking-limit");
4807 CmdArgs.push_back(A->getValue());
4808 }
4809
Daniel Dunbar2c978472009-11-04 06:24:47 +00004810 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00004811 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00004812 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004813 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00004814 } else {
4815 // If -fmessage-length=N was not specified, determine whether this is a
4816 // terminal and, if so, implicitly define -fmessage-length appropriately.
4817 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004818 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00004819 }
4820
John McCallb4a99d32013-02-19 01:57:35 +00004821 // -fvisibility= and -fvisibility-ms-compat are of a piece.
4822 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4823 options::OPT_fvisibility_ms_compat)) {
4824 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4825 CmdArgs.push_back("-fvisibility");
4826 CmdArgs.push_back(A->getValue());
4827 } else {
4828 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4829 CmdArgs.push_back("-fvisibility");
4830 CmdArgs.push_back("hidden");
4831 CmdArgs.push_back("-ftype-visibility");
4832 CmdArgs.push_back("default");
4833 }
Daniel Dunbare357d562009-12-03 18:42:11 +00004834 }
4835
Douglas Gregor08329632010-06-15 17:05:35 +00004836 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004837
Hans Wennborgf60f6af2012-06-28 08:01:44 +00004838 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4839
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004840 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00004841 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
4842 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004843 CmdArgs.push_back("-ffreestanding");
4844
Daniel Dunbare357d562009-12-03 18:42:11 +00004845 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004846 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004847 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Eric Christopher86050822011-10-25 07:13:06 +00004848 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004849 // Emulated TLS is enabled by default on Android, and can be enabled manually
4850 // with -femulated-tls.
NAKAMURA Takumi33ff1dd2016-01-16 03:44:52 +00004851 bool EmulatedTLSDefault = Triple.isAndroid() || Triple.isWindowsCygwinEnvironment();
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004852 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
4853 EmulatedTLSDefault))
4854 CmdArgs.push_back("-femulated-tls");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004855 // AltiVec-like language extensions aren't relevant for assembling.
4856 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) {
Bill Schmidtb3b804e2013-07-03 15:36:02 +00004857 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004858 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4859 }
Richard Trieu91844232012-06-26 18:18:47 +00004860 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4861 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00004862
Alexey Bataevdb390212015-05-20 04:24:19 +00004863 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004864 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
Alexey Bataevc6bd8912016-05-26 11:10:11 +00004865 options::OPT_fno_openmp, false)) {
4866 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004867 switch (getOpenMPRuntime(getToolChain(), Args)) {
4868 case OMPRT_OMP:
4869 case OMPRT_IOMP5:
4870 // Clang can generate useful OpenMP code for these two runtime libraries.
4871 CmdArgs.push_back("-fopenmp");
Samuel Antaof8b50122015-07-13 22:54:53 +00004872
4873 // If no option regarding the use of TLS in OpenMP codegeneration is
4874 // given, decide a default based on the target. Otherwise rely on the
4875 // options and pass the right information to the frontend.
4876 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
Alexey Bataev6a43c002015-09-10 12:06:58 +00004877 options::OPT_fnoopenmp_use_tls, /*Default=*/true))
Samuel Antaof8b50122015-07-13 22:54:53 +00004878 CmdArgs.push_back("-fnoopenmp-use-tls");
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004879 break;
4880 default:
4881 // By default, if Clang doesn't know how to generate useful OpenMP code
4882 // for a specific runtime library, we just don't pass the '-fopenmp' flag
4883 // down to the actual compilation.
4884 // FIXME: It would be better to have a mode which *only* omits IR
4885 // generation based on the OpenMP support so that we get consistent
4886 // semantic analysis, etc.
4887 break;
4888 }
Alexey Bataevc6bd8912016-05-26 11:10:11 +00004889 }
Alexey Bataevdb390212015-05-20 04:24:19 +00004890
Peter Collingbourne32701642013-11-01 18:16:25 +00004891 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
Peter Collingbourne581f4382015-07-02 01:48:12 +00004892 Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
Richard Smith52be6192012-11-05 22:04:41 +00004893
Eric Christopher459d2712013-02-19 06:16:53 +00004894 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004895 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4896 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4897 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4898 Arch == llvm::Triple::ppc64le))
4899 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4900 << "ppc/ppc64/ppc64le";
4901 }
Chad Rosier864dfe12012-03-13 23:45:51 +00004902
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004903 // -fzvector is incompatible with -faltivec.
4904 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4905 if (Args.hasArg(options::OPT_faltivec))
4906 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4907 << "-faltivec";
4908
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004909 if (getToolChain().SupportsProfiling())
4910 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00004911
4912 // -flax-vector-conversions is default.
4913 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4914 options::OPT_fno_lax_vector_conversions))
4915 CmdArgs.push_back("-fno-lax-vector-conversions");
4916
John Brawna7b4ec02015-08-10 11:11:28 +00004917 if (Args.getLastArg(options::OPT_fapple_kext) ||
4918 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004919 CmdArgs.push_back("-fapple-kext");
4920
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00004921 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00004922 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00004923 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004924 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4925 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00004926
4927 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4928 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00004929 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00004930 }
4931
Bob Wilson14adb362012-02-03 06:27:22 +00004932 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00004933
Chandler Carruth6e501032011-03-27 00:04:55 +00004934 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4935 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004936 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
Chandler Carruth6e501032011-03-27 00:04:55 +00004937 if (A->getOption().matches(options::OPT_fwrapv))
4938 CmdArgs.push_back("-fwrapv");
4939 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4940 options::OPT_fno_strict_overflow)) {
4941 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4942 CmdArgs.push_back("-fwrapv");
4943 }
Hal Finkelce0697f2013-11-17 16:03:29 +00004944
4945 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4946 options::OPT_fno_reroll_loops))
4947 if (A->getOption().matches(options::OPT_freroll_loops))
4948 CmdArgs.push_back("-freroll-loops");
4949
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004950 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00004951 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4952 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004953
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004954 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4955
Daniel Dunbar4930e332009-11-17 08:07:36 +00004956 // -stack-protector=0 is default.
4957 unsigned StackProtectorLevel = 0;
Evgeniy Stepanov368d3072016-04-11 22:27:55 +00004958 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4959 options::OPT_fstack_protector_all,
4960 options::OPT_fstack_protector_strong,
4961 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004962 if (A->getOption().matches(options::OPT_fstack_protector)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004963 StackProtectorLevel = std::max<unsigned>(
4964 LangOptions::SSPOn,
4965 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
Rafael Espindolace5c6092014-05-22 22:57:39 +00004966 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004967 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004968 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004969 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004970 } else {
4971 StackProtectorLevel =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004972 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
Nico Weberdd473632011-08-23 07:38:27 +00004973 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004974 if (StackProtectorLevel) {
4975 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004976 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004977 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004978
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004979 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004980 for (const Arg *A : Args.filtered(options::OPT__param)) {
4981 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004982 if (Str.startswith("ssp-buffer-size=")) {
4983 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004984 CmdArgs.push_back("-stack-protector-buffer-size");
4985 // FIXME: Verify the argument is a valid integer.
4986 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004987 }
Sean Silva14facf32015-06-09 01:57:17 +00004988 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004989 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004990 }
4991
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004992 // Translate -mstackrealign
4993 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
Akira Hatanakaaecca042015-09-11 18:55:09 +00004994 false))
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004995 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004996
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004997 if (Args.hasArg(options::OPT_mstack_alignment)) {
4998 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4999 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00005000 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00005001
Hans Wennborg77dc2362015-01-20 19:45:50 +00005002 if (Args.hasArg(options::OPT_mstack_probe_size)) {
5003 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
5004
5005 if (!Size.empty())
5006 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
5007 else
5008 CmdArgs.push_back("-mstack-probe-size=0");
5009 }
5010
Oliver Stannarddc2854c2015-09-03 12:40:58 +00005011 switch (getToolChain().getArch()) {
5012 case llvm::Triple::aarch64:
5013 case llvm::Triple::aarch64_be:
5014 case llvm::Triple::arm:
5015 case llvm::Triple::armeb:
5016 case llvm::Triple::thumb:
5017 case llvm::Triple::thumbeb:
Oliver Stannarded8ecc82014-08-27 16:31:57 +00005018 CmdArgs.push_back("-fallow-half-arguments-and-returns");
Oliver Stannarddc2854c2015-09-03 12:40:58 +00005019 break;
5020
5021 default:
5022 break;
5023 }
Oliver Stannarded8ecc82014-08-27 16:31:57 +00005024
Weiming Zhao580dcfb2013-11-13 18:31:23 +00005025 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
5026 options::OPT_mno_restrict_it)) {
5027 if (A->getOption().matches(options::OPT_mrestrict_it)) {
5028 CmdArgs.push_back("-backend-option");
5029 CmdArgs.push_back("-arm-restrict-it");
5030 } else {
5031 CmdArgs.push_back("-backend-option");
5032 CmdArgs.push_back("-arm-no-restrict-it");
5033 }
James Y Knight2db38f32015-08-15 03:45:25 +00005034 } else if (Triple.isOSWindows() &&
5035 (Triple.getArch() == llvm::Triple::arm ||
5036 Triple.getArch() == llvm::Triple::thumb)) {
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00005037 // Windows on ARM expects restricted IT blocks
5038 CmdArgs.push_back("-backend-option");
5039 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00005040 }
5041
Daniel Dunbard18049a2009-04-07 21:16:11 +00005042 // Forward -f options with positive and negative forms; we translate
5043 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00005044 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
5045 StringRef fname = A->getValue();
5046 if (!llvm::sys::fs::exists(fname))
5047 D.Diag(diag::err_drv_no_such_file) << fname;
5048 else
5049 A->render(Args, CmdArgs);
5050 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00005051
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00005052 // -fbuiltin is default unless -mkernel is used.
5053 bool UseBuiltins =
5054 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
5055 !Args.hasArg(options::OPT_mkernel));
5056 if (!UseBuiltins)
Daniel Dunbar484afa22009-11-19 04:55:23 +00005057 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00005058
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00005059 // -ffreestanding implies -fno-builtin.
5060 if (Args.hasArg(options::OPT_ffreestanding))
5061 UseBuiltins = false;
5062
5063 // Process the -fno-builtin-* options.
5064 for (const auto &Arg : Args) {
5065 const Option &O = Arg->getOption();
5066 if (!O.matches(options::OPT_fno_builtin_))
5067 continue;
5068
5069 Arg->claim();
5070 // If -fno-builtin is specified, then there's no need to pass the option to
5071 // the frontend.
5072 if (!UseBuiltins)
5073 continue;
5074
5075 StringRef FuncName = Arg->getValue();
5076 CmdArgs.push_back(Args.MakeArgString("-fno-builtin-" + FuncName));
5077 }
5078
Nuno Lopes13c88c72009-12-16 16:59:22 +00005079 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5080 options::OPT_fno_assume_sane_operator_new))
5081 CmdArgs.push_back("-fno-assume-sane-operator-new");
5082
Daniel Dunbar4930e332009-11-17 08:07:36 +00005083 // -fblocks=0 is default.
5084 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00005085 getToolChain().IsBlocksDefault()) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005086 (Args.hasArg(options::OPT_fgnu_runtime) &&
5087 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
5088 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00005089 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00005090
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005091 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
John McCall7959fee2011-09-09 20:41:01 +00005092 !getToolChain().hasBlocksRuntime())
5093 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00005094 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00005095
Richard Smith47972af2015-06-16 00:08:24 +00005096 // -fmodules enables the use of precompiled modules (off by default).
Richard Smithffb65082014-09-30 23:10:19 +00005097 // Users can pass -fno-cxx-modules to turn off modules support for
Richard Smith47972af2015-06-16 00:08:24 +00005098 // C++/Objective-C++ programs.
Douglas Gregorc60437f2013-01-16 01:23:41 +00005099 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00005100 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005101 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
5102 options::OPT_fno_cxx_modules, true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00005103 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00005104 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00005105 HaveModules = true;
5106 }
5107 }
5108
Richard Smith47972af2015-06-16 00:08:24 +00005109 // -fmodule-maps enables implicit reading of module map files. By default,
5110 // this is enabled if we are using precompiled modules.
Richard Smithcf18b792015-06-16 00:20:23 +00005111 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
5112 options::OPT_fno_implicit_module_maps, HaveModules)) {
Richard Smith47972af2015-06-16 00:08:24 +00005113 CmdArgs.push_back("-fimplicit-module-maps");
Daniel Jasper07e6c402013-08-05 20:26:17 +00005114 }
5115
Daniel Jasperac42b752013-10-21 06:34:34 +00005116 // -fmodules-decluse checks that modules used are declared so (off by
5117 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00005118 if (Args.hasFlag(options::OPT_fmodules_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005119 options::OPT_fno_modules_decluse, false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00005120 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00005121 }
5122
Daniel Jasper962b38e2014-04-11 11:47:45 +00005123 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
5124 // all #included headers are part of modules.
5125 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005126 options::OPT_fno_modules_strict_decluse, false)) {
Daniel Jasper962b38e2014-04-11 11:47:45 +00005127 CmdArgs.push_back("-fmodules-strict-decluse");
5128 }
5129
Manuel Klimekd2e8b042015-02-20 11:44:41 +00005130 // -fno-implicit-modules turns off implicitly compiling modules on demand.
5131 if (!Args.hasFlag(options::OPT_fimplicit_modules,
5132 options::OPT_fno_implicit_modules)) {
5133 CmdArgs.push_back("-fno-implicit-modules");
Richard Smith8d83d6d2016-03-21 19:06:06 +00005134 } else if (HaveModules) {
5135 // -fmodule-cache-path specifies where our implicitly-built module files
5136 // should be written.
5137 SmallString<128> Path;
5138 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
5139 Path = A->getValue();
Justin Bognera88f0122014-06-20 22:59:50 +00005140 if (C.isForDiagnostics()) {
5141 // When generating crash reports, we want to emit the modules along with
5142 // the reproduction sources, so we ignore any provided module path.
Daniel Jasper7450f912015-07-10 08:25:54 +00005143 Path = Output.getFilename();
5144 llvm::sys::path::replace_extension(Path, ".cache");
5145 llvm::sys::path::append(Path, "modules");
5146 } else if (Path.empty()) {
Justin Bognera88f0122014-06-20 22:59:50 +00005147 // No module path was provided: use the default.
Renato Golin7c542b42015-07-27 23:44:45 +00005148 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Path);
Daniel Jasper7450f912015-07-10 08:25:54 +00005149 llvm::sys::path::append(Path, "org.llvm.clang.");
5150 appendUserToPath(Path);
5151 llvm::sys::path::append(Path, "ModuleCache");
Justin Bognera88f0122014-06-20 22:59:50 +00005152 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00005153 const char Arg[] = "-fmodules-cache-path=";
Daniel Jasper7450f912015-07-10 08:25:54 +00005154 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
5155 CmdArgs.push_back(Args.MakeArgString(Path));
Justin Bognera88f0122014-06-20 22:59:50 +00005156 }
5157
Richard Smith8d83d6d2016-03-21 19:06:06 +00005158 // -fmodule-name specifies the module that is currently being built (or
5159 // used for header checking by -fmodule-maps).
5160 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
5161
5162 // -fmodule-map-file can be used to specify files containing module
5163 // definitions.
5164 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
5165
5166 // -fmodule-file can be used to specify files containing precompiled modules.
5167 if (HaveModules)
5168 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
5169 else
5170 Args.ClaimAllArgs(options::OPT_fmodule_file);
5171
Justin Bognera88f0122014-06-20 22:59:50 +00005172 // When building modules and generating crashdumps, we need to dump a module
5173 // dependency VFS alongside the output.
5174 if (HaveModules && C.isForDiagnostics()) {
5175 SmallString<128> VFSDir(Output.getFilename());
5176 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00005177 // Add the cache directory as a temp so the crash diagnostics pick it up.
5178 C.addTempFile(Args.MakeArgString(VFSDir));
5179
Justin Bognera88f0122014-06-20 22:59:50 +00005180 llvm::sys::path::append(VFSDir, "vfs");
5181 CmdArgs.push_back("-module-dependency-dir");
5182 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00005183 }
5184
Richard Smith9887d792014-10-17 01:42:53 +00005185 if (HaveModules)
5186 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00005187
Douglas Gregor35b04d62013-02-07 19:01:24 +00005188 // Pass through all -fmodules-ignore-macro arguments.
5189 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00005190 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
5191 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00005192
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005193 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
5194
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005195 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
5196 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
5197 D.Diag(diag::err_drv_argument_not_allowed_with)
5198 << A->getAsString(Args) << "-fbuild-session-timestamp";
5199
5200 llvm::sys::fs::file_status Status;
5201 if (llvm::sys::fs::status(A->getValue(), Status))
5202 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00005203 CmdArgs.push_back(Args.MakeArgString(
5204 "-fbuild-session-timestamp=" +
5205 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005206 }
5207
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005208 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00005209 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
5210 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00005211 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
5212
5213 Args.AddLastArg(CmdArgs,
5214 options::OPT_fmodules_validate_once_per_build_session);
5215 }
5216
Ben Langmuirdcf73862014-03-12 00:06:17 +00005217 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
5218
John McCalldfea9982010-04-09 19:12:06 +00005219 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00005220 if (Args.hasFlag(options::OPT_fno_access_control,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005221 options::OPT_faccess_control, false))
John McCall3155f572010-04-09 19:03:51 +00005222 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00005223
Anders Carlssond470fef2010-11-21 00:09:52 +00005224 // -felide-constructors is the default.
5225 if (Args.hasFlag(options::OPT_fno_elide_constructors,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005226 options::OPT_felide_constructors, false))
Anders Carlssond470fef2010-11-21 00:09:52 +00005227 CmdArgs.push_back("-fno-elide-constructors");
5228
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00005229 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00005230
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00005231 if (KernelOrKext || (types::isCXX(InputType) &&
5232 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
5233 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00005234 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00005235
Tony Linthicum76329bf2011-12-12 21:14:55 +00005236 // -fshort-enums=0 is default for all architectures except Hexagon.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005237 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
5238 getToolChain().getArch() == llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00005239 CmdArgs.push_back("-fshort-enums");
5240
Daniel Dunbard609b7b2009-11-17 06:37:03 +00005241 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00005242 if (Arg *A = Args.getLastArg(
5243 options::OPT_fsigned_char, options::OPT_fno_signed_char,
5244 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
5245 if (A->getOption().matches(options::OPT_funsigned_char) ||
5246 A->getOption().matches(options::OPT_fno_signed_char)) {
5247 CmdArgs.push_back("-fno-signed-char");
5248 }
5249 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00005250 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00005251 }
Eli Friedman327f0b52009-06-05 07:21:14 +00005252
Daniel Dunbarfe06df42010-03-20 04:15:41 +00005253 // -fuse-cxa-atexit is default.
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00005254 if (!Args.hasFlag(
5255 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
5256 !IsWindowsCygnus && !IsWindowsGNU &&
5257 getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
5258 getToolChain().getArch() != llvm::Triple::hexagon &&
5259 getToolChain().getArch() != llvm::Triple::xcore &&
5260 ((getToolChain().getTriple().getVendor() !=
5261 llvm::Triple::MipsTechnologies) ||
5262 getToolChain().getTriple().hasEnvironment())) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00005263 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00005264 CmdArgs.push_back("-fno-use-cxa-atexit");
5265
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00005266 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00005267 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00005268 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00005269 CmdArgs.push_back("-fms-extensions");
5270
Reid Kleckner1df0fea2015-02-26 00:17:25 +00005271 // -fno-use-line-directives is default.
5272 if (Args.hasFlag(options::OPT_fuse_line_directives,
5273 options::OPT_fno_use_line_directives, false))
5274 CmdArgs.push_back("-fuse-line-directives");
5275
Francois Pichet1b4f1632011-09-17 04:32:15 +00005276 // -fms-compatibility=0 is default.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005277 if (Args.hasFlag(options::OPT_fms_compatibility,
Douglas Gregor2b4907e2011-10-24 15:49:38 +00005278 options::OPT_fno_ms_compatibility,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005279 (IsWindowsMSVC &&
5280 Args.hasFlag(options::OPT_fms_extensions,
5281 options::OPT_fno_ms_extensions, true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00005282 CmdArgs.push_back("-fms-compatibility");
5283
David Majnemerc371ff02015-03-22 08:39:22 +00005284 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00005285 VersionTuple MSVT = visualstudio::getMSVCVersion(
Adrian McCarthye4b26fc2016-05-13 23:20:11 +00005286 &D, getToolChain(), getToolChain().getTriple(), Args, IsWindowsMSVC);
David Majnemere11d3732015-06-08 00:22:46 +00005287 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00005288 CmdArgs.push_back(
5289 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00005290
David Majnemer8db91762015-05-18 04:49:30 +00005291 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
5292 if (ImplyVCPPCXXVer) {
5293 if (IsMSVC2015Compatible)
5294 CmdArgs.push_back("-std=c++14");
5295 else
5296 CmdArgs.push_back("-std=c++11");
5297 }
5298
Eric Christopher5ecce122013-02-18 00:38:31 +00005299 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00005300 if (Args.hasFlag(options::OPT_fborland_extensions,
5301 options::OPT_fno_borland_extensions, false))
5302 CmdArgs.push_back("-fborland-extensions");
5303
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00005304 // -fno-declspec is default, except for PS4.
5305 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
5306 getToolChain().getTriple().isPS4()))
5307 CmdArgs.push_back("-fdeclspec");
5308 else if (Args.hasArg(options::OPT_fno_declspec))
5309 CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec.
5310
David Majnemerc371ff02015-03-22 08:39:22 +00005311 // -fthreadsafe-static is default, except for MSVC compatibility versions less
5312 // than 19.
5313 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
5314 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00005315 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00005316 CmdArgs.push_back("-fno-threadsafe-statics");
5317
Francois Pichet02744872011-09-01 16:38:08 +00005318 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
5319 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00005320 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00005321 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00005322 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00005323
Chandler Carruthe03aa552010-04-17 20:17:31 +00005324 // -fgnu-keywords default varies depending on language; only pass if
5325 // specified.
5326 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00005327 options::OPT_fno_gnu_keywords))
5328 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00005329
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005330 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
Rafael Espindola922a6242011-06-02 17:30:53 +00005331 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00005332 CmdArgs.push_back("-fgnu89-inline");
5333
Chad Rosier9c76d242012-03-15 22:31:42 +00005334 if (Args.hasArg(options::OPT_fno_inline))
5335 CmdArgs.push_back("-fno-inline");
5336
Hans Wennborg7a008882016-05-24 20:40:51 +00005337 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions,
5338 options::OPT_fno_inline_functions))
5339 InlineArg->render(Args, CmdArgs);
Chad Rosier80603182012-03-06 18:49:20 +00005340
John McCall5fb5df92012-06-20 06:18:46 +00005341 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00005342
John McCall5fb5df92012-06-20 06:18:46 +00005343 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00005344 // legacy is the default. Except for deployment taget of 10.5,
5345 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
5346 // gets ignored silently.
5347 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00005348 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
5349 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00005350 objcRuntime.isLegacyDispatchDefaultForArch(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005351 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00005352 if (getToolChain().UseObjCMixedDispatch())
5353 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
5354 else
5355 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
5356 }
5357 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00005358
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00005359 // When ObjectiveC legacy runtime is in effect on MacOSX,
5360 // turn on the option to do Array/Dictionary subscripting
5361 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005362 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00005363 getToolChain().getTriple().isMacOSX() &&
5364 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
5365 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00005366 objcRuntime.isNeXTFamily())
5367 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005368
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00005369 // -fencode-extended-block-signature=1 is default.
5370 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
5371 CmdArgs.push_back("-fencode-extended-block-signature");
5372 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005373
John McCall24fc0de2011-07-06 00:26:06 +00005374 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
5375 // NOTE: This logic is duplicated in ToolChains.cpp.
5376 bool ARC = isObjCAutoRefCount(Args);
5377 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00005378 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00005379
John McCall24fc0de2011-07-06 00:26:06 +00005380 CmdArgs.push_back("-fobjc-arc");
5381
Chandler Carruth491db322011-11-04 07:34:47 +00005382 // FIXME: It seems like this entire block, and several around it should be
5383 // wrapped in isObjC, but for now we just use it here as this is where it
5384 // was being used previously.
5385 if (types::isCXX(InputType) && types::isObjC(InputType)) {
5386 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
5387 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
5388 else
5389 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
5390 }
5391
John McCall24fc0de2011-07-06 00:26:06 +00005392 // Allow the user to enable full exceptions code emission.
5393 // We define off for Objective-CC, on for Objective-C++.
5394 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
5395 options::OPT_fno_objc_arc_exceptions,
5396 /*default*/ types::isCXX(InputType)))
5397 CmdArgs.push_back("-fobjc-arc-exceptions");
John McCall460ce582015-10-22 18:38:17 +00005398
John McCall24fc0de2011-07-06 00:26:06 +00005399 }
5400
5401 // -fobjc-infer-related-result-type is the default, except in the Objective-C
5402 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00005403 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00005404 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005405
John McCall24fc0de2011-07-06 00:26:06 +00005406 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
5407 // takes precedence.
5408 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
5409 if (!GCArg)
5410 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
5411 if (GCArg) {
5412 if (ARC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005413 D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00005414 } else if (getToolChain().SupportsObjCGC()) {
5415 GCArg->render(Args, CmdArgs);
5416 } else {
5417 // FIXME: We should move this to a hard error.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005418 D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00005419 }
5420 }
5421
John McCallfbe5ed72015-11-05 19:19:56 +00005422 // Pass down -fobjc-weak or -fno-objc-weak if present.
5423 if (types::isObjC(InputType)) {
5424 auto WeakArg = Args.getLastArg(options::OPT_fobjc_weak,
5425 options::OPT_fno_objc_weak);
5426 if (!WeakArg) {
5427 // nothing to do
5428 } else if (GCArg) {
5429 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5430 D.Diag(diag::err_objc_weak_with_gc);
5431 } else if (!objcRuntime.allowsWeak()) {
5432 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5433 D.Diag(diag::err_objc_weak_unsupported);
5434 } else {
5435 WeakArg->render(Args, CmdArgs);
5436 }
5437 }
5438
Bob Wilsonb111ec92015-03-02 19:01:14 +00005439 if (Args.hasFlag(options::OPT_fapplication_extension,
5440 options::OPT_fno_application_extension, false))
5441 CmdArgs.push_back("-fapplication-extension");
5442
Reid Klecknerc542d372014-06-27 17:02:02 +00005443 // Handle GCC-style exception args.
5444 if (!C.getDriver().IsCLMode())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005445 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
5446 CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00005447
Tim Northovere931f9f2015-10-30 16:30:41 +00005448 if (getToolChain().UseSjLjExceptions(Args))
John McCallb5f652e2011-06-22 00:53:57 +00005449 CmdArgs.push_back("-fsjlj-exceptions");
5450
5451 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00005452 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5453 options::OPT_fno_assume_sane_operator_new))
5454 CmdArgs.push_back("-fno-assume-sane-operator-new");
5455
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00005456 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
5457 // most platforms.
5458 if (Args.hasFlag(options::OPT_fsized_deallocation,
5459 options::OPT_fno_sized_deallocation, false))
5460 CmdArgs.push_back("-fsized-deallocation");
5461
Daniel Dunbar34d7a992010-04-27 15:34:57 +00005462 // -fconstant-cfstrings is default, and may be subject to argument translation
5463 // on Darwin.
5464 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
5465 options::OPT_fno_constant_cfstrings) ||
5466 !Args.hasFlag(options::OPT_mconstant_cfstrings,
5467 options::OPT_mno_constant_cfstrings))
5468 CmdArgs.push_back("-fno-constant-cfstrings");
5469
John Thompsoned4e2952009-11-05 20:14:16 +00005470 // -fshort-wchar default varies depending on platform; only
5471 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00005472 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
5473 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00005474 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00005475
Hans Wennborg28c96312013-07-31 23:39:13 +00005476 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005477 if (Args.hasFlag(options::OPT_fpascal_strings,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005478 options::OPT_fno_pascal_strings, false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00005479 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00005480
Daniel Dunbar096ed292011-10-05 21:04:55 +00005481 // Honor -fpack-struct= and -fpack-struct, if given. Note that
5482 // -fno-pack-struct doesn't apply to -fpack-struct=.
5483 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00005484 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00005485 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00005486 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00005487 } else if (Args.hasFlag(options::OPT_fpack_struct,
5488 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00005489 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00005490 }
5491
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00005492 // Handle -fmax-type-align=N and -fno-type-align
5493 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
5494 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
5495 if (!SkipMaxTypeAlign) {
5496 std::string MaxTypeAlignStr = "-fmax-type-align=";
5497 MaxTypeAlignStr += A->getValue();
5498 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5499 }
5500 } else if (getToolChain().getTriple().isOSDarwin()) {
5501 if (!SkipMaxTypeAlign) {
5502 std::string MaxTypeAlignStr = "-fmax-type-align=16";
5503 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5504 }
5505 }
5506
John Brawna7b4ec02015-08-10 11:11:28 +00005507 // -fcommon is the default unless compiling kernel code or the target says so
5508 bool NoCommonDefault =
5509 KernelOrKext || isNoCommonDefault(getToolChain().getTriple());
5510 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
5511 !NoCommonDefault))
Daniel Dunbard18049a2009-04-07 21:16:11 +00005512 CmdArgs.push_back("-fno-common");
5513
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005514 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00005515 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00005516 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005517 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005518 D.Diag(diag::warn_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005519 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
Daniel Dunbar2edd9232009-04-15 02:37:43 +00005520
Daniel Dunbar6358d682010-10-15 22:30:42 +00005521 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005522 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005523 D.Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005524 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
Daniel Dunbar6358d682010-10-15 22:30:42 +00005525
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00005526 // -finput_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005527 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
5528 StringRef value = inputCharset->getValue();
5529 if (value != "UTF-8")
5530 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
5531 << value;
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00005532 }
5533
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00005534 // -fexec_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005535 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
5536 StringRef value = execCharset->getValue();
5537 if (value != "UTF-8")
5538 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
5539 << value;
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00005540 }
5541
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00005542 // -fcaret-diagnostics is default.
5543 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
5544 options::OPT_fno_caret_diagnostics, true))
5545 CmdArgs.push_back("-fno-caret-diagnostics");
5546
Daniel Dunbar8281bde2009-04-19 21:09:34 +00005547 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00005548 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00005549 options::OPT_fno_diagnostics_fixit_info))
5550 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005551
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005552 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00005553 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005554 options::OPT_fno_diagnostics_show_option))
5555 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005556
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005557 if (const Arg *A =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005558 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005559 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00005560 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005561 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005562
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005563 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
Douglas Gregor643c9222011-05-21 17:07:29 +00005564 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00005565 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00005566 }
5567
Chandler Carruthb6766f02011-03-27 01:50:55 +00005568 if (Arg *A = Args.getLastArg(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005569 options::OPT_fdiagnostics_show_note_include_stack,
5570 options::OPT_fno_diagnostics_show_note_include_stack)) {
Chandler Carruthb6766f02011-03-27 01:50:55 +00005571 if (A->getOption().matches(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005572 options::OPT_fdiagnostics_show_note_include_stack))
Chandler Carruthb6766f02011-03-27 01:50:55 +00005573 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
5574 else
5575 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
5576 }
5577
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005578 // Color diagnostics are the default, unless the terminal doesn't support
5579 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00005580 // Support both clang's -f[no-]color-diagnostics and gcc's
5581 // -f[no-]diagnostics-colors[=never|always|auto].
5582 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005583 for (const auto &Arg : Args) {
5584 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00005585 if (!O.matches(options::OPT_fcolor_diagnostics) &&
5586 !O.matches(options::OPT_fdiagnostics_color) &&
5587 !O.matches(options::OPT_fno_color_diagnostics) &&
5588 !O.matches(options::OPT_fno_diagnostics_color) &&
5589 !O.matches(options::OPT_fdiagnostics_color_EQ))
5590 continue;
5591
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005592 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00005593 if (O.matches(options::OPT_fcolor_diagnostics) ||
5594 O.matches(options::OPT_fdiagnostics_color)) {
5595 ShowColors = Colors_On;
5596 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
5597 O.matches(options::OPT_fno_diagnostics_color)) {
5598 ShowColors = Colors_Off;
5599 } else {
5600 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005601 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00005602 if (value == "always")
5603 ShowColors = Colors_On;
5604 else if (value == "never")
5605 ShowColors = Colors_Off;
5606 else if (value == "auto")
5607 ShowColors = Colors_Auto;
5608 else
5609 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005610 << ("-fdiagnostics-color=" + value).str();
Nico Weber7e2da792013-04-17 21:52:44 +00005611 }
5612 }
5613 if (ShowColors == Colors_On ||
5614 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005615 CmdArgs.push_back("-fcolor-diagnostics");
5616
Nico Rieck7857d462013-09-11 00:38:02 +00005617 if (Args.hasArg(options::OPT_fansi_escape_codes))
5618 CmdArgs.push_back("-fansi-escape-codes");
5619
Daniel Dunbardb097022009-06-08 21:13:54 +00005620 if (!Args.hasFlag(options::OPT_fshow_source_location,
5621 options::OPT_fno_show_source_location))
5622 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005623
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005624 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
Douglas Gregor643c9222011-05-21 17:07:29 +00005625 true))
5626 CmdArgs.push_back("-fno-show-column");
5627
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00005628 if (!Args.hasFlag(options::OPT_fspell_checking,
5629 options::OPT_fno_spell_checking))
5630 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005631
Chad Rosierc8e56e82012-12-05 21:08:21 +00005632 // -fno-asm-blocks is default.
5633 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5634 false))
5635 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00005636
Steven Wucb0d13f2015-01-16 23:05:28 +00005637 // -fgnu-inline-asm is default.
5638 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5639 options::OPT_fno_gnu_inline_asm, true))
5640 CmdArgs.push_back("-fno-gnu-inline-asm");
5641
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00005642 // Enable vectorization per default according to the optimization level
5643 // selected. For optimization levels that want vectorization we use the alias
5644 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005645 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005646 OptSpecifier VectorizeAliasOption =
5647 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00005648 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00005649 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005650 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005651
Chad Rosier136d67d2014-04-28 19:30:57 +00005652 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005653 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005654 OptSpecifier SLPVectAliasOption =
5655 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
Chad Rosier136d67d2014-04-28 19:30:57 +00005656 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005657 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00005658 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00005659
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005660 // -fno-slp-vectorize-aggressive is default.
5661 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00005662 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005663 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005664
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00005665 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
5666 A->render(Args, CmdArgs);
5667
Filipe Cabecinhasab731f72016-05-12 16:51:36 +00005668 if (Arg *A = Args.getLastArg(
5669 options::OPT_fsanitize_undefined_strip_path_components_EQ))
5670 A->render(Args, CmdArgs);
5671
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005672 // -fdollars-in-identifiers default varies depending on platform and
5673 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00005674 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005675 options::OPT_fno_dollars_in_identifiers)) {
5676 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005677 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005678 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005679 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005680 }
5681
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005682 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
5683 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00005684 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005685 options::OPT_fno_unit_at_a_time)) {
5686 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005687 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005688 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005689
Eli Friedman055c9702011-11-02 01:53:16 +00005690 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5691 options::OPT_fno_apple_pragma_pack, false))
5692 CmdArgs.push_back("-fapple-pragma-pack");
5693
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005694 // le32-specific flags:
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005695 // -fno-math-builtin: clang should not convert math builtins to intrinsics
5696 // by default.
Chad Rosierf662fb32016-01-26 16:16:53 +00005697 if (getToolChain().getArch() == llvm::Triple::le32) {
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005698 CmdArgs.push_back("-fno-math-builtin");
Chad Rosierf662fb32016-01-26 16:16:53 +00005699 }
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005700
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005701// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
5702//
Chad Rosier38fd54e2016-01-26 15:46:29 +00005703// FIXME: Now that PR4941 has been fixed this can be enabled.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005704#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00005705 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005706 (getToolChain().getArch() == llvm::Triple::arm ||
5707 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005708 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
5709 CmdArgs.push_back("-fno-builtin-strcat");
5710 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
5711 CmdArgs.push_back("-fno-builtin-strcpy");
5712 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005713#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005714
Justin Bognera88f0122014-06-20 22:59:50 +00005715 // Enable rewrite includes if the user's asked for it or if we're generating
5716 // diagnostics.
5717 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
5718 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00005719 if (Args.hasFlag(options::OPT_frewrite_includes,
5720 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00005721 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00005722 CmdArgs.push_back("-frewrite-includes");
5723
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005724 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00005725 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005726 options::OPT_traditional_cpp)) {
5727 if (isa<PreprocessJobAction>(JA))
5728 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005729 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005730 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005731 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005732
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005733 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00005734 Args.AddLastArg(CmdArgs, options::OPT_dD);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005735
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005736 // Handle serialized diagnostics.
5737 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5738 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00005739 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005740 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005741
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00005742 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5743 CmdArgs.push_back("-fretain-comments-from-system-headers");
5744
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005745 // Forward -fcomment-block-commands to -cc1.
5746 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00005747 // Forward -fparse-all-comments to -cc1.
5748 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005749
John Brawnad31ace2015-09-23 13:55:40 +00005750 // Turn -fplugin=name.so into -load name.so
5751 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5752 CmdArgs.push_back("-load");
5753 CmdArgs.push_back(A->getValue());
5754 A->claim();
5755 }
5756
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005757 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
5758 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005759 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Sean Silva14facf32015-06-09 01:57:17 +00005760 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
5761 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00005762
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005763 // We translate this by hand to the -cc1 argument, since nightly test uses
5764 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00005765 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005766 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00005767 } else
Sean Silva14facf32015-06-09 01:57:17 +00005768 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005769 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005770
Bob Wilson23a55f12014-12-21 07:00:00 +00005771 // With -save-temps, we want to save the unoptimized bitcode output from the
Steven Wu546a1962015-07-17 20:09:56 +00005772 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated
5773 // by the frontend.
Steven Wu27fb5222016-05-11 16:26:03 +00005774 // When -fembed-bitcode is enabled, optimized bitcode is emitted because it
5775 // has slightly different breakdown between stages.
5776 // FIXME: -fembed-bitcode -save-temps will save optimized bitcode instead of
5777 // pristine IR generated by the frontend. Ideally, a new compile action should
5778 // be added so both IR can be captured.
5779 if (C.getDriver().isSaveTempsEnabled() &&
5780 !C.getDriver().embedBitcodeEnabled() && isa<CompileJobAction>(JA))
Steven Wu546a1962015-07-17 20:09:56 +00005781 CmdArgs.push_back("-disable-llvm-passes");
Bob Wilson23a55f12014-12-21 07:00:00 +00005782
Daniel Dunbard67a3222009-03-30 06:36:42 +00005783 if (Output.getType() == types::TY_Dependencies) {
5784 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005785 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005786 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005787 CmdArgs.push_back(Output.getFilename());
5788 } else {
5789 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005790 }
5791
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005792 addDashXForInput(Args, Input, CmdArgs);
Ben Langmuir2cb4a782014-02-05 22:21:15 +00005793
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005794 if (Input.isFilename())
5795 CmdArgs.push_back(Input.getFilename());
5796 else
5797 Input.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005798
Chris Lattnere9d7d782009-11-03 19:50:27 +00005799 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5800
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005801 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005802
5803 // Optionally embed the -cc1 level arguments into the debug info, for build
5804 // analysis.
5805 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00005806 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005807 for (const auto &Arg : Args)
5808 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005809
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005810 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005811 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005812 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005813 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005814 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005815 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005816 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005817 }
5818 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005819 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005820 }
5821
Eric Christopherd3804002013-02-22 20:12:52 +00005822 // Add the split debug info name to the command lines here so we
5823 // can propagate it to the backend.
David Blaikiece3e7a62015-07-30 21:42:22 +00005824 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005825 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5826 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00005827 const char *SplitDwarfOut;
5828 if (SplitDwarf) {
5829 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00005830 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00005831 CmdArgs.push_back(SplitDwarfOut);
5832 }
5833
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005834 // Host-side cuda compilation receives device-side outputs as Inputs[1...].
5835 // Include them with -fcuda-include-gpubinary.
5836 if (IsCuda && Inputs.size() > 1)
Artem Belevich5bde4e02015-07-20 20:02:54 +00005837 for (auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005838 CmdArgs.push_back("-fcuda-include-gpubinary");
Artem Belevich5bde4e02015-07-20 20:02:54 +00005839 CmdArgs.push_back(I->getFilename());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005840 }
5841
Peter Collingbourne3afb2662016-04-28 17:09:37 +00005842 bool WholeProgramVTables =
5843 Args.hasFlag(options::OPT_fwhole_program_vtables,
5844 options::OPT_fno_whole_program_vtables, false);
5845 if (WholeProgramVTables) {
5846 if (!D.isUsingLTO())
5847 D.Diag(diag::err_drv_argument_only_allowed_with)
5848 << "-fwhole-program-vtables"
5849 << "-flto";
5850 CmdArgs.push_back("-fwhole-program-vtables");
5851 }
5852
Eric Christopherd3804002013-02-22 20:12:52 +00005853 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00005854 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00005855 Output.getType() == types::TY_Object &&
5856 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00005857 auto CLCommand =
5858 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
Justin Bognerd3371d82015-07-17 03:35:54 +00005859 C.addCommand(llvm::make_unique<FallbackCommand>(
5860 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
Nico Weber2ca4be92016-03-01 23:16:44 +00005861 } else if (Args.hasArg(options::OPT__SLASH_fallback) &&
5862 isa<PrecompileJobAction>(JA)) {
5863 // In /fallback builds, run the main compilation even if the pch generation
5864 // fails, so that the main compilation's fallback to cl.exe runs.
5865 C.addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *this, Exec,
5866 CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005867 } else {
Justin Bognerd3371d82015-07-17 03:35:54 +00005868 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005869 }
5870
Eric Christopherf1545832013-02-22 23:50:16 +00005871 // Handle the debug info splitting at object creation time if we're
5872 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00005873 // TODO: Currently only works on linux with newer objcopy.
Eric Christopher0945a642016-03-24 00:34:02 +00005874 if (SplitDwarf && Output.getType() == types::TY_Object)
Eric Christopherd3804002013-02-22 20:12:52 +00005875 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00005876
Roman Divacky178e01602011-02-10 16:52:03 +00005877 if (Arg *A = Args.getLastArg(options::OPT_pg))
5878 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005879 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
5880 << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005881
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005882 // Claim some arguments which clang supports automatically.
5883
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00005884 // -fpch-preprocess is used with gcc to add a special marker in the output to
5885 // include the PCH file. Clang's PTH solution is completely transparent, so we
5886 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005887 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005888
Daniel Dunbar17731772009-03-23 19:03:36 +00005889 // Claim some arguments which clang doesn't support, but we don't
5890 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00005891 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5892 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00005893
Rafael Espindolab0092d72013-09-04 19:37:35 +00005894 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00005895 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005896}
5897
John McCall5fb5df92012-06-20 06:18:46 +00005898/// Add options related to the Objective-C runtime/ABI.
5899///
5900/// Returns true if the runtime is non-fragile.
5901ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
5902 ArgStringList &cmdArgs,
5903 RewriteKind rewriteKind) const {
5904 // Look for the controlling runtime option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005905 Arg *runtimeArg =
5906 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5907 options::OPT_fobjc_runtime_EQ);
John McCall5fb5df92012-06-20 06:18:46 +00005908
5909 // Just forward -fobjc-runtime= to the frontend. This supercedes
5910 // options about fragility.
5911 if (runtimeArg &&
5912 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5913 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00005914 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005915 if (runtime.tryParse(value)) {
5916 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005917 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005918 }
5919
5920 runtimeArg->render(args, cmdArgs);
5921 return runtime;
5922 }
5923
5924 // Otherwise, we'll need the ABI "version". Version numbers are
5925 // slightly confusing for historical reasons:
5926 // 1 - Traditional "fragile" ABI
5927 // 2 - Non-fragile ABI, version 1
5928 // 3 - Non-fragile ABI, version 2
5929 unsigned objcABIVersion = 1;
5930 // If -fobjc-abi-version= is present, use that to set the version.
5931 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005932 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005933 if (value == "1")
5934 objcABIVersion = 1;
5935 else if (value == "2")
5936 objcABIVersion = 2;
5937 else if (value == "3")
5938 objcABIVersion = 3;
5939 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005940 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
John McCall5fb5df92012-06-20 06:18:46 +00005941 } else {
5942 // Otherwise, determine if we are using the non-fragile ABI.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005943 bool nonFragileABIIsDefault =
5944 (rewriteKind == RK_NonFragile ||
5945 (rewriteKind == RK_None &&
5946 getToolChain().IsObjCNonFragileABIDefault()));
John McCall5fb5df92012-06-20 06:18:46 +00005947 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5948 options::OPT_fno_objc_nonfragile_abi,
5949 nonFragileABIIsDefault)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005950// Determine the non-fragile ABI version to use.
John McCall5fb5df92012-06-20 06:18:46 +00005951#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5952 unsigned nonFragileABIVersion = 1;
5953#else
5954 unsigned nonFragileABIVersion = 2;
5955#endif
5956
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005957 if (Arg *abiArg =
5958 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005959 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005960 if (value == "1")
5961 nonFragileABIVersion = 1;
5962 else if (value == "2")
5963 nonFragileABIVersion = 2;
5964 else
5965 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005966 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005967 }
5968
5969 objcABIVersion = 1 + nonFragileABIVersion;
5970 } else {
5971 objcABIVersion = 1;
5972 }
5973 }
5974
5975 // We don't actually care about the ABI version other than whether
5976 // it's non-fragile.
5977 bool isNonFragile = objcABIVersion != 1;
5978
5979 // If we have no runtime argument, ask the toolchain for its default runtime.
5980 // However, the rewriter only really supports the Mac runtime, so assume that.
5981 ObjCRuntime runtime;
5982 if (!runtimeArg) {
5983 switch (rewriteKind) {
5984 case RK_None:
5985 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5986 break;
5987 case RK_Fragile:
5988 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5989 break;
5990 case RK_NonFragile:
5991 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5992 break;
5993 }
5994
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005995 // -fnext-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005996 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5997 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005998 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00005999 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
6000
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006001 // Otherwise, build for a generic macosx port.
John McCall5fb5df92012-06-20 06:18:46 +00006002 } else {
6003 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
6004 }
6005
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006006 // -fgnu-runtime
John McCall5fb5df92012-06-20 06:18:46 +00006007 } else {
6008 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
Eric Christopherbce27882015-12-28 21:57:05 +00006009 // Legacy behaviour is to target the gnustep runtime if we are in
David Chisnall314896c2012-07-04 10:37:03 +00006010 // non-fragile mode or the GCC runtime in fragile mode.
6011 if (isNonFragile)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006012 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6));
David Chisnall314896c2012-07-04 10:37:03 +00006013 else
6014 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00006015 }
6016
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006017 cmdArgs.push_back(
6018 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
John McCall5fb5df92012-06-20 06:18:46 +00006019 return runtime;
6020}
6021
Reid Klecknerc542d372014-06-27 17:02:02 +00006022static bool maybeConsumeDash(const std::string &EH, size_t &I) {
6023 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
6024 I += HaveDash;
6025 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00006026}
Reid Klecknerc542d372014-06-27 17:02:02 +00006027
Benjamin Kramere003ca22015-10-28 13:54:16 +00006028namespace {
Reid Klecknerc542d372014-06-27 17:02:02 +00006029struct EHFlags {
David Majnemerb8809092016-02-20 09:23:44 +00006030 bool Synch = false;
6031 bool Asynch = false;
6032 bool NoUnwindC = false;
Reid Klecknerc542d372014-06-27 17:02:02 +00006033};
Benjamin Kramere003ca22015-10-28 13:54:16 +00006034} // end anonymous namespace
Reid Klecknerc542d372014-06-27 17:02:02 +00006035
6036/// /EH controls whether to run destructor cleanups when exceptions are
6037/// thrown. There are three modifiers:
6038/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
6039/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
6040/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
David Majnemer960813e2016-02-20 09:23:47 +00006041/// - c: Assume that extern "C" functions are implicitly nounwind.
Reid Klecknerc542d372014-06-27 17:02:02 +00006042/// The default is /EHs-c-, meaning cleanups are disabled.
6043static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
6044 EHFlags EH;
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00006045
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006046 std::vector<std::string> EHArgs =
6047 Args.getAllArgValues(options::OPT__SLASH_EH);
Reid Klecknerc542d372014-06-27 17:02:02 +00006048 for (auto EHVal : EHArgs) {
6049 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
6050 switch (EHVal[I]) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006051 case 'a':
6052 EH.Asynch = maybeConsumeDash(EHVal, I);
David Majnemer387fccd2016-02-29 01:40:30 +00006053 if (EH.Asynch)
6054 EH.Synch = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006055 continue;
6056 case 'c':
David Majnemerb8809092016-02-20 09:23:44 +00006057 EH.NoUnwindC = maybeConsumeDash(EHVal, I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006058 continue;
6059 case 's':
6060 EH.Synch = maybeConsumeDash(EHVal, I);
David Majnemer387fccd2016-02-29 01:40:30 +00006061 if (EH.Synch)
6062 EH.Asynch = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006063 continue;
6064 default:
6065 break;
Reid Klecknerc542d372014-06-27 17:02:02 +00006066 }
6067 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
6068 break;
6069 }
6070 }
David Majnemerb8809092016-02-20 09:23:44 +00006071 // The /GX, /GX- flags are only processed if there are not /EH flags.
David Majnemera7bdc5a2016-02-22 17:44:51 +00006072 // The default is that /GX is not specified.
David Majnemerb8809092016-02-20 09:23:44 +00006073 if (EHArgs.empty() &&
David Majnemera7bdc5a2016-02-22 17:44:51 +00006074 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
6075 /*default=*/false)) {
David Majnemerb8809092016-02-20 09:23:44 +00006076 EH.Synch = true;
6077 EH.NoUnwindC = true;
6078 }
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00006079
Reid Klecknerc542d372014-06-27 17:02:02 +00006080 return EH;
6081}
6082
David Majnemercd5855e2016-02-29 01:40:36 +00006083void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
6084 ArgStringList &CmdArgs,
Benjamin Kramer8c305922016-02-02 11:06:51 +00006085 codegenoptions::DebugInfoKind *DebugInfoKind,
Douglas Katzman3459ce22015-10-08 04:24:12 +00006086 bool *EmitCodeView) const {
Hans Wennborg75958c42013-08-08 00:17:41 +00006087 unsigned RTOptionID = options::OPT__SLASH_MT;
6088
Hans Wennborgf1a74252013-09-10 20:18:04 +00006089 if (Args.hasArg(options::OPT__SLASH_LDd))
6090 // The /LDd option implies /MTd. The dependent lib part can be overridden,
6091 // but defining _DEBUG is sticky.
6092 RTOptionID = options::OPT__SLASH_MTd;
6093
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00006094 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00006095 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00006096
David Majnemere2afb472015-07-24 06:49:13 +00006097 StringRef FlagForCRT;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006098 switch (RTOptionID) {
6099 case options::OPT__SLASH_MD:
6100 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00006101 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006102 CmdArgs.push_back("-D_MT");
6103 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00006104 FlagForCRT = "--dependent-lib=msvcrt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006105 break;
6106 case options::OPT__SLASH_MDd:
6107 CmdArgs.push_back("-D_DEBUG");
6108 CmdArgs.push_back("-D_MT");
6109 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00006110 FlagForCRT = "--dependent-lib=msvcrtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006111 break;
6112 case options::OPT__SLASH_MT:
6113 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00006114 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006115 CmdArgs.push_back("-D_MT");
Peter Collingbourne3afb2662016-04-28 17:09:37 +00006116 CmdArgs.push_back("-flto-visibility-public-std");
David Majnemere2afb472015-07-24 06:49:13 +00006117 FlagForCRT = "--dependent-lib=libcmt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006118 break;
6119 case options::OPT__SLASH_MTd:
6120 CmdArgs.push_back("-D_DEBUG");
6121 CmdArgs.push_back("-D_MT");
Peter Collingbourne3afb2662016-04-28 17:09:37 +00006122 CmdArgs.push_back("-flto-visibility-public-std");
David Majnemere2afb472015-07-24 06:49:13 +00006123 FlagForCRT = "--dependent-lib=libcmtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006124 break;
6125 default:
6126 llvm_unreachable("Unexpected option ID.");
Hans Wennborg75958c42013-08-08 00:17:41 +00006127 }
6128
David Majnemere2afb472015-07-24 06:49:13 +00006129 if (Args.hasArg(options::OPT__SLASH_Zl)) {
6130 CmdArgs.push_back("-D_VC_NODEFAULTLIB");
6131 } else {
6132 CmdArgs.push_back(FlagForCRT.data());
6133
6134 // This provides POSIX compatibility (maps 'open' to '_open'), which most
6135 // users want. The /Za flag to cl.exe turns this off, but it's not
6136 // implemented in clang.
6137 CmdArgs.push_back("--dependent-lib=oldnames");
6138 }
Hans Wennborg614f7072013-08-08 19:54:30 +00006139
Hans Wennborg8858a032014-07-21 23:42:07 +00006140 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
6141 // would produce interleaved output, so ignore /showIncludes in such cases.
6142 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
6143 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
6144 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00006145
David Majnemerf6072342014-07-01 22:24:56 +00006146 // This controls whether or not we emit RTTI data for polymorphic types.
6147 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
6148 /*default=*/false))
6149 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00006150
Reid Kleckner124955a2015-08-05 18:51:13 +00006151 // Emit CodeView if -Z7 is present.
Douglas Katzman3459ce22015-10-08 04:24:12 +00006152 *EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
Reid Kleckner9ce06a4a2016-02-10 21:28:38 +00006153 if (*EmitCodeView)
6154 *DebugInfoKind = codegenoptions::LimitedDebugInfo;
Douglas Katzman3459ce22015-10-08 04:24:12 +00006155 if (*EmitCodeView)
Reid Kleckner124955a2015-08-05 18:51:13 +00006156 CmdArgs.push_back("-gcodeview");
6157
Reid Klecknerc542d372014-06-27 17:02:02 +00006158 const Driver &D = getToolChain().getDriver();
6159 EHFlags EH = parseClangCLEHFlags(D, Args);
Reid Klecknerdeeddec2015-02-05 18:56:03 +00006160 if (EH.Synch || EH.Asynch) {
David Majnemercd5855e2016-02-29 01:40:36 +00006161 if (types::isCXX(InputType))
6162 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00006163 CmdArgs.push_back("-fexceptions");
6164 }
David Majnemercd5855e2016-02-29 01:40:36 +00006165 if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
6166 CmdArgs.push_back("-fexternc-nounwind");
Reid Klecknerc542d372014-06-27 17:02:02 +00006167
Hans Wennborge50cec32014-06-13 20:59:54 +00006168 // /EP should expand to -E -P.
6169 if (Args.hasArg(options::OPT__SLASH_EP)) {
6170 CmdArgs.push_back("-E");
6171 CmdArgs.push_back("-P");
6172 }
6173
David Majnemera5b195a2015-02-14 01:35:12 +00006174 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006175 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
6176 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00006177 VolatileOptionID = options::OPT__SLASH_volatile_ms;
6178 else
6179 VolatileOptionID = options::OPT__SLASH_volatile_iso;
6180
6181 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
6182 VolatileOptionID = A->getOption().getID();
6183
6184 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
6185 CmdArgs.push_back("-fms-volatile");
6186
David Majnemer86c318f2014-02-11 21:05:00 +00006187 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
6188 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
6189 if (MostGeneralArg && BestCaseArg)
6190 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6191 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
6192
6193 if (MostGeneralArg) {
6194 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
6195 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
6196 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
6197
6198 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
6199 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
6200 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
6201 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6202 << FirstConflict->getAsString(Args)
6203 << SecondConflict->getAsString(Args);
6204
6205 if (SingleArg)
6206 CmdArgs.push_back("-fms-memptr-rep=single");
6207 else if (MultipleArg)
6208 CmdArgs.push_back("-fms-memptr-rep=multiple");
6209 else
6210 CmdArgs.push_back("-fms-memptr-rep=virtual");
6211 }
6212
Alexey Bataeva7547182016-05-18 09:06:38 +00006213 if (Args.getLastArg(options::OPT__SLASH_Gd))
6214 CmdArgs.push_back("-fdefault-calling-conv=cdecl");
6215 else if (Args.getLastArg(options::OPT__SLASH_Gr))
6216 CmdArgs.push_back("-fdefault-calling-conv=fastcall");
6217 else if (Args.getLastArg(options::OPT__SLASH_Gz))
6218 CmdArgs.push_back("-fdefault-calling-conv=stdcall");
6219 else if (Args.getLastArg(options::OPT__SLASH_Gv))
6220 CmdArgs.push_back("-fdefault-calling-conv=vectorcall");
6221
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00006222 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
6223 A->render(Args, CmdArgs);
6224
Hans Wennborg81f74482013-09-10 01:07:07 +00006225 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
6226 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00006227 if (Args.hasArg(options::OPT__SLASH_fallback))
6228 CmdArgs.push_back("msvc-fallback");
6229 else
6230 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00006231 }
Hans Wennborg75958c42013-08-08 00:17:41 +00006232}
6233
Douglas Katzman95354292015-06-23 20:42:09 +00006234visualstudio::Compiler *Clang::getCLFallback() const {
Hans Wennborg1da044a2014-06-26 19:59:02 +00006235 if (!CLFallback)
Douglas Katzman95354292015-06-23 20:42:09 +00006236 CLFallback.reset(new visualstudio::Compiler(getToolChain()));
Hans Wennborg1da044a2014-06-26 19:59:02 +00006237 return CLFallback.get();
6238}
6239
Daniel Sanders7f933f42015-01-30 17:35:23 +00006240void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
6241 ArgStringList &CmdArgs) const {
6242 StringRef CPUName;
6243 StringRef ABIName;
6244 const llvm::Triple &Triple = getToolChain().getTriple();
6245 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
6246
6247 CmdArgs.push_back("-target-abi");
6248 CmdArgs.push_back(ABIName.data());
6249}
6250
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006251void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006252 const InputInfo &Output, const InputInfoList &Inputs,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006253 const ArgList &Args,
6254 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006255 ArgStringList CmdArgs;
6256
6257 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6258 const InputInfo &Input = Inputs[0];
6259
James Y Knight2db38f32015-08-15 03:45:25 +00006260 std::string TripleStr =
6261 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
6262 const llvm::Triple Triple(TripleStr);
6263
Rafael Espindolacfaadda2010-11-17 22:13:25 +00006264 // Don't warn about "clang -w -c foo.s"
6265 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00006266 // and "clang -emit-llvm -c foo.s"
6267 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00006268
Rafael Espindola577637a2015-01-03 00:06:04 +00006269 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00006270
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006271 // Invoke ourselves in -cc1as mode.
6272 //
6273 // FIXME: Implement custom jobs for internal actions.
6274 CmdArgs.push_back("-cc1as");
6275
6276 // Add the "effective" target triple.
6277 CmdArgs.push_back("-triple");
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006278 CmdArgs.push_back(Args.MakeArgString(TripleStr));
6279
6280 // Set the output mode, we currently only expect to be used as a real
6281 // assembler.
6282 CmdArgs.push_back("-filetype");
6283 CmdArgs.push_back("obj");
6284
Eric Christopher45f2e712012-12-18 00:31:10 +00006285 // Set the main file name, so that debug info works even with
6286 // -save-temps or preprocessed assembly.
6287 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00006288 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00006289
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006290 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00006291 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00006292 if (!CPU.empty()) {
6293 CmdArgs.push_back("-target-cpu");
6294 CmdArgs.push_back(Args.MakeArgString(CPU));
6295 }
6296
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00006297 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00006298 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00006299
Daniel Dunbar1d733e22011-03-17 17:37:29 +00006300 // Ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006301 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006302
Jim Grosbachc78c2bc2015-06-23 18:20:13 +00006303 // Pass along any -I options so we get proper .include search paths.
6304 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
6305
Eric Christopherfc3ee562012-01-10 00:38:01 +00006306 // Determine the original source input.
6307 const Action *SourceAction = &JA;
6308 while (SourceAction->getKind() != Action::InputClass) {
6309 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6310 SourceAction = SourceAction->getInputs()[0];
6311 }
6312
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00006313 // Forward -g and handle debug info related flags, assuming we are dealing
6314 // with an actual assembly file.
Douglas Katzman3103f252016-04-19 18:55:53 +00006315 bool WantDebug = false;
6316 unsigned DwarfVersion = 0;
6317 Args.ClaimAllArgs(options::OPT_g_Group);
6318 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
6319 WantDebug = !A->getOption().matches(options::OPT_g0) &&
6320 !A->getOption().matches(options::OPT_ggdb0);
6321 if (WantDebug)
6322 DwarfVersion = DwarfVersionNum(A->getSpelling());
6323 }
6324 if (DwarfVersion == 0)
6325 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
6326
6327 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo;
6328
Eric Christopherfc3ee562012-01-10 00:38:01 +00006329 if (SourceAction->getType() == types::TY_Asm ||
6330 SourceAction->getType() == types::TY_PP_Asm) {
Douglas Katzman3103f252016-04-19 18:55:53 +00006331 // You might think that it would be ok to set DebugInfoKind outside of
6332 // the guard for source type, however there is a test which asserts
6333 // that some assembler invocation receives no -debug-info-kind,
6334 // and it's not clear whether that test is just overly restrictive.
6335 DebugInfoKind = (WantDebug ? codegenoptions::LimitedDebugInfo
6336 : codegenoptions::NoDebugInfo);
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00006337 // Add the -fdebug-compilation-dir flag if needed.
6338 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00006339
6340 // Set the AT_producer to the clang version when using the integrated
6341 // assembler on assembly source files.
6342 CmdArgs.push_back("-dwarf-debug-producer");
Bruno Cardoso Lopes34c549e2016-05-02 20:20:49 +00006343 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Renato Golina74bbc72015-07-22 15:32:36 +00006344
6345 // And pass along -I options
6346 Args.AddAllArgs(CmdArgs, options::OPT_I);
Eric Christopherfc3ee562012-01-10 00:38:01 +00006347 }
Douglas Katzman3103f252016-04-19 18:55:53 +00006348 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
6349 llvm::DebuggerKind::Default);
Kevin Enderby292dc082011-12-22 19:31:58 +00006350
James Y Knight5bdf7ab2015-08-19 15:12:02 +00006351 // Handle -fPIC et al -- the relocation-model affects the assembler
6352 // for some targets.
6353 llvm::Reloc::Model RelocationModel;
6354 unsigned PICLevel;
6355 bool IsPIE;
6356 std::tie(RelocationModel, PICLevel, IsPIE) =
6357 ParsePICArgs(getToolChain(), Triple, Args);
6358
6359 const char *RMName = RelocationModelName(RelocationModel);
6360 if (RMName) {
6361 CmdArgs.push_back("-mrelocation-model");
6362 CmdArgs.push_back(RMName);
6363 }
6364
Kevin Enderby292dc082011-12-22 19:31:58 +00006365 // Optionally embed the -cc1as level arguments into the debug info, for build
6366 // analysis.
6367 if (getToolChain().UseDwarfDebugFlags()) {
6368 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006369 for (const auto &Arg : Args)
6370 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00006371
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00006372 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00006373 const char *Exec = getToolChain().getDriver().getClangProgramPath();
6374 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00006375 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00006376 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00006377 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00006378 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00006379 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00006380 }
6381 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00006382 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00006383 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006384
6385 // FIXME: Add -static support, once we have it.
6386
Daniel Sanders7f933f42015-01-30 17:35:23 +00006387 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006388 switch (getToolChain().getArch()) {
Daniel Sanders7f933f42015-01-30 17:35:23 +00006389 default:
6390 break;
6391
6392 case llvm::Triple::mips:
6393 case llvm::Triple::mipsel:
6394 case llvm::Triple::mips64:
6395 case llvm::Triple::mips64el:
6396 AddMIPSTargetArgs(Args, CmdArgs);
6397 break;
6398 }
6399
David Blaikie372d9502014-01-17 03:17:40 +00006400 // Consume all the warning flags. Usually this would be handled more
6401 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
6402 // doesn't handle that so rather than warning about unused flags that are
6403 // actually used, we'll lie by omission instead.
6404 // FIXME: Stop lying and consume only the appropriate driver flags
Eric Christopher5d1caa52016-01-07 02:00:55 +00006405 Args.ClaimAllArgs(options::OPT_W_Group);
David Blaikie372d9502014-01-17 03:17:40 +00006406
David Blaikie9260ed62013-07-25 21:19:01 +00006407 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
6408 getToolChain().getDriver());
6409
Daniel Dunbar252e8f92011-04-29 17:53:18 +00006410 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006411
6412 assert(Output.isFilename() && "Unexpected lipo output.");
6413 CmdArgs.push_back("-o");
6414 CmdArgs.push_back(Output.getFilename());
6415
Daniel Dunbarb440f562010-08-02 02:38:21 +00006416 assert(Input.isFilename() && "Invalid input.");
6417 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006418
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00006419 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Justin Bognerd3371d82015-07-17 03:35:54 +00006420 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christophera75018a2013-04-10 21:30:40 +00006421
6422 // Handle the debug info splitting at object creation time if we're
6423 // creating an object.
6424 // TODO: Currently only works on linux with newer objcopy.
6425 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00006426 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00006427 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00006428 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00006429}
6430
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006431void GnuTool::anchor() {}
6432
Daniel Dunbara3246a02009-03-18 08:07:30 +00006433void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00006434 const InputInfo &Output,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006435 const InputInfoList &Inputs, const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00006436 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006437 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00006438 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006439
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006440 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00006441 if (forwardToGCC(A->getOption())) {
Eric Christopher3f07d852016-01-07 09:03:42 +00006442 // It is unfortunate that we have to claim here, as this means
6443 // we will basically never report anything interesting for
6444 // platforms using a generic gcc, even if we are just using gcc
6445 // to get to the assembler.
6446 A->claim();
6447
Daniel Dunbar939c1212010-08-03 16:14:14 +00006448 // Don't forward any -g arguments to assembly steps.
6449 if (isa<AssembleJobAction>(JA) &&
6450 A->getOption().matches(options::OPT_g_Group))
6451 continue;
6452
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00006453 // Don't forward any -W arguments to assembly and link steps.
6454 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
6455 A->getOption().matches(options::OPT_W_Group))
6456 continue;
6457
Daniel Dunbara2aedc62009-03-18 10:01:51 +00006458 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00006459 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006460 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006461
Daniel Dunbar4e295052010-01-25 22:35:08 +00006462 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00006463
6464 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006465 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006466 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00006467 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006468 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00006469 }
6470
Daniel Dunbar5716d872009-05-02 21:41:52 +00006471 // Try to force gcc to match the tool chain we want, if we recognize
6472 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00006473 //
6474 // FIXME: The triple class should directly provide the information we want
6475 // here.
Douglas Katzman38857552015-08-20 18:32:26 +00006476 switch (getToolChain().getArch()) {
6477 default:
6478 break;
6479 case llvm::Triple::x86:
6480 case llvm::Triple::ppc:
Daniel Dunbar5716d872009-05-02 21:41:52 +00006481 CmdArgs.push_back("-m32");
Douglas Katzman38857552015-08-20 18:32:26 +00006482 break;
6483 case llvm::Triple::x86_64:
6484 case llvm::Triple::ppc64:
6485 case llvm::Triple::ppc64le:
Daniel Dunbar5716d872009-05-02 21:41:52 +00006486 CmdArgs.push_back("-m64");
Douglas Katzman38857552015-08-20 18:32:26 +00006487 break;
6488 case llvm::Triple::sparcel:
6489 CmdArgs.push_back("-EL");
6490 break;
6491 }
Daniel Dunbar5716d872009-05-02 21:41:52 +00006492
Daniel Dunbarb440f562010-08-02 02:38:21 +00006493 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006494 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006495 CmdArgs.push_back(Output.getFilename());
6496 } else {
6497 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00006498 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006499 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006500
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006501 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00006502
6503 // Only pass -x if gcc will understand it; otherwise hope gcc
6504 // understands the suffix correctly. The main use case this would go
6505 // wrong in is for linker inputs if they happened to have an odd
6506 // suffix; really the only way to get this to happen is a command
6507 // like '-x foobar a.c' which will treat a.c like a linker input.
6508 //
6509 // FIXME: For the linker case specifically, can we safely convert
6510 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006511 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00006512 // Don't try to pass LLVM or AST inputs to a generic gcc.
Eric Christopherc1984072015-12-08 02:10:19 +00006513 if (types::isLLVMIR(II.getType()))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006514 D.Diag(diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006515 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00006516 else if (II.getType() == types::TY_AST)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006517 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00006518 else if (II.getType() == types::TY_ModuleFile)
6519 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006520 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00006521
Daniel Dunbara3246a02009-03-18 08:07:30 +00006522 if (types::canTypeBeUserSpecified(II.getType())) {
6523 CmdArgs.push_back("-x");
6524 CmdArgs.push_back(types::getTypeName(II.getType()));
6525 }
6526
Daniel Dunbarb440f562010-08-02 02:38:21 +00006527 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006528 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00006529 else {
6530 const Arg &A = II.getInputArg();
6531
6532 // Reverse translate some rewritten options.
6533 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
6534 CmdArgs.push_back("-lstdc++");
6535 continue;
6536 }
6537
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00006538 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00006539 A.render(Args, CmdArgs);
6540 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00006541 }
6542
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006543 const std::string customGCCName = D.getCCCGenericGCCName();
6544 const char *GCCName;
6545 if (!customGCCName.empty())
6546 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00006547 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006548 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00006549 } else
6550 GCCName = "gcc";
6551
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006552 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00006553 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006554}
6555
Douglas Katzman95354292015-06-23 20:42:09 +00006556void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
6557 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006558 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006559}
6560
Douglas Katzman95354292015-06-23 20:42:09 +00006561void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
6562 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00006563 const Driver &D = getToolChain().getDriver();
6564
Eric Christophercc7ff502015-01-29 00:56:17 +00006565 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00006566 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00006567 case types::TY_LLVM_IR:
6568 case types::TY_LTO_IR:
6569 case types::TY_LLVM_BC:
6570 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00006571 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00006572 break;
Eric Christopher29a50bc2016-01-06 07:24:45 +00006573 // We assume we've got an "integrated" assembler in that gcc will produce an
6574 // object file itself.
6575 case types::TY_Object:
6576 CmdArgs.push_back("-c");
6577 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00006578 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00006579 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00006580 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00006581 case types::TY_Nothing:
6582 CmdArgs.push_back("-fsyntax-only");
6583 break;
6584 default:
6585 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00006586 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00006587}
6588
Douglas Katzman95354292015-06-23 20:42:09 +00006589void gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
6590 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00006591 // The types are (hopefully) good enough.
6592}
6593
Tony Linthicum76329bf2011-12-12 21:14:55 +00006594// Hexagon tools start.
Douglas Katzman95354292015-06-23 20:42:09 +00006595void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006596 ArgStringList &CmdArgs) const {
6597}
6598
Douglas Katzman95354292015-06-23 20:42:09 +00006599void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6600 const InputInfo &Output,
6601 const InputInfoList &Inputs,
6602 const ArgList &Args,
6603 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00006604 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00006605
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006606 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
6607 const Driver &D = HTC.getDriver();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006608 ArgStringList CmdArgs;
6609
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006610 std::string MArchString = "-march=hexagon";
6611 CmdArgs.push_back(Args.MakeArgString(MArchString));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006612
6613 RenderExtraToolArgs(JA, CmdArgs);
6614
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006615 std::string AsName = "hexagon-llvm-mc";
6616 std::string MCpuString = "-mcpu=hexagon" +
6617 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
6618 CmdArgs.push_back("-filetype=obj");
6619 CmdArgs.push_back(Args.MakeArgString(MCpuString));
6620
Tony Linthicum76329bf2011-12-12 21:14:55 +00006621 if (Output.isFilename()) {
6622 CmdArgs.push_back("-o");
6623 CmdArgs.push_back(Output.getFilename());
6624 } else {
6625 assert(Output.isNothing() && "Unexpected output");
6626 CmdArgs.push_back("-fsyntax-only");
6627 }
6628
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006629 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
6630 std::string N = llvm::utostr(G.getValue());
6631 CmdArgs.push_back(Args.MakeArgString(std::string("-gpsize=") + N));
6632 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006633
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006634 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Matthew Curtise5df3812012-12-07 17:23:04 +00006635
Tony Linthicum76329bf2011-12-12 21:14:55 +00006636 // Only pass -x if gcc will understand it; otherwise hope gcc
6637 // understands the suffix correctly. The main use case this would go
6638 // wrong in is for linker inputs if they happened to have an odd
6639 // suffix; really the only way to get this to happen is a command
6640 // like '-x foobar a.c' which will treat a.c like a linker input.
6641 //
6642 // FIXME: For the linker case specifically, can we safely convert
6643 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006644 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006645 // Don't try to pass LLVM or AST inputs to a generic gcc.
Eric Christopherc1984072015-12-08 02:10:19 +00006646 if (types::isLLVMIR(II.getType()))
Tony Linthicum76329bf2011-12-12 21:14:55 +00006647 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006648 << HTC.getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006649 else if (II.getType() == types::TY_AST)
6650 D.Diag(clang::diag::err_drv_no_ast_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006651 << HTC.getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00006652 else if (II.getType() == types::TY_ModuleFile)
6653 D.Diag(diag::err_drv_no_module_support)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006654 << HTC.getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006655
6656 if (II.isFilename())
6657 CmdArgs.push_back(II.getFilename());
6658 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006659 // Don't render as input, we need gcc to do the translations.
Eric Christopherb0a44f72015-12-08 01:59:51 +00006660 // FIXME: What is this?
Tony Linthicum76329bf2011-12-12 21:14:55 +00006661 II.getInputArg().render(Args, CmdArgs);
6662 }
6663
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006664 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
Justin Bognerd3371d82015-07-17 03:35:54 +00006665 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006666}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006667
Douglas Katzman95354292015-06-23 20:42:09 +00006668void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
6669 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006670}
6671
Douglas Katzman54366072015-07-27 16:53:08 +00006672static void
6673constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006674 const toolchains::HexagonToolChain &HTC,
Douglas Katzman54366072015-07-27 16:53:08 +00006675 const InputInfo &Output, const InputInfoList &Inputs,
6676 const ArgList &Args, ArgStringList &CmdArgs,
6677 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006678
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006679 const Driver &D = HTC.getDriver();
Matthew Curtise689b052012-12-06 15:46:07 +00006680
Matthew Curtise689b052012-12-06 15:46:07 +00006681 //----------------------------------------------------------------------------
6682 //
6683 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006684 bool IsStatic = Args.hasArg(options::OPT_static);
6685 bool IsShared = Args.hasArg(options::OPT_shared);
6686 bool IsPIE = Args.hasArg(options::OPT_pie);
6687 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
6688 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
6689 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
6690 bool UseG0 = false;
6691 bool UseShared = IsShared && !IsStatic;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006692
Matthew Curtise689b052012-12-06 15:46:07 +00006693 //----------------------------------------------------------------------------
6694 // Silence warnings for various options
6695 //----------------------------------------------------------------------------
Matthew Curtise689b052012-12-06 15:46:07 +00006696 Args.ClaimAllArgs(options::OPT_g_Group);
6697 Args.ClaimAllArgs(options::OPT_emit_llvm);
6698 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
6699 // handled somewhere else.
6700 Args.ClaimAllArgs(options::OPT_static_libgcc);
6701
6702 //----------------------------------------------------------------------------
6703 //
6704 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006705 if (Args.hasArg(options::OPT_s))
6706 CmdArgs.push_back("-s");
6707
6708 if (Args.hasArg(options::OPT_r))
6709 CmdArgs.push_back("-r");
6710
6711 for (const auto &Opt : HTC.ExtraOpts)
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006712 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006713
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006714 CmdArgs.push_back("-march=hexagon");
6715 std::string CpuVer =
6716 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
6717 std::string MCpuString = "-mcpu=hexagon" + CpuVer;
6718 CmdArgs.push_back(Args.MakeArgString(MCpuString));
Sebastian Pop86500282012-01-13 20:37:10 +00006719
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006720 if (IsShared) {
Matthew Curtise689b052012-12-06 15:46:07 +00006721 CmdArgs.push_back("-shared");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006722 // The following should be the default, but doing as hexagon-gcc does.
6723 CmdArgs.push_back("-call_shared");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006724 }
6725
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006726 if (IsStatic)
Matthew Curtise689b052012-12-06 15:46:07 +00006727 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006728
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006729 if (IsPIE && !IsShared)
Matthew Curtise8f80a12012-12-06 17:49:03 +00006730 CmdArgs.push_back("-pie");
6731
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006732 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
6733 std::string N = llvm::utostr(G.getValue());
6734 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + N));
6735 UseG0 = G.getValue() == 0;
Matthew Curtise8f80a12012-12-06 17:49:03 +00006736 }
6737
Matthew Curtise689b052012-12-06 15:46:07 +00006738 //----------------------------------------------------------------------------
6739 //
6740 //----------------------------------------------------------------------------
6741 CmdArgs.push_back("-o");
6742 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006743
Matthew Curtise689b052012-12-06 15:46:07 +00006744 //----------------------------------------------------------------------------
6745 // moslib
6746 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006747 std::vector<std::string> OsLibs;
6748 bool HasStandalone = false;
Matthew Curtise689b052012-12-06 15:46:07 +00006749
Sean Silva14facf32015-06-09 01:57:17 +00006750 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
6751 A->claim();
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006752 OsLibs.emplace_back(A->getValue());
6753 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006754 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006755 if (OsLibs.empty()) {
6756 OsLibs.push_back("standalone");
6757 HasStandalone = true;
Matthew Curtise689b052012-12-06 15:46:07 +00006758 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006759
Matthew Curtise689b052012-12-06 15:46:07 +00006760 //----------------------------------------------------------------------------
6761 // Start Files
6762 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006763 const std::string MCpuSuffix = "/" + CpuVer;
6764 const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
6765 const std::string RootDir =
6766 HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
6767 const std::string StartSubDir =
6768 "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00006769
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006770 auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
6771 const char *Name) -> std::string {
6772 std::string RelName = SubDir + Name;
6773 std::string P = HTC.GetFilePath(RelName.c_str());
6774 if (llvm::sys::fs::exists(P))
6775 return P;
6776 return RootDir + RelName;
6777 };
6778
6779 if (IncStdLib && IncStartFiles) {
6780 if (!IsShared) {
6781 if (HasStandalone) {
6782 std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
6783 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
Matthew Curtise689b052012-12-06 15:46:07 +00006784 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006785 std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
6786 CmdArgs.push_back(Args.MakeArgString(Crt0));
Matthew Curtise689b052012-12-06 15:46:07 +00006787 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006788 std::string Init = UseShared
6789 ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
6790 : Find(RootDir, StartSubDir, "/init.o");
6791 CmdArgs.push_back(Args.MakeArgString(Init));
Matthew Curtise689b052012-12-06 15:46:07 +00006792 }
6793
6794 //----------------------------------------------------------------------------
6795 // Library Search Paths
6796 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006797 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
6798 for (const auto &LibPath : LibPaths)
6799 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00006800
6801 //----------------------------------------------------------------------------
6802 //
6803 //----------------------------------------------------------------------------
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006804 Args.AddAllArgs(CmdArgs,
6805 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6806 options::OPT_t, options::OPT_u_Group});
Matthew Curtise689b052012-12-06 15:46:07 +00006807
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006808 AddLinkerInputs(HTC, Inputs, Args, CmdArgs);
Matthew Curtise689b052012-12-06 15:46:07 +00006809
6810 //----------------------------------------------------------------------------
6811 // Libraries
6812 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006813 if (IncStdLib && IncDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006814 if (D.CCCIsCXX()) {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006815 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
Matthew Curtise689b052012-12-06 15:46:07 +00006816 CmdArgs.push_back("-lm");
6817 }
6818
6819 CmdArgs.push_back("--start-group");
6820
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006821 if (!IsShared) {
6822 for (const std::string &Lib : OsLibs)
Douglas Katzman2675d012015-06-29 19:12:56 +00006823 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
Matthew Curtise689b052012-12-06 15:46:07 +00006824 CmdArgs.push_back("-lc");
6825 }
6826 CmdArgs.push_back("-lgcc");
6827
6828 CmdArgs.push_back("--end-group");
6829 }
6830
6831 //----------------------------------------------------------------------------
6832 // End files
6833 //----------------------------------------------------------------------------
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006834 if (IncStdLib && IncStartFiles) {
6835 std::string Fini = UseShared
6836 ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
6837 : Find(RootDir, StartSubDir, "/fini.o");
6838 CmdArgs.push_back(Args.MakeArgString(Fini));
Matthew Curtise689b052012-12-06 15:46:07 +00006839 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006840}
6841
Douglas Katzman95354292015-06-23 20:42:09 +00006842void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6843 const InputInfo &Output,
6844 const InputInfoList &Inputs,
6845 const ArgList &Args,
6846 const char *LinkingOutput) const {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006847 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006848
6849 ArgStringList CmdArgs;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006850 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006851 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00006852
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006853 std::string Linker = HTC.GetProgramPath("hexagon-link");
David Blaikiec11bf802014-09-04 16:04:28 +00006854 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
Justin Bognerd3371d82015-07-17 03:35:54 +00006855 CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006856}
6857// Hexagon tools end.
6858
Tom Stellard8fa33092015-07-18 01:49:05 +00006859void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6860 const InputInfo &Output,
6861 const InputInfoList &Inputs,
6862 const ArgList &Args,
6863 const char *LinkingOutput) const {
6864
6865 std::string Linker = getToolChain().GetProgramPath(getShortName());
6866 ArgStringList CmdArgs;
Tom Stellard8fa33092015-07-18 01:49:05 +00006867 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Tom Stellardf6699f52016-05-05 17:03:41 +00006868 CmdArgs.push_back("-shared");
6869 CmdArgs.push_back("-o");
Tom Stellard8fa33092015-07-18 01:49:05 +00006870 CmdArgs.push_back(Output.getFilename());
6871 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
6872 CmdArgs, Inputs));
6873}
6874// AMDGPU tools end.
6875
Dan Gohman52816862015-12-16 23:30:41 +00006876wasm::Linker::Linker(const ToolChain &TC)
6877 : GnuTool("wasm::Linker", "lld", TC) {}
6878
6879bool wasm::Linker::isLinkJob() const {
6880 return true;
6881}
6882
6883bool wasm::Linker::hasIntegratedCPP() const {
6884 return false;
6885}
6886
6887void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6888 const InputInfo &Output,
6889 const InputInfoList &Inputs,
6890 const ArgList &Args,
6891 const char *LinkingOutput) const {
Dan Gohman57b62c52016-02-22 19:26:15 +00006892
6893 const ToolChain &ToolChain = getToolChain();
6894 const Driver &D = ToolChain.getDriver();
6895 const char *Linker = Args.MakeArgString(ToolChain.GetLinkerPath());
Dan Gohman52816862015-12-16 23:30:41 +00006896 ArgStringList CmdArgs;
6897 CmdArgs.push_back("-flavor");
6898 CmdArgs.push_back("ld");
Dan Gohman1aa58282016-01-06 19:43:32 +00006899
6900 // Enable garbage collection of unused input sections by default, since code
Dan Gohmana5b804b2016-01-07 00:50:27 +00006901 // size is of particular importance. This is significantly facilitated by
6902 // the enabling of -ffunction-sections and -fdata-sections in
6903 // Clang::ConstructJob.
Dan Gohman4e480202016-01-07 00:32:04 +00006904 if (areOptimizationsEnabled(Args))
6905 CmdArgs.push_back("--gc-sections");
Dan Gohman1aa58282016-01-06 19:43:32 +00006906
Dan Gohman57b62c52016-02-22 19:26:15 +00006907 if (Args.hasArg(options::OPT_rdynamic))
6908 CmdArgs.push_back("-export-dynamic");
6909 if (Args.hasArg(options::OPT_s))
6910 CmdArgs.push_back("--strip-all");
6911 if (Args.hasArg(options::OPT_shared))
6912 CmdArgs.push_back("-shared");
6913 if (Args.hasArg(options::OPT_static))
6914 CmdArgs.push_back("-Bstatic");
6915
6916 Args.AddAllArgs(CmdArgs, options::OPT_L);
6917 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
6918
6919 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
6920 if (Args.hasArg(options::OPT_shared))
6921 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("rcrt1.o")));
6922 else if (Args.hasArg(options::OPT_pie))
6923 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("Scrt1.o")));
6924 else
6925 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
6926
6927 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6928 }
6929
6930 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6931
6932 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6933 if (D.CCCIsCXX())
6934 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6935
6936 if (Args.hasArg(options::OPT_pthread))
6937 CmdArgs.push_back("-lpthread");
6938
6939 CmdArgs.push_back("-lc");
6940 CmdArgs.push_back("-lcompiler_rt");
6941 }
6942
6943 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
6944 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6945
Dan Gohman52816862015-12-16 23:30:41 +00006946 CmdArgs.push_back("-o");
6947 CmdArgs.push_back(Output.getFilename());
Dan Gohman57b62c52016-02-22 19:26:15 +00006948
Dan Gohman52816862015-12-16 23:30:41 +00006949 C.addCommand(llvm::make_unique<Command>(JA, *this, Linker, CmdArgs, Inputs));
6950}
6951
Renato Golin7c542b42015-07-27 23:44:45 +00006952const std::string arm::getARMArch(StringRef Arch, const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00006953 std::string MArch;
Renato Goline17c5802015-07-27 23:44:42 +00006954 if (!Arch.empty())
6955 MArch = Arch;
6956 else
Bernard Ogden31561762013-12-12 13:27:11 +00006957 MArch = Triple.getArchName();
Bradley Smithbbf5a002015-11-18 16:33:48 +00006958 MArch = StringRef(MArch).split("+").first.lower();
John Brawn94fd9632015-05-21 12:19:49 +00006959
6960 // Handle -march=native.
6961 if (MArch == "native") {
6962 std::string CPU = llvm::sys::getHostCPUName();
6963 if (CPU != "generic") {
6964 // Translate the native cpu into the architecture suffix for that CPU.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006965 StringRef Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006966 // If there is no valid architecture suffix for this CPU we don't know how
6967 // to handle it, so return no architecture.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006968 if (Suffix.empty())
John Brawn94fd9632015-05-21 12:19:49 +00006969 MArch = "";
6970 else
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006971 MArch = std::string("arm") + Suffix.str();
John Brawn94fd9632015-05-21 12:19:49 +00006972 }
6973 }
6974
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006975 return MArch;
6976}
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006977
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006978/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006979StringRef arm::getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple) {
Renato Goline17c5802015-07-27 23:44:42 +00006980 std::string MArch = getARMArch(Arch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006981 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
6982 // here means an -march=native that we can't handle, so instead return no CPU.
6983 if (MArch.empty())
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006984 return StringRef();
Bernard Ogden31561762013-12-12 13:27:11 +00006985
John Brawna95c1a82015-05-08 12:52:18 +00006986 // We need to return an empty string here on invalid MArch values as the
6987 // various places that call this function can't cope with a null result.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006988 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00006989}
6990
6991/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Renato Golin7c542b42015-07-27 23:44:45 +00006992std::string arm::getARMTargetCPU(StringRef CPU, StringRef Arch,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006993 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00006994 // FIXME: Warn on inconsistent use of -mcpu and -march.
6995 // If we have -mcpu=, use that.
Renato Goline17c5802015-07-27 23:44:42 +00006996 if (!CPU.empty()) {
Bradley Smithbbf5a002015-11-18 16:33:48 +00006997 std::string MCPU = StringRef(CPU).split("+").first.lower();
Bernard Ogden31561762013-12-12 13:27:11 +00006998 // Handle -mcpu=native.
6999 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00007000 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00007001 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00007002 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00007003 }
7004
Renato Goline17c5802015-07-27 23:44:42 +00007005 return getARMCPUForMArch(Arch, Triple);
Bernard Ogden31561762013-12-12 13:27:11 +00007006}
7007
7008/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00007009/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00007010// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00007011StringRef arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
7012 const llvm::Triple &Triple) {
7013 unsigned ArchKind;
Vladimir Sukharev64f68242015-09-23 09:29:32 +00007014 if (CPU == "generic") {
Vladimir Sukhareva317dfb2015-09-24 10:06:44 +00007015 std::string ARMArch = tools::arm::getARMArch(Arch, Triple);
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00007016 ArchKind = llvm::ARM::parseArch(ARMArch);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00007017 if (ArchKind == llvm::ARM::AK_INVALID)
7018 // In case of generic Arch, i.e. "arm",
7019 // extract arch from default cpu of the Triple
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00007020 ArchKind = llvm::ARM::parseCPUArch(Triple.getARMCPUForArch(ARMArch));
Vladimir Sukharev64f68242015-09-23 09:29:32 +00007021 } else {
Tim Northover6f3ff222015-10-30 16:30:27 +00007022 // FIXME: horrible hack to get around the fact that Cortex-A7 is only an
7023 // armv7k triple if it's actually been specified via "-arch armv7k".
7024 ArchKind = (Arch == "armv7k" || Arch == "thumbv7k")
Aaron Ballman43059102015-11-04 14:43:43 +00007025 ? (unsigned)llvm::ARM::AK_ARMV7K
Tim Northover6f3ff222015-10-30 16:30:27 +00007026 : llvm::ARM::parseCPUArch(CPU);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00007027 }
Renato Golin3c007252015-05-28 15:05:53 +00007028 if (ArchKind == llvm::ARM::AK_INVALID)
7029 return "";
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00007030 return llvm::ARM::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00007031}
7032
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007033void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00007034 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007035 if (Args.hasArg(options::OPT_r))
7036 return;
7037
John Brawn94fd9632015-05-21 12:19:49 +00007038 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
7039 // to generate BE-8 executables.
7040 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
7041 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00007042}
7043
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007044mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
Daniel Sanderse0395a72015-09-24 10:22:17 +00007045 // Strictly speaking, mips32r2 and mips64r2 are NanLegacy-only since Nan2008
7046 // was first introduced in Release 3. However, other compilers have
7047 // traditionally allowed it for Release 2 so we should do the same.
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007048 return (NanEncoding)llvm::StringSwitch<int>(CPU)
7049 .Case("mips1", NanLegacy)
7050 .Case("mips2", NanLegacy)
7051 .Case("mips3", NanLegacy)
7052 .Case("mips4", NanLegacy)
7053 .Case("mips5", NanLegacy)
7054 .Case("mips32", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00007055 .Case("mips32r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007056 .Case("mips32r3", NanLegacy | Nan2008)
7057 .Case("mips32r5", NanLegacy | Nan2008)
7058 .Case("mips32r6", Nan2008)
7059 .Case("mips64", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00007060 .Case("mips64r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00007061 .Case("mips64r3", NanLegacy | Nan2008)
7062 .Case("mips64r5", NanLegacy | Nan2008)
7063 .Case("mips64r6", Nan2008)
7064 .Default(NanLegacy);
7065}
7066
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007067bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
7068 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
7069 return A && (A->getValue() == StringRef(Value));
7070}
7071
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007072bool mips::isUCLibc(const ArgList &Args) {
7073 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00007074 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00007075}
7076
Daniel Sanders2bf13662014-07-10 14:40:57 +00007077bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007078 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
7079 return llvm::StringSwitch<bool>(NaNArg->getValue())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007080 .Case("2008", true)
7081 .Case("legacy", false)
7082 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007083
7084 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00007085 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007086 .Cases("mips32r6", "mips64r6", true)
7087 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00007088
7089 return false;
7090}
7091
Petar Jovanovic3ca16222016-05-18 12:46:06 +00007092bool mips::isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName) {
7093 if (!Triple.isAndroid())
7094 return false;
7095
7096 // Android MIPS32R6 defaults to FP64A.
7097 return llvm::StringSwitch<bool>(CPUName)
7098 .Case("mips32r6", true)
7099 .Default(false);
7100}
7101
Daniel Sanders379d44b2014-07-16 11:52:23 +00007102bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007103 StringRef ABIName, mips::FloatABI FloatABI) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00007104 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Petar Jovanovic3ca16222016-05-18 12:46:06 +00007105 Triple.getVendor() != llvm::Triple::MipsTechnologies &&
7106 !Triple.isAndroid())
Daniel Sanders379d44b2014-07-16 11:52:23 +00007107 return false;
7108
7109 if (ABIName != "32")
7110 return false;
7111
Toma Tabacu94ea6862015-06-16 13:54:13 +00007112 // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is
7113 // present.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007114 if (FloatABI == mips::FloatABI::Soft)
Toma Tabacu94ea6862015-06-16 13:54:13 +00007115 return false;
7116
Daniel Sanders379d44b2014-07-16 11:52:23 +00007117 return llvm::StringSwitch<bool>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007118 .Cases("mips2", "mips3", "mips4", "mips5", true)
7119 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
7120 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
7121 .Default(false);
Daniel Sanders379d44b2014-07-16 11:52:23 +00007122}
7123
Toma Tabacu94ea6862015-06-16 13:54:13 +00007124bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple,
7125 StringRef CPUName, StringRef ABIName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00007126 mips::FloatABI FloatABI) {
Toma Tabacu94ea6862015-06-16 13:54:13 +00007127 bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
7128
7129 // FPXX shouldn't be used if -msingle-float is present.
7130 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
7131 options::OPT_mdouble_float))
7132 if (A->getOption().matches(options::OPT_msingle_float))
7133 UseFPXX = false;
7134
7135 return UseFPXX;
7136}
7137
Tim Northover157d9112014-01-16 08:48:16 +00007138llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00007139 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
7140 // archs which Darwin doesn't use.
7141
7142 // The matching this routine does is fairly pointless, since it is neither the
7143 // complete architecture list, nor a reasonable subset. The problem is that
7144 // historically the driver driver accepts this and also ties its -march=
7145 // handling to the architecture name, so we need to be careful before removing
7146 // support for it.
7147
7148 // This code must be kept in sync with Clang's Darwin specific argument
7149 // translation.
7150
7151 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007152 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
7153 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
7154 .Case("ppc64", llvm::Triple::ppc64)
7155 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
7156 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
7157 llvm::Triple::x86)
7158 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
7159 // This is derived from the driver driver.
7160 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
7161 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
7162 .Cases("armv7s", "xscale", llvm::Triple::arm)
7163 .Case("arm64", llvm::Triple::aarch64)
7164 .Case("r600", llvm::Triple::r600)
7165 .Case("amdgcn", llvm::Triple::amdgcn)
7166 .Case("nvptx", llvm::Triple::nvptx)
7167 .Case("nvptx64", llvm::Triple::nvptx64)
7168 .Case("amdil", llvm::Triple::amdil)
7169 .Case("spir", llvm::Triple::spir)
7170 .Default(llvm::Triple::UnknownArch);
Rafael Espindoladcbf6982012-10-31 18:51:07 +00007171}
Tony Linthicum76329bf2011-12-12 21:14:55 +00007172
Tim Northover157d9112014-01-16 08:48:16 +00007173void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007174 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00007175 T.setArch(Arch);
7176
7177 if (Str == "x86_64h")
7178 T.setArchName(Str);
7179 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
7180 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00007181 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00007182 }
7183}
7184
Bob Wilsondecc03e2012-11-23 06:14:39 +00007185const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00007186 const InputInfo &Input) {
7187 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007188}
7189
Bob Wilsondecc03e2012-11-23 06:14:39 +00007190const char *Clang::getBaseInputStem(const ArgList &Args,
7191 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00007192 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007193
Chris Lattner906bb902011-01-16 08:14:11 +00007194 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00007195 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007196
7197 return Str;
7198}
7199
Bob Wilsondecc03e2012-11-23 06:14:39 +00007200const char *Clang::getDependencyFileName(const ArgList &Args,
7201 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007202 // FIXME: Think about this more.
7203 std::string Res;
7204
7205 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00007206 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007207 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00007208 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00007209 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00007210 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00007211 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00007212}
7213
Douglas Katzman95354292015-06-23 20:42:09 +00007214void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7215 const InputInfo &Output,
7216 const InputInfoList &Inputs,
7217 const ArgList &Args,
7218 const char *LinkingOutput) const {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007219 const ToolChain &ToolChain = getToolChain();
7220 const Driver &D = ToolChain.getDriver();
7221 ArgStringList CmdArgs;
7222
7223 // Silence warning for "clang -g foo.o -o foo"
7224 Args.ClaimAllArgs(options::OPT_g_Group);
7225 // and "clang -emit-llvm foo.o -o foo"
7226 Args.ClaimAllArgs(options::OPT_emit_llvm);
7227 // and for "clang -w foo.o -o foo". Other warning options are already
7228 // handled somewhere else.
7229 Args.ClaimAllArgs(options::OPT_w);
7230
7231 if (!D.SysRoot.empty())
7232 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7233
7234 // CloudABI only supports static linkage.
7235 CmdArgs.push_back("-Bstatic");
Ed Schouten506f2952016-04-06 15:37:06 +00007236
7237 // CloudABI uses Position Independent Executables exclusively.
7238 CmdArgs.push_back("-pie");
7239 CmdArgs.push_back("--no-dynamic-linker");
7240 CmdArgs.push_back("-zrelro");
7241
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007242 CmdArgs.push_back("--eh-frame-hdr");
7243 CmdArgs.push_back("--gc-sections");
7244
7245 if (Output.isFilename()) {
7246 CmdArgs.push_back("-o");
7247 CmdArgs.push_back(Output.getFilename());
7248 } else {
7249 assert(Output.isNothing() && "Invalid output.");
7250 }
7251
Douglas Katzman78b37b02015-11-17 20:28:07 +00007252 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007253 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
7254 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
7255 }
7256
7257 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +00007258 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007259 Args.AddAllArgs(CmdArgs,
7260 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
7261 options::OPT_t, options::OPT_Z_Flag, options::OPT_r});
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007262
Teresa Johnson945bc502015-10-15 20:35:53 +00007263 if (D.isUsingLTO())
7264 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007265
7266 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7267
Douglas Katzman78b37b02015-11-17 20:28:07 +00007268 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007269 if (D.CCCIsCXX())
7270 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
7271 CmdArgs.push_back("-lc");
7272 CmdArgs.push_back("-lcompiler_rt");
7273 }
7274
Douglas Katzman78b37b02015-11-17 20:28:07 +00007275 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007276 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
7277
7278 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007279 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Ed Schouten3c3e58c2015-03-26 11:13:44 +00007280}
7281
Douglas Katzman95354292015-06-23 20:42:09 +00007282void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7283 const InputInfo &Output,
7284 const InputInfoList &Inputs,
7285 const ArgList &Args,
7286 const char *LinkingOutput) const {
Daniel Dunbarbe220842009-03-20 16:06:39 +00007287 ArgStringList CmdArgs;
7288
7289 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
7290 const InputInfo &Input = Inputs[0];
7291
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007292 // Determine the original source input.
7293 const Action *SourceAction = &JA;
7294 while (SourceAction->getKind() != Action::InputClass) {
7295 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
7296 SourceAction = SourceAction->getInputs()[0];
7297 }
7298
Eric Christopherf5a8f492015-12-08 00:10:10 +00007299 // If -fno-integrated-as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00007300 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00007301 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
7302 // FIXME: at run-time detect assembler capabilities or rely on version
Eric Christopherf5a8f492015-12-08 00:10:10 +00007303 // information forwarded by -target-assembler-version.
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00007304 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00007305 const llvm::Triple &T(getToolChain().getTriple());
7306 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00007307 CmdArgs.push_back("-Q");
7308 }
Kevin Enderby319baa42013-11-18 23:30:29 +00007309
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007310 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00007311 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00007312 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00007313 if (Args.hasArg(options::OPT_gstabs))
7314 CmdArgs.push_back("--gstabs");
7315 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00007316 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00007317 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007318
Daniel Dunbarbe220842009-03-20 16:06:39 +00007319 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00007320 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00007321
Daniel Dunbar6d484762010-07-22 01:47:22 +00007322 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00007323 if (getToolChain().getArch() == llvm::Triple::x86 ||
7324 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00007325 Args.hasArg(options::OPT_force__cpusubtype__ALL))
7326 CmdArgs.push_back("-force_cpusubtype_ALL");
7327
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00007328 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00007329 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00007330 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00007331 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00007332 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007333 CmdArgs.push_back("-static");
7334
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007335 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarbe220842009-03-20 16:06:39 +00007336
7337 assert(Output.isFilename() && "Unexpected lipo output.");
7338 CmdArgs.push_back("-o");
7339 CmdArgs.push_back(Output.getFilename());
7340
Daniel Dunbarb440f562010-08-02 02:38:21 +00007341 assert(Input.isFilename() && "Invalid input.");
7342 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00007343
7344 // asm_final spec is empty.
7345
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007346 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007347 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00007348}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007349
Tim Northover157d9112014-01-16 08:48:16 +00007350void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00007351
Tim Northover157d9112014-01-16 08:48:16 +00007352void darwin::MachOTool::AddMachOArch(const ArgList &Args,
7353 ArgStringList &CmdArgs) const {
7354 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007355
Daniel Dunbarc1964212009-03-26 16:23:12 +00007356 // Derived from darwin_arch spec.
7357 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007358 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00007359
Daniel Dunbardcc3b652010-01-22 02:04:58 +00007360 // FIXME: Is this needed anymore?
7361 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00007362 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00007363}
7364
Douglas Katzman95354292015-06-23 20:42:09 +00007365bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
Bill Wendling3b2000f2012-10-02 18:02:50 +00007366 // We only need to generate a temp path for LTO if we aren't compiling object
7367 // files. When compiling source files, we run 'dsymutil' after linking. We
7368 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007369 for (const auto &Input : Inputs)
7370 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00007371 return true;
7372
7373 return false;
7374}
7375
Douglas Katzman95354292015-06-23 20:42:09 +00007376void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
7377 ArgStringList &CmdArgs,
7378 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007379 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00007380 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00007381
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00007382 unsigned Version[5] = {0, 0, 0, 0, 0};
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007383 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00007384 if (!Driver::GetReleaseVersion(A->getValue(), Version))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007385 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007386 }
7387
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00007388 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007389 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00007390 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7391 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00007392
Bob Wilson3d27dad2013-08-02 22:25:34 +00007393 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
7394 CmdArgs.push_back("-export_dynamic");
7395
Bob Wilsonb111ec92015-03-02 19:01:14 +00007396 // If we are using App Extension restrictions, pass a flag to the linker
7397 // telling it that the compiled code has been audited.
7398 if (Args.hasFlag(options::OPT_fapplication_extension,
7399 options::OPT_fno_application_extension, false))
7400 CmdArgs.push_back("-application_extension");
7401
Teresa Johnson945bc502015-10-15 20:35:53 +00007402 if (D.isUsingLTO()) {
Bruno Cardoso Lopesa5efe3a2015-10-02 15:10:33 +00007403 // If we are using LTO, then automatically create a temporary file path for
7404 // the linker to use, so that it's lifetime will extend past a possible
7405 // dsymutil step.
7406 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
7407 const char *TmpPath = C.getArgs().MakeArgString(
7408 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
7409 C.addTempFile(TmpPath);
7410 CmdArgs.push_back("-object_path_lto");
7411 CmdArgs.push_back(TmpPath);
7412 }
7413
7414 // Use -lto_library option to specify the libLTO.dylib path. Try to find
7415 // it in clang installed libraries. If not found, the option is not used
7416 // and 'ld' will use its default mechanism to search for libLTO.dylib.
7417 if (Version[0] >= 133) {
7418 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
7419 StringRef P = llvm::sys::path::parent_path(D.getInstalledDir());
7420 SmallString<128> LibLTOPath(P);
7421 llvm::sys::path::append(LibLTOPath, "lib");
7422 llvm::sys::path::append(LibLTOPath, "libLTO.dylib");
7423 if (llvm::sys::fs::exists(LibLTOPath)) {
7424 CmdArgs.push_back("-lto_library");
7425 CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));
7426 } else {
7427 D.Diag(diag::warn_drv_lto_libpath);
7428 }
7429 }
Daniel Dunbaref889c72011-06-21 20:55:11 +00007430 }
7431
Daniel Dunbarc1964212009-03-26 16:23:12 +00007432 // Derived from the "link" spec.
7433 Args.AddAllArgs(CmdArgs, options::OPT_static);
7434 if (!Args.hasArg(options::OPT_static))
7435 CmdArgs.push_back("-dynamic");
7436 if (Args.hasArg(options::OPT_fgnu_runtime)) {
7437 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
7438 // here. How do we wish to handle such things?
7439 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007440
Daniel Dunbarc1964212009-03-26 16:23:12 +00007441 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00007442 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00007443 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00007444 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007445
7446 Args.AddLastArg(CmdArgs, options::OPT_bundle);
7447 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
7448 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
7449
7450 Arg *A;
7451 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
7452 (A = Args.getLastArg(options::OPT_current__version)) ||
7453 (A = Args.getLastArg(options::OPT_install__name)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007454 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
7455 << "-dynamiclib";
Daniel Dunbarc1964212009-03-26 16:23:12 +00007456
7457 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
7458 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
7459 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
7460 } else {
7461 CmdArgs.push_back("-dylib");
7462
7463 Arg *A;
7464 if ((A = Args.getLastArg(options::OPT_bundle)) ||
7465 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
7466 (A = Args.getLastArg(options::OPT_client__name)) ||
7467 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
7468 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
7469 (A = Args.getLastArg(options::OPT_private__bundle)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007470 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
7471 << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007472
Daniel Dunbarc1964212009-03-26 16:23:12 +00007473 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
7474 "-dylib_compatibility_version");
7475 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
7476 "-dylib_current_version");
7477
Tim Northover157d9112014-01-16 08:48:16 +00007478 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007479
7480 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
7481 "-dylib_install_name");
7482 }
7483
7484 Args.AddLastArg(CmdArgs, options::OPT_all__load);
7485 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
7486 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00007487 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007488 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007489 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
7490 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
7491 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
7492 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
7493 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
7494 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00007495 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007496 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
7497 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
7498 Args.AddAllArgs(CmdArgs, options::OPT_init);
7499
Daniel Dunbarc44d3132011-04-28 21:23:41 +00007500 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00007501 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00007502
Daniel Dunbarc1964212009-03-26 16:23:12 +00007503 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
7504 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
7505 Args.AddLastArg(CmdArgs, options::OPT_single__module);
7506 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
7507 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007508
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007509 if (const Arg *A =
7510 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
7511 options::OPT_fno_pie, options::OPT_fno_PIE)) {
Daniel Dunbaraf68a882010-07-13 23:31:40 +00007512 if (A->getOption().matches(options::OPT_fpie) ||
7513 A->getOption().matches(options::OPT_fPIE))
7514 CmdArgs.push_back("-pie");
7515 else
7516 CmdArgs.push_back("-no_pie");
7517 }
Steven Wu574b0f22016-03-01 01:07:58 +00007518 // for embed-bitcode, use -bitcode_bundle in linker command
7519 if (C.getDriver().embedBitcodeEnabled() ||
7520 C.getDriver().embedBitcodeMarkerOnly()) {
7521 // Check if the toolchain supports bitcode build flow.
7522 if (MachOTC.SupportsEmbeddedBitcode())
7523 CmdArgs.push_back("-bitcode_bundle");
7524 else
7525 D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
7526 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00007527
7528 Args.AddLastArg(CmdArgs, options::OPT_prebind);
7529 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
7530 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
7531 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
7532 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
7533 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
7534 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
7535 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
7536 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
7537 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
7538 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
7539 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
7540 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
7541 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
7542 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
7543 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007544
Daniel Dunbar84384642011-05-02 21:03:47 +00007545 // Give --sysroot= preference, over the Apple specific behavior to also use
7546 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00007547 StringRef sysroot = C.getSysRoot();
7548 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00007549 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00007550 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00007551 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
7552 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00007553 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007554 }
7555
Daniel Dunbarc1964212009-03-26 16:23:12 +00007556 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
7557 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
7558 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
7559 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
7560 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00007561 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007562 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
7563 Args.AddAllArgs(CmdArgs, options::OPT_y);
7564 Args.AddLastArg(CmdArgs, options::OPT_w);
7565 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
7566 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
7567 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
7568 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
7569 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
7570 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
7571 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
7572 Args.AddLastArg(CmdArgs, options::OPT_whyload);
7573 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
7574 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
7575 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
7576 Args.AddLastArg(CmdArgs, options::OPT_Mach);
7577}
7578
Douglas Katzman95354292015-06-23 20:42:09 +00007579void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7580 const InputInfo &Output,
7581 const InputInfoList &Inputs,
7582 const ArgList &Args,
7583 const char *LinkingOutput) const {
Daniel Dunbarc1964212009-03-26 16:23:12 +00007584 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00007585
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007586 // If the number of arguments surpasses the system limits, we will encode the
7587 // input files in a separate file, shortening the command line. To this end,
7588 // build a list of input file names that can be passed via a file with the
7589 // -filelist linker option.
7590 llvm::opt::ArgStringList InputFileList;
7591
Daniel Dunbarc1964212009-03-26 16:23:12 +00007592 // The logic here is derived from gcc's behavior; most of which
7593 // comes from specs (starting with link_command). Consult gcc for
7594 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00007595 ArgStringList CmdArgs;
7596
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007597 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
7598 if (Args.hasArg(options::OPT_ccc_arcmt_check,
7599 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007600 for (const auto &Arg : Args)
7601 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007602 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007603 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007604 CmdArgs.push_back(Output.getFilename());
Justin Bognerd3371d82015-07-17 03:35:54 +00007605 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00007606 return;
7607 }
7608
Daniel Dunbarc1964212009-03-26 16:23:12 +00007609 // I'm not sure why this particular decomposition exists in gcc, but
7610 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00007611 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007612
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007613 // It seems that the 'e' option is completely ignored for dynamic executables
7614 // (the default), and with static executables, the last one wins, as expected.
7615 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
7616 options::OPT_Z_Flag, options::OPT_u_Group,
7617 options::OPT_e, options::OPT_r});
Daniel Dunbarc1964212009-03-26 16:23:12 +00007618
Daniel Dunbar767bbab2010-10-18 22:08:36 +00007619 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
7620 // members of static archive libraries which implement Objective-C classes or
7621 // categories.
7622 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
7623 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007624
Daniel Dunbarc1964212009-03-26 16:23:12 +00007625 CmdArgs.push_back("-o");
7626 CmdArgs.push_back(Output.getFilename());
7627
Douglas Katzman78b37b02015-11-17 20:28:07 +00007628 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
Tim Northover157d9112014-01-16 08:48:16 +00007629 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007630
Peter Collingbournec4122c12015-06-15 21:08:13 +00007631 // SafeStack requires its own runtime libraries
7632 // These libraries should be linked first, to make sure the
7633 // __safestack_init constructor executes before everything else
7634 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
7635 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
7636 "libclang_rt.safestack_osx.a",
7637 /*AlwaysLink=*/true);
7638 }
7639
Daniel Dunbarc1964212009-03-26 16:23:12 +00007640 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007641
Douglas Gregor9295df02012-05-15 21:00:27 +00007642 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007643 // Build the input file for -filelist (list of linker input files) in case we
7644 // need it later
7645 for (const auto &II : Inputs) {
7646 if (!II.isFilename()) {
7647 // This is a linker input argument.
7648 // We cannot mix input arguments and file names in a -filelist input, thus
7649 // we prematurely stop our list (remaining files shall be passed as
7650 // arguments).
7651 if (InputFileList.size() > 0)
7652 break;
7653
7654 continue;
7655 }
7656
7657 InputFileList.push_back(II.getFilename());
7658 }
7659
Douglas Katzman78b37b02015-11-17 20:28:07 +00007660 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
Joerg Sonnenberger5c3f9d52015-09-23 20:07:56 +00007661 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
7662
Douglas Katzman78b37b02015-11-17 20:28:07 +00007663 if (isObjCRuntimeLinked(Args) &&
7664 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00007665 // We use arclite library for both ARC and subscripting support.
7666 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
7667
Bob Wilson7dda0cd2012-04-21 00:21:42 +00007668 CmdArgs.push_back("-framework");
7669 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00007670 // Link libobj.
7671 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00007672 }
John McCall31168b02011-06-15 23:02:42 +00007673
Daniel Dunbarc1964212009-03-26 16:23:12 +00007674 if (LinkingOutput) {
7675 CmdArgs.push_back("-arch_multiple");
7676 CmdArgs.push_back("-final_output");
7677 CmdArgs.push_back(LinkingOutput);
7678 }
7679
Daniel Dunbarc1964212009-03-26 16:23:12 +00007680 if (Args.hasArg(options::OPT_fnested_functions))
7681 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007682
Justin Bognerc7701242015-05-12 05:44:36 +00007683 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
7684
Douglas Katzman78b37b02015-11-17 20:28:07 +00007685 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007686 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007687 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00007688
Daniel Dunbarc1964212009-03-26 16:23:12 +00007689 // link_ssp spec is empty.
7690
Daniel Dunbar26d482a2009-09-18 08:15:03 +00007691 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00007692 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00007693 }
7694
Douglas Katzman78b37b02015-11-17 20:28:07 +00007695 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbarc1964212009-03-26 16:23:12 +00007696 // endfile_spec is empty.
7697 }
7698
7699 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7700 Args.AddAllArgs(CmdArgs, options::OPT_F);
7701
Steven Wu3ffb61b2015-02-06 18:08:29 +00007702 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00007703 for (const Arg *A : Args.filtered(options::OPT_iframework))
7704 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00007705
Douglas Katzman78b37b02015-11-17 20:28:07 +00007706 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00007707 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
7708 if (A->getValue() == StringRef("Accelerate")) {
7709 CmdArgs.push_back("-framework");
7710 CmdArgs.push_back("Accelerate");
7711 }
7712 }
7713 }
7714
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007715 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007716 std::unique_ptr<Command> Cmd =
Justin Bognerd3371d82015-07-17 03:35:54 +00007717 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00007718 Cmd->setInputFileList(std::move(InputFileList));
7719 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00007720}
7721
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007722void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007723 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00007724 const InputInfoList &Inputs,
7725 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007726 const char *LinkingOutput) const {
7727 ArgStringList CmdArgs;
7728
7729 CmdArgs.push_back("-create");
7730 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007731
7732 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007733 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007734
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007735 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007736 assert(II.isFilename() && "Unexpected lipo input.");
7737 CmdArgs.push_back(II.getFilename());
7738 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007739
7740 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007741 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007742}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007743
Daniel Dunbar88299622010-06-04 18:28:36 +00007744void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007745 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00007746 const InputInfoList &Inputs,
7747 const ArgList &Args,
7748 const char *LinkingOutput) const {
7749 ArgStringList CmdArgs;
7750
Daniel Dunbareb86b042011-05-09 17:23:16 +00007751 CmdArgs.push_back("-o");
7752 CmdArgs.push_back(Output.getFilename());
7753
Daniel Dunbar88299622010-06-04 18:28:36 +00007754 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7755 const InputInfo &Input = Inputs[0];
7756 assert(Input.isFilename() && "Unexpected dsymutil input.");
7757 CmdArgs.push_back(Input.getFilename());
7758
Daniel Dunbar88299622010-06-04 18:28:36 +00007759 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007760 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007761 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar88299622010-06-04 18:28:36 +00007762}
7763
Eric Christopher551ef452011-08-23 17:56:55 +00007764void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00007765 const InputInfo &Output,
7766 const InputInfoList &Inputs,
7767 const ArgList &Args,
7768 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00007769 ArgStringList CmdArgs;
7770 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00007771 CmdArgs.push_back("--debug-info");
7772 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00007773 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00007774
7775 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7776 const InputInfo &Input = Inputs[0];
7777 assert(Input.isFilename() && "Unexpected verify input");
7778
7779 // Grabbing the output of the earlier dsymutil run.
7780 CmdArgs.push_back(Input.getFilename());
7781
7782 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007783 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007784 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher551ef452011-08-23 17:56:55 +00007785}
7786
Douglas Katzman95354292015-06-23 20:42:09 +00007787void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
David Chisnallf571cde2012-02-15 13:39:01 +00007788 const InputInfo &Output,
7789 const InputInfoList &Inputs,
7790 const ArgList &Args,
7791 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007792 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00007793 ArgStringList CmdArgs;
7794
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007795 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
David Chisnallf571cde2012-02-15 13:39:01 +00007796
7797 CmdArgs.push_back("-o");
7798 CmdArgs.push_back(Output.getFilename());
7799
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007800 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00007801 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00007802
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007803 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007804 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007805}
7806
Douglas Katzman95354292015-06-23 20:42:09 +00007807void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7808 const InputInfo &Output,
7809 const InputInfoList &Inputs,
7810 const ArgList &Args,
7811 const char *LinkingOutput) const {
David Chisnallf571cde2012-02-15 13:39:01 +00007812 ArgStringList CmdArgs;
7813
David Chisnall272a0712012-02-29 15:06:12 +00007814 // Demangle C++ names in errors
7815 CmdArgs.push_back("-C");
7816
Douglas Katzman78b37b02015-11-17 20:28:07 +00007817 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
David Chisnallf571cde2012-02-15 13:39:01 +00007818 CmdArgs.push_back("-e");
7819 CmdArgs.push_back("_start");
7820 }
7821
7822 if (Args.hasArg(options::OPT_static)) {
7823 CmdArgs.push_back("-Bstatic");
7824 CmdArgs.push_back("-dn");
7825 } else {
7826 CmdArgs.push_back("-Bdynamic");
7827 if (Args.hasArg(options::OPT_shared)) {
7828 CmdArgs.push_back("-shared");
7829 } else {
7830 CmdArgs.push_back("--dynamic-linker");
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007831 CmdArgs.push_back(
7832 Args.MakeArgString(getToolChain().GetFilePath("ld.so.1")));
David Chisnallf571cde2012-02-15 13:39:01 +00007833 }
7834 }
7835
7836 if (Output.isFilename()) {
7837 CmdArgs.push_back("-o");
7838 CmdArgs.push_back(Output.getFilename());
7839 } else {
7840 assert(Output.isNothing() && "Invalid output.");
7841 }
7842
Douglas Katzman78b37b02015-11-17 20:28:07 +00007843 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007844 if (!Args.hasArg(options::OPT_shared))
7845 CmdArgs.push_back(
7846 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7847
7848 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7849 CmdArgs.push_back(
7850 Args.MakeArgString(getToolChain().GetFilePath("values-Xa.o")));
7851 CmdArgs.push_back(
7852 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007853 }
7854
Douglas Katzman6059ef92015-11-17 17:41:23 +00007855 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00007856
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007857 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7858 options::OPT_e, options::OPT_r});
David Chisnallf571cde2012-02-15 13:39:01 +00007859
7860 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7861
Douglas Katzman78b37b02015-11-17 20:28:07 +00007862 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007863 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00007864 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00007865 CmdArgs.push_back("-lgcc_s");
Rafael Espindola8d4d9d2f2015-09-14 19:30:53 +00007866 CmdArgs.push_back("-lc");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007867 if (!Args.hasArg(options::OPT_shared)) {
7868 CmdArgs.push_back("-lgcc");
David Chisnallc73fb892012-02-28 20:06:45 +00007869 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007870 }
David Chisnallf571cde2012-02-15 13:39:01 +00007871 }
7872
Douglas Katzman78b37b02015-11-17 20:28:07 +00007873 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007874 CmdArgs.push_back(
7875 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007876 }
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007877 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007878
Xinliang David Li69306c02015-10-22 06:15:31 +00007879 getToolChain().addProfileRTLibs(Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00007880
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007881 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007882 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007883}
7884
Douglas Katzman95354292015-06-23 20:42:09 +00007885void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7886 const InputInfo &Output,
7887 const InputInfoList &Inputs,
7888 const ArgList &Args,
7889 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007890 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007891 ArgStringList CmdArgs;
7892
Rafael Espindolacc126272014-02-28 01:55:21 +00007893 switch (getToolChain().getArch()) {
7894 case llvm::Triple::x86:
7895 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
7896 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007897 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00007898 break;
7899
7900 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007901 CmdArgs.push_back("-mppc");
7902 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00007903 break;
7904
7905 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007906 case llvm::Triple::sparcel: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007907 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007908 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7909 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7910 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007911 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007912 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007913
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007914 case llvm::Triple::sparcv9: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007915 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007916 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7917 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7918 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007919 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007920 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007921
7922 case llvm::Triple::mips64:
7923 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007924 StringRef CPUName;
7925 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007926 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007927
7928 CmdArgs.push_back("-mabi");
7929 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7930
7931 if (getToolChain().getArch() == llvm::Triple::mips64)
7932 CmdArgs.push_back("-EB");
7933 else
7934 CmdArgs.push_back("-EL");
7935
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007936 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007937 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007938 }
7939
Rafael Espindolacc126272014-02-28 01:55:21 +00007940 default:
7941 break;
7942 }
7943
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007944 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007945
7946 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007947 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007948
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007949 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007950 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007951
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007952 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007953 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007954}
7955
Douglas Katzman95354292015-06-23 20:42:09 +00007956void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7957 const InputInfo &Output,
7958 const InputInfoList &Inputs,
7959 const ArgList &Args,
7960 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007961 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007962 ArgStringList CmdArgs;
7963
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00007964 // Silence warning for "clang -g foo.o -o foo"
7965 Args.ClaimAllArgs(options::OPT_g_Group);
7966 // and "clang -emit-llvm foo.o -o foo"
7967 Args.ClaimAllArgs(options::OPT_emit_llvm);
7968 // and for "clang -w foo.o -o foo". Other warning options are already
7969 // handled somewhere else.
7970 Args.ClaimAllArgs(options::OPT_w);
7971
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007972 if (getToolChain().getArch() == llvm::Triple::mips64)
7973 CmdArgs.push_back("-EB");
7974 else if (getToolChain().getArch() == llvm::Triple::mips64el)
7975 CmdArgs.push_back("-EL");
7976
Douglas Katzman78b37b02015-11-17 20:28:07 +00007977 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007978 CmdArgs.push_back("-e");
7979 CmdArgs.push_back("__start");
7980 }
7981
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007982 if (Args.hasArg(options::OPT_static)) {
7983 CmdArgs.push_back("-Bstatic");
7984 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007985 if (Args.hasArg(options::OPT_rdynamic))
7986 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007987 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007988 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007989 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007990 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007991 } else {
7992 CmdArgs.push_back("-dynamic-linker");
7993 CmdArgs.push_back("/usr/libexec/ld.so");
7994 }
7995 }
7996
Rafael Espindola044f7832013-06-05 04:28:55 +00007997 if (Args.hasArg(options::OPT_nopie))
7998 CmdArgs.push_back("-nopie");
7999
Daniel Dunbarb440f562010-08-02 02:38:21 +00008000 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008001 CmdArgs.push_back("-o");
8002 CmdArgs.push_back(Output.getFilename());
8003 } else {
8004 assert(Output.isNothing() && "Invalid output.");
8005 }
8006
Douglas Katzman78b37b02015-11-17 20:28:07 +00008007 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008008 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008009 if (Args.hasArg(options::OPT_pg))
8010 CmdArgs.push_back(
8011 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman3715d1f2011-12-15 02:15:56 +00008012 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008013 CmdArgs.push_back(
8014 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
8015 CmdArgs.push_back(
8016 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008017 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008018 CmdArgs.push_back(
8019 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008020 }
8021 }
8022
Edward O'Callaghan5c521462009-10-28 15:13:08 +00008023 std::string Triple = getToolChain().getTripleString();
8024 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00008025 Triple.replace(0, 6, "amd64");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008026 CmdArgs.push_back(
8027 Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00008028
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008029 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
8030 options::OPT_e, options::OPT_s, options::OPT_t,
8031 options::OPT_Z_Flag, options::OPT_r});
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008032
Daniel Dunbar54423b22010-09-17 00:24:54 +00008033 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008034
Douglas Katzman78b37b02015-11-17 20:28:07 +00008035 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008036 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008037 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008038 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00008039 CmdArgs.push_back("-lm_p");
8040 else
8041 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00008042 }
8043
Daniel Dunbara8888ac2009-08-03 01:28:59 +00008044 // FIXME: For some reason GCC passes -lgcc before adding
8045 // the default system libraries. Just mimic this for now.
8046 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008047
Eric Christopher17674ec2012-09-13 06:32:34 +00008048 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008049 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
8050 CmdArgs.push_back("-lpthread_p");
Eric Christopher17674ec2012-09-13 06:32:34 +00008051 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008052 CmdArgs.push_back("-lpthread");
Eric Christopher17674ec2012-09-13 06:32:34 +00008053 }
8054
Chandler Carruth45661652011-12-17 22:32:42 +00008055 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00008056 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008057 CmdArgs.push_back("-lc_p");
Eli Friedman3715d1f2011-12-15 02:15:56 +00008058 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008059 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00008060 }
Eric Christopher17674ec2012-09-13 06:32:34 +00008061
Daniel Dunbara8888ac2009-08-03 01:28:59 +00008062 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008063 }
8064
Douglas Katzman78b37b02015-11-17 20:28:07 +00008065 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008066 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008067 CmdArgs.push_back(
8068 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008069 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008070 CmdArgs.push_back(
8071 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008072 }
8073
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008074 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008075 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00008076}
Ed Schoutene33194b2009-04-02 19:13:12 +00008077
Douglas Katzman95354292015-06-23 20:42:09 +00008078void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8079 const InputInfo &Output,
8080 const InputInfoList &Inputs,
8081 const ArgList &Args,
8082 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008083 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00008084 ArgStringList CmdArgs;
8085
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008086 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Eli Friedman9fa28852012-08-08 23:57:20 +00008087
8088 CmdArgs.push_back("-o");
8089 CmdArgs.push_back(Output.getFilename());
8090
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008091 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00008092 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00008093
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008094 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008095 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00008096}
8097
Douglas Katzman95354292015-06-23 20:42:09 +00008098void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8099 const InputInfo &Output,
8100 const InputInfoList &Inputs,
8101 const ArgList &Args,
8102 const char *LinkingOutput) const {
Eli Friedman9fa28852012-08-08 23:57:20 +00008103 const Driver &D = getToolChain().getDriver();
8104 ArgStringList CmdArgs;
8105
Douglas Katzman78b37b02015-11-17 20:28:07 +00008106 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008107 CmdArgs.push_back("-e");
8108 CmdArgs.push_back("__start");
8109 }
8110
8111 if (Args.hasArg(options::OPT_static)) {
8112 CmdArgs.push_back("-Bstatic");
8113 } else {
8114 if (Args.hasArg(options::OPT_rdynamic))
8115 CmdArgs.push_back("-export-dynamic");
8116 CmdArgs.push_back("--eh-frame-hdr");
8117 CmdArgs.push_back("-Bdynamic");
8118 if (Args.hasArg(options::OPT_shared)) {
8119 CmdArgs.push_back("-shared");
8120 } else {
8121 CmdArgs.push_back("-dynamic-linker");
8122 CmdArgs.push_back("/usr/libexec/ld.so");
8123 }
8124 }
8125
8126 if (Output.isFilename()) {
8127 CmdArgs.push_back("-o");
8128 CmdArgs.push_back(Output.getFilename());
8129 } else {
8130 assert(Output.isNothing() && "Invalid output.");
8131 }
8132
Douglas Katzman78b37b02015-11-17 20:28:07 +00008133 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008134 if (!Args.hasArg(options::OPT_shared)) {
8135 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008136 CmdArgs.push_back(
8137 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008138 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008139 CmdArgs.push_back(
8140 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
8141 CmdArgs.push_back(
8142 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008143 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008144 CmdArgs.push_back(
8145 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008146 }
8147 }
8148
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008149 Args.AddAllArgs(CmdArgs,
8150 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Eli Friedman9fa28852012-08-08 23:57:20 +00008151
8152 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8153
Douglas Katzman78b37b02015-11-17 20:28:07 +00008154 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008155 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008156 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8157 if (Args.hasArg(options::OPT_pg))
8158 CmdArgs.push_back("-lm_p");
8159 else
8160 CmdArgs.push_back("-lm");
8161 }
8162
Rafael Espindola1ad26f02012-10-23 17:07:31 +00008163 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008164 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
Rafael Espindola1ad26f02012-10-23 17:07:31 +00008165 CmdArgs.push_back("-lpthread_p");
8166 else
8167 CmdArgs.push_back("-lpthread");
8168 }
8169
Eli Friedman9fa28852012-08-08 23:57:20 +00008170 if (!Args.hasArg(options::OPT_shared)) {
8171 if (Args.hasArg(options::OPT_pg))
8172 CmdArgs.push_back("-lc_p");
8173 else
8174 CmdArgs.push_back("-lc");
8175 }
8176
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00008177 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008178 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00008179 case llvm::Triple::arm:
8180 MyArch = "arm";
8181 break;
8182 case llvm::Triple::x86:
8183 MyArch = "i386";
8184 break;
8185 case llvm::Triple::x86_64:
8186 MyArch = "amd64";
8187 break;
8188 default:
8189 llvm_unreachable("Unsupported architecture");
8190 }
8191 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00008192 }
8193
Douglas Katzman78b37b02015-11-17 20:28:07 +00008194 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman9fa28852012-08-08 23:57:20 +00008195 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008196 CmdArgs.push_back(
8197 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008198 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008199 CmdArgs.push_back(
8200 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00008201 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00008202
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008203 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008204 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00008205}
8206
Douglas Katzman95354292015-06-23 20:42:09 +00008207void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8208 const InputInfo &Output,
8209 const InputInfoList &Inputs,
8210 const ArgList &Args,
8211 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008212 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008213 ArgStringList CmdArgs;
8214
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008215 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
8216 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008217 switch (getToolChain().getArch()) {
8218 default:
8219 break;
8220 case llvm::Triple::x86:
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008221 CmdArgs.push_back("--32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008222 break;
8223 case llvm::Triple::ppc:
Roman Divacky00859c22011-06-04 07:37:31 +00008224 CmdArgs.push_back("-a32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008225 break;
8226 case llvm::Triple::mips:
8227 case llvm::Triple::mipsel:
8228 case llvm::Triple::mips64:
8229 case llvm::Triple::mips64el: {
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008230 StringRef CPUName;
8231 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008232 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00008233
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008234 CmdArgs.push_back("-march");
8235 CmdArgs.push_back(CPUName.data());
8236
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008237 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00008238 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008239
8240 if (getToolChain().getArch() == llvm::Triple::mips ||
8241 getToolChain().getArch() == llvm::Triple::mips64)
8242 CmdArgs.push_back("-EB");
8243 else
8244 CmdArgs.push_back("-EL");
8245
Dimitry Andric46f338c2015-12-27 10:36:44 +00008246 if (Arg *A = Args.getLastArg(options::OPT_G)) {
8247 StringRef v = A->getValue();
8248 CmdArgs.push_back(Args.MakeArgString("-G" + v));
8249 A->claim();
8250 }
8251
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008252 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008253 break;
8254 }
8255 case llvm::Triple::arm:
8256 case llvm::Triple::armeb:
8257 case llvm::Triple::thumb:
8258 case llvm::Triple::thumbeb: {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008259 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
Renato Golinf4421f72014-02-19 10:44:07 +00008260
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008261 if (ABI == arm::FloatABI::Hard)
Renato Golinf4421f72014-02-19 10:44:07 +00008262 CmdArgs.push_back("-mfpu=vfp");
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008263 else
Renato Golinf4421f72014-02-19 10:44:07 +00008264 CmdArgs.push_back("-mfpu=softvfp");
Renato Golinf4421f72014-02-19 10:44:07 +00008265
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008266 switch (getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00008267 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00008268 case llvm::Triple::GNUEABI:
8269 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00008270 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00008271 break;
8272
8273 default:
8274 CmdArgs.push_back("-matpcs");
8275 }
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008276 break;
8277 }
8278 case llvm::Triple::sparc:
8279 case llvm::Triple::sparcel:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008280 case llvm::Triple::sparcv9: {
8281 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8282 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008283 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00008284 break;
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00008285 }
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008286 }
Eric Christopher0b26a612010-03-02 02:41:08 +00008287
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008288 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008289
8290 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008291 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008292
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008293 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008294 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008295
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008296 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008297 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00008298}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008299
Douglas Katzman95354292015-06-23 20:42:09 +00008300void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8301 const InputInfo &Output,
8302 const InputInfoList &Inputs,
8303 const ArgList &Args,
8304 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008305 const toolchains::FreeBSD &ToolChain =
8306 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00008307 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008308 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008309 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008310 !Args.hasArg(options::OPT_shared) &&
8311 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008312 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00008313
8314 // Silence warning for "clang -g foo.o -o foo"
8315 Args.ClaimAllArgs(options::OPT_g_Group);
8316 // and "clang -emit-llvm foo.o -o foo"
8317 Args.ClaimAllArgs(options::OPT_emit_llvm);
8318 // and for "clang -w foo.o -o foo". Other warning options are already
8319 // handled somewhere else.
8320 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008321
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008322 if (!D.SysRoot.empty())
8323 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8324
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008325 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008326 CmdArgs.push_back("-pie");
8327
Ed Maste1bc232d2016-04-12 21:11:46 +00008328 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008329 if (Args.hasArg(options::OPT_static)) {
8330 CmdArgs.push_back("-Bstatic");
8331 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00008332 if (Args.hasArg(options::OPT_rdynamic))
8333 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008334 if (Args.hasArg(options::OPT_shared)) {
8335 CmdArgs.push_back("-Bshareable");
8336 } else {
8337 CmdArgs.push_back("-dynamic-linker");
8338 CmdArgs.push_back("/libexec/ld-elf.so.1");
8339 }
Roman Divackyafe2f232012-08-28 15:09:03 +00008340 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00008341 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
8342 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
8343 CmdArgs.push_back("--hash-style=both");
8344 }
8345 }
8346 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008347 }
8348
8349 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
8350 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008351 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008352 CmdArgs.push_back("-m");
8353 CmdArgs.push_back("elf_i386_fbsd");
8354 }
8355
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008356 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00008357 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00008358 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00008359 }
8360
Dimitry Andric904895f2015-12-27 06:47:09 +00008361 if (Arg *A = Args.getLastArg(options::OPT_G)) {
8362 if (ToolChain.getArch() == llvm::Triple::mips ||
8363 ToolChain.getArch() == llvm::Triple::mipsel ||
8364 ToolChain.getArch() == llvm::Triple::mips64 ||
8365 ToolChain.getArch() == llvm::Triple::mips64el) {
8366 StringRef v = A->getValue();
8367 CmdArgs.push_back(Args.MakeArgString("-G" + v));
8368 A->claim();
8369 }
8370 }
8371
Daniel Dunbarb440f562010-08-02 02:38:21 +00008372 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008373 CmdArgs.push_back("-o");
8374 CmdArgs.push_back(Output.getFilename());
8375 } else {
8376 assert(Output.isNothing() && "Invalid output.");
8377 }
8378
Douglas Katzman78b37b02015-11-17 20:28:07 +00008379 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008380 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008381 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00008382 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00008383 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008384 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008385 crt1 = "Scrt1.o";
8386 else
8387 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008388 }
Roman Divackyafe2f232012-08-28 15:09:03 +00008389 if (crt1)
8390 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
8391
8392 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8393
Craig Topper92fc2df2014-05-17 16:56:41 +00008394 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00008395 if (Args.hasArg(options::OPT_static))
8396 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008397 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008398 crtbegin = "crtbeginS.o";
8399 else
8400 crtbegin = "crtbegin.o";
8401
8402 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008403 }
8404
8405 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +00008406 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008407 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8408 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00008409 Args.AddAllArgs(CmdArgs, options::OPT_s);
8410 Args.AddAllArgs(CmdArgs, options::OPT_t);
8411 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8412 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008413
Teresa Johnson945bc502015-10-15 20:35:53 +00008414 if (D.isUsingLTO())
8415 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Roman Divackyf0d7f942013-11-10 09:31:43 +00008416
Alexey Samsonov52550342014-09-15 19:58:40 +00008417 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00008418 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008419
Douglas Katzman78b37b02015-11-17 20:28:07 +00008420 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Dimitry Andric0cc6f472015-10-18 13:32:20 +00008421 addOpenMPRuntime(CmdArgs, ToolChain, Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00008422 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00008423 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00008424 if (Args.hasArg(options::OPT_pg))
8425 CmdArgs.push_back("-lm_p");
8426 else
8427 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00008428 }
Alexey Samsonov52550342014-09-15 19:58:40 +00008429 if (NeedsSanitizerDeps)
8430 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008431 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
8432 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00008433 if (Args.hasArg(options::OPT_pg))
8434 CmdArgs.push_back("-lgcc_p");
8435 else
8436 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008437 if (Args.hasArg(options::OPT_static)) {
8438 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00008439 } else if (Args.hasArg(options::OPT_pg)) {
8440 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008441 } else {
8442 CmdArgs.push_back("--as-needed");
8443 CmdArgs.push_back("-lgcc_s");
8444 CmdArgs.push_back("--no-as-needed");
8445 }
8446
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00008447 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00008448 if (Args.hasArg(options::OPT_pg))
8449 CmdArgs.push_back("-lpthread_p");
8450 else
8451 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00008452 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008453
Roman Divacky66f22762011-02-10 16:59:40 +00008454 if (Args.hasArg(options::OPT_pg)) {
8455 if (Args.hasArg(options::OPT_shared))
8456 CmdArgs.push_back("-lc");
8457 else
8458 CmdArgs.push_back("-lc_p");
8459 CmdArgs.push_back("-lgcc_p");
8460 } else {
8461 CmdArgs.push_back("-lc");
8462 CmdArgs.push_back("-lgcc");
8463 }
8464
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008465 if (Args.hasArg(options::OPT_static)) {
8466 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00008467 } else if (Args.hasArg(options::OPT_pg)) {
8468 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008469 } else {
8470 CmdArgs.push_back("--as-needed");
8471 CmdArgs.push_back("-lgcc_s");
8472 CmdArgs.push_back("--no-as-needed");
8473 }
8474 }
8475
Douglas Katzman78b37b02015-11-17 20:28:07 +00008476 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00008477 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00008478 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00008479 else
8480 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00008481 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008482 }
8483
Xinliang David Li69306c02015-10-22 06:15:31 +00008484 ToolChain.addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008485
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008486 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008487 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00008488}
Daniel Dunbarcc912342009-05-02 18:28:39 +00008489
Douglas Katzman95354292015-06-23 20:42:09 +00008490void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008491 const InputInfo &Output,
8492 const InputInfoList &Inputs,
8493 const ArgList &Args,
8494 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008495 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008496 ArgStringList CmdArgs;
8497
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008498 // GNU as needs different flags for creating the correct output format
8499 // on architectures with different ABIs or optional feature sets.
8500 switch (getToolChain().getArch()) {
8501 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008502 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008503 break;
8504 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00008505 case llvm::Triple::armeb:
8506 case llvm::Triple::thumb:
8507 case llvm::Triple::thumbeb: {
Renato Goline17c5802015-07-27 23:44:42 +00008508 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00008509 getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true);
8510 std::string Arch =
8511 arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple());
Renato Goline17c5802015-07-27 23:44:42 +00008512 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008513 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00008514 }
8515
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008516 case llvm::Triple::mips:
8517 case llvm::Triple::mipsel:
8518 case llvm::Triple::mips64:
8519 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008520 StringRef CPUName;
8521 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008522 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008523
8524 CmdArgs.push_back("-march");
8525 CmdArgs.push_back(CPUName.data());
8526
8527 CmdArgs.push_back("-mabi");
8528 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
8529
8530 if (getToolChain().getArch() == llvm::Triple::mips ||
8531 getToolChain().getArch() == llvm::Triple::mips64)
8532 CmdArgs.push_back("-EB");
8533 else
8534 CmdArgs.push_back("-EL");
8535
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008536 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008537 break;
8538 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008539
8540 case llvm::Triple::sparc:
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008541 case llvm::Triple::sparcel: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008542 CmdArgs.push_back("-32");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008543 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8544 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008545 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008546 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008547 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008548
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008549 case llvm::Triple::sparcv9: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008550 CmdArgs.push_back("-64");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008551 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8552 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008553 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008554 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00008555 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008556
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00008557 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008558 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00008559 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008560
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008561 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008562
8563 CmdArgs.push_back("-o");
8564 CmdArgs.push_back(Output.getFilename());
8565
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008566 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008567 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008568
David Chisnallddbd68f2011-09-27 22:03:18 +00008569 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Justin Bognerd3371d82015-07-17 03:35:54 +00008570 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008571}
8572
Douglas Katzman95354292015-06-23 20:42:09 +00008573void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8574 const InputInfo &Output,
8575 const InputInfoList &Inputs,
8576 const ArgList &Args,
8577 const char *LinkingOutput) const {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008578 const Driver &D = getToolChain().getDriver();
8579 ArgStringList CmdArgs;
8580
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008581 if (!D.SysRoot.empty())
8582 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8583
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00008584 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008585 if (Args.hasArg(options::OPT_static)) {
8586 CmdArgs.push_back("-Bstatic");
8587 } else {
8588 if (Args.hasArg(options::OPT_rdynamic))
8589 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008590 if (Args.hasArg(options::OPT_shared)) {
8591 CmdArgs.push_back("-Bshareable");
8592 } else {
8593 CmdArgs.push_back("-dynamic-linker");
8594 CmdArgs.push_back("/libexec/ld.elf_so");
8595 }
8596 }
8597
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008598 // Many NetBSD architectures support more than one ABI.
8599 // Determine the correct emulation for ld.
8600 switch (getToolChain().getArch()) {
8601 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008602 CmdArgs.push_back("-m");
8603 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008604 break;
8605 case llvm::Triple::arm:
8606 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008607 CmdArgs.push_back("-m");
8608 switch (getToolChain().getTriple().getEnvironment()) {
8609 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008610 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008611 CmdArgs.push_back("armelf_nbsd_eabi");
8612 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00008613 case llvm::Triple::EABIHF:
8614 case llvm::Triple::GNUEABIHF:
8615 CmdArgs.push_back("armelf_nbsd_eabihf");
8616 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008617 default:
8618 CmdArgs.push_back("armelf_nbsd");
8619 break;
8620 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008621 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00008622 case llvm::Triple::armeb:
8623 case llvm::Triple::thumbeb:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008624 arm::appendEBLinkFlags(
8625 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00008626 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00008627 CmdArgs.push_back("-m");
8628 switch (getToolChain().getTriple().getEnvironment()) {
8629 case llvm::Triple::EABI:
8630 case llvm::Triple::GNUEABI:
8631 CmdArgs.push_back("armelfb_nbsd_eabi");
8632 break;
8633 case llvm::Triple::EABIHF:
8634 case llvm::Triple::GNUEABIHF:
8635 CmdArgs.push_back("armelfb_nbsd_eabihf");
8636 break;
8637 default:
8638 CmdArgs.push_back("armelfb_nbsd");
8639 break;
8640 }
8641 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00008642 case llvm::Triple::mips64:
8643 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00008644 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00008645 CmdArgs.push_back("-m");
8646 if (getToolChain().getArch() == llvm::Triple::mips64)
8647 CmdArgs.push_back("elf32btsmip");
8648 else
8649 CmdArgs.push_back("elf32ltsmip");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008650 } else if (mips::hasMipsAbiArg(Args, "64")) {
8651 CmdArgs.push_back("-m");
8652 if (getToolChain().getArch() == llvm::Triple::mips64)
8653 CmdArgs.push_back("elf64btsmip");
8654 else
8655 CmdArgs.push_back("elf64ltsmip");
8656 }
8657 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00008658 case llvm::Triple::ppc:
8659 CmdArgs.push_back("-m");
8660 CmdArgs.push_back("elf32ppc_nbsd");
8661 break;
8662
8663 case llvm::Triple::ppc64:
8664 case llvm::Triple::ppc64le:
8665 CmdArgs.push_back("-m");
8666 CmdArgs.push_back("elf64ppc");
8667 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00008668
8669 case llvm::Triple::sparc:
8670 CmdArgs.push_back("-m");
8671 CmdArgs.push_back("elf32_sparc");
8672 break;
8673
8674 case llvm::Triple::sparcv9:
8675 CmdArgs.push_back("-m");
8676 CmdArgs.push_back("elf64_sparc");
8677 break;
8678
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00008679 default:
8680 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00008681 }
8682
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008683 if (Output.isFilename()) {
8684 CmdArgs.push_back("-o");
8685 CmdArgs.push_back(Output.getFilename());
8686 } else {
8687 assert(Output.isNothing() && "Invalid output.");
8688 }
8689
Douglas Katzman78b37b02015-11-17 20:28:07 +00008690 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008691 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008692 CmdArgs.push_back(
8693 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
8694 CmdArgs.push_back(
8695 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8696 CmdArgs.push_back(
8697 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008698 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008699 CmdArgs.push_back(
8700 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8701 CmdArgs.push_back(
8702 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008703 }
8704 }
8705
8706 Args.AddAllArgs(CmdArgs, options::OPT_L);
8707 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8708 Args.AddAllArgs(CmdArgs, options::OPT_e);
8709 Args.AddAllArgs(CmdArgs, options::OPT_s);
8710 Args.AddAllArgs(CmdArgs, options::OPT_t);
8711 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8712 Args.AddAllArgs(CmdArgs, options::OPT_r);
8713
8714 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8715
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008716 unsigned Major, Minor, Micro;
8717 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
8718 bool useLibgcc = true;
Joerg Sonnenberger21156e82016-02-11 23:35:03 +00008719 if (Major >= 7 || Major == 0) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008720 switch (getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00008721 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00008722 case llvm::Triple::arm:
8723 case llvm::Triple::armeb:
8724 case llvm::Triple::thumb:
8725 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00008726 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00008727 case llvm::Triple::ppc64:
8728 case llvm::Triple::ppc64le:
Joerg Sonnenberger059613c2016-02-11 23:18:36 +00008729 case llvm::Triple::sparc:
8730 case llvm::Triple::sparcv9:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008731 case llvm::Triple::x86:
8732 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008733 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008734 break;
8735 default:
8736 break;
8737 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008738 }
8739
Douglas Katzman78b37b02015-11-17 20:28:07 +00008740 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Joerg Sonnenberger27a69a22015-09-23 20:11:00 +00008741 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00008742 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008743 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8744 CmdArgs.push_back("-lm");
8745 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008746 if (Args.hasArg(options::OPT_pthread))
8747 CmdArgs.push_back("-lpthread");
8748 CmdArgs.push_back("-lc");
8749
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008750 if (useLibgcc) {
8751 if (Args.hasArg(options::OPT_static)) {
8752 // libgcc_eh depends on libc, so resolve as much as possible,
8753 // pull in any new requirements from libc and then get the rest
8754 // of libgcc.
8755 CmdArgs.push_back("-lgcc_eh");
8756 CmdArgs.push_back("-lc");
8757 CmdArgs.push_back("-lgcc");
8758 } else {
8759 CmdArgs.push_back("-lgcc");
8760 CmdArgs.push_back("--as-needed");
8761 CmdArgs.push_back("-lgcc_s");
8762 CmdArgs.push_back("--no-as-needed");
8763 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008764 }
8765 }
8766
Douglas Katzman78b37b02015-11-17 20:28:07 +00008767 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008768 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008769 CmdArgs.push_back(
8770 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008771 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008772 CmdArgs.push_back(
8773 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
8774 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008775 }
8776
Xinliang David Li69306c02015-10-22 06:15:31 +00008777 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008778
Logan Chieneb9162f2014-06-26 14:23:45 +00008779 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008780 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008781}
8782
Douglas Katzman95354292015-06-23 20:42:09 +00008783void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8784 const InputInfo &Output,
8785 const InputInfoList &Inputs,
8786 const ArgList &Args,
8787 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008788 claimNoWarnArgs(Args);
8789
James Y Knight2db38f32015-08-15 03:45:25 +00008790 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8791 llvm::Triple Triple = llvm::Triple(TripleStr);
8792
Rafael Espindola92b00932010-08-10 00:25:48 +00008793 ArgStringList CmdArgs;
8794
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008795 llvm::Reloc::Model RelocationModel;
8796 unsigned PICLevel;
8797 bool IsPIE;
8798 std::tie(RelocationModel, PICLevel, IsPIE) =
8799 ParsePICArgs(getToolChain(), Triple, Args);
8800
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008801 switch (getToolChain().getArch()) {
8802 default:
8803 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00008804 // Add --32/--64 to make sure we get the format we want.
8805 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008806 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00008807 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008808 break;
8809 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00008810 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
8811 CmdArgs.push_back("--x32");
8812 else
8813 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008814 break;
8815 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008816 CmdArgs.push_back("-a32");
8817 CmdArgs.push_back("-mppc");
8818 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008819 break;
8820 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008821 CmdArgs.push_back("-a64");
8822 CmdArgs.push_back("-mppc64");
8823 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008824 break;
8825 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00008826 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008827 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00008828 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008829 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008830 break;
8831 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008832 case llvm::Triple::sparcel: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008833 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008834 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8835 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8836 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008837 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008838 }
8839 case llvm::Triple::sparcv9: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008840 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008841 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8842 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8843 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008844 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008845 }
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008846 case llvm::Triple::arm:
8847 case llvm::Triple::armeb:
8848 case llvm::Triple::thumb:
8849 case llvm::Triple::thumbeb: {
James Y Knight2db38f32015-08-15 03:45:25 +00008850 const llvm::Triple &Triple2 = getToolChain().getTriple();
8851 switch (Triple2.getSubArch()) {
Scott Douglass3205f522015-03-23 10:54:24 +00008852 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00008853 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00008854 break;
8855 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00008856 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00008857 break;
8858 default:
8859 break;
8860 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00008861
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008862 switch (arm::getARMFloatABI(getToolChain(), Args)) {
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008863 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
8864 case arm::FloatABI::Soft:
8865 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
8866 break;
8867 case arm::FloatABI::SoftFP:
8868 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
8869 break;
8870 case arm::FloatABI::Hard:
8871 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
8872 break;
8873 }
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008874
8875 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00008876
8877 // FIXME: remove krait check when GNU tools support krait cpu
Stephen Hinese3f91e32016-03-04 20:57:22 +00008878 // for now replace it with -mcpu=cortex-a15 to avoid a lower
Ana Pazosdd6068d2013-12-06 22:43:17 +00008879 // march from being picked in the absence of a cpu flag.
8880 Arg *A;
8881 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008882 StringRef(A->getValue()).lower() == "krait")
Stephen Hinese3f91e32016-03-04 20:57:22 +00008883 CmdArgs.push_back("-mcpu=cortex-a15");
Ana Pazosdd6068d2013-12-06 22:43:17 +00008884 else
8885 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008886 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008887 break;
8888 }
8889 case llvm::Triple::mips:
8890 case llvm::Triple::mipsel:
8891 case llvm::Triple::mips64:
8892 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008893 StringRef CPUName;
8894 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008895 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00008896 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00008897
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008898 CmdArgs.push_back("-march");
8899 CmdArgs.push_back(CPUName.data());
8900
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008901 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00008902 CmdArgs.push_back(ABIName.data());
8903
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008904 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
8905 // or -mshared (not implemented) is in effect.
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008906 if (RelocationModel == llvm::Reloc::Static)
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008907 CmdArgs.push_back("-mno-shared");
8908
Daniel Sanders379d44b2014-07-16 11:52:23 +00008909 // LLVM doesn't support -mplt yet and acts as if it is always given.
8910 // However, -mplt has no effect with the N64 ABI.
8911 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00008912
8913 if (getToolChain().getArch() == llvm::Triple::mips ||
8914 getToolChain().getArch() == llvm::Triple::mips64)
8915 CmdArgs.push_back("-EB");
8916 else
8917 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00008918
Simon Atanasyan22127ce2013-09-24 09:09:16 +00008919 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
8920 if (StringRef(A->getValue()) == "2008")
8921 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
8922 }
8923
Daniel Sanders379d44b2014-07-16 11:52:23 +00008924 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
8925 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
8926 options::OPT_mfp64)) {
8927 A->claim();
8928 A->render(Args, CmdArgs);
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00008929 } else if (mips::shouldUseFPXX(
8930 Args, getToolChain().getTriple(), CPUName, ABIName,
8931 getMipsFloatABI(getToolChain().getDriver(), Args)))
Daniel Sanders379d44b2014-07-16 11:52:23 +00008932 CmdArgs.push_back("-mfpxx");
8933
8934 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
8935 // -mno-mips16 is actually -no-mips16.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008936 if (Arg *A =
8937 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00008938 if (A->getOption().matches(options::OPT_mips16)) {
8939 A->claim();
8940 A->render(Args, CmdArgs);
8941 } else {
8942 A->claim();
8943 CmdArgs.push_back("-no-mips16");
8944 }
8945 }
8946
Simon Atanasyan036d16d2013-04-30 07:47:13 +00008947 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
8948 options::OPT_mno_micromips);
8949 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
8950 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
8951
Simon Atanasyanbd986632013-11-26 11:58:04 +00008952 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
8953 // Do not use AddLastArg because not all versions of MIPS assembler
8954 // support -mmsa / -mno-msa options.
8955 if (A->getOption().matches(options::OPT_mmsa))
8956 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
8957 }
8958
Daniel Sanders379d44b2014-07-16 11:52:23 +00008959 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
8960 options::OPT_msoft_float);
8961
Toma Tabacub36d6102015-06-11 12:13:18 +00008962 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
8963 options::OPT_msingle_float);
8964
Daniel Sanders379d44b2014-07-16 11:52:23 +00008965 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
8966 options::OPT_mno_odd_spreg);
8967
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008968 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008969 break;
8970 }
8971 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008972 // Always pass an -march option, since our default of z10 is later
8973 // than the GNU assembler's default.
8974 StringRef CPUName = getSystemZTargetCPU(Args);
8975 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008976 break;
8977 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008978 }
8979
Renato Golina74bbc72015-07-22 15:32:36 +00008980 Args.AddAllArgs(CmdArgs, options::OPT_I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008981 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Rafael Espindola92b00932010-08-10 00:25:48 +00008982
8983 CmdArgs.push_back("-o");
8984 CmdArgs.push_back(Output.getFilename());
8985
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008986 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00008987 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00008988
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008989 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008990 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00008991
8992 // Handle the debug info splitting at object creation time if we're
8993 // creating an object.
8994 // TODO: Currently only works on linux with newer objcopy.
8995 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00008996 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00008997 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00008998 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00008999}
9000
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00009001static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009002 ArgStringList &CmdArgs, const ArgList &Args) {
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00009003 bool isAndroid = Triple.isAndroid();
Reid Kleckner0213a472015-07-22 16:01:38 +00009004 bool isCygMing = Triple.isOSCygMing();
Chandler Carruth58d6eb62013-03-04 02:07:55 +00009005 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
9006 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00009007 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00009008 CmdArgs.push_back("-lgcc");
9009
Logan Chien3d3373c2012-11-19 12:04:11 +00009010 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00009011 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00009012 CmdArgs.push_back("-lgcc");
9013 } else {
Reid Kleckner0213a472015-07-22 16:01:38 +00009014 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00009015 CmdArgs.push_back("--as-needed");
9016 CmdArgs.push_back("-lgcc_s");
Reid Kleckner0213a472015-07-22 16:01:38 +00009017 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00009018 CmdArgs.push_back("--no-as-needed");
9019 }
9020
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009021 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00009022 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00009023 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00009024 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00009025
9026 // According to Android ABI, we have to link with libdl if we are
9027 // linking with non-static libgcc.
9028 //
9029 // NOTE: This fixes a link error on Android MIPS as well. The non-static
9030 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
9031 if (isAndroid && !StaticLibgcc)
9032 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00009033}
9034
Renato Golinc4b49242014-02-13 10:01:16 +00009035static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00009036 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00009037 // Make use of compiler-rt if --rtlib option is used
9038 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
9039
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00009040 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00009041 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009042 switch (TC.getTriple().getOS()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009043 default:
9044 llvm_unreachable("unsupported OS");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009045 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009046 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00009047 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009048 break;
9049 }
Renato Golinc4b49242014-02-13 10:01:16 +00009050 break;
9051 case ToolChain::RLT_Libgcc:
Andrey Turetskiya4868572016-03-14 11:19:43 +00009052 // Make sure libgcc is not used under MSVC environment by default
9053 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
9054 // Issue error diagnostic if libgcc is explicitly specified
9055 // through command line as --rtlib option argument.
9056 if (Args.hasArg(options::OPT_rtlib_EQ)) {
9057 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
9058 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "MSVC";
9059 }
9060 } else
9061 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
Renato Golinc4b49242014-02-13 10:01:16 +00009062 break;
Renato Golinc4b49242014-02-13 10:01:16 +00009063 }
9064}
9065
Rafael Espindola1e085772014-08-15 17:14:35 +00009066static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
9067 switch (T.getArch()) {
9068 case llvm::Triple::x86:
9069 return "elf_i386";
9070 case llvm::Triple::aarch64:
9071 return "aarch64linux";
9072 case llvm::Triple::aarch64_be:
9073 return "aarch64_be_linux";
9074 case llvm::Triple::arm:
9075 case llvm::Triple::thumb:
9076 return "armelf_linux_eabi";
9077 case llvm::Triple::armeb:
9078 case llvm::Triple::thumbeb:
9079 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
9080 case llvm::Triple::ppc:
9081 return "elf32ppclinux";
9082 case llvm::Triple::ppc64:
9083 return "elf64ppc";
9084 case llvm::Triple::ppc64le:
9085 return "elf64lppc";
9086 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009087 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00009088 return "elf32_sparc";
9089 case llvm::Triple::sparcv9:
9090 return "elf64_sparc";
9091 case llvm::Triple::mips:
9092 return "elf32btsmip";
9093 case llvm::Triple::mipsel:
9094 return "elf32ltsmip";
9095 case llvm::Triple::mips64:
9096 if (mips::hasMipsAbiArg(Args, "n32"))
9097 return "elf32btsmipn32";
9098 return "elf64btsmip";
9099 case llvm::Triple::mips64el:
9100 if (mips::hasMipsAbiArg(Args, "n32"))
9101 return "elf32ltsmipn32";
9102 return "elf64ltsmip";
9103 case llvm::Triple::systemz:
9104 return "elf64_s390";
9105 case llvm::Triple::x86_64:
9106 if (T.getEnvironment() == llvm::Triple::GNUX32)
9107 return "elf32_x86_64";
9108 return "elf_x86_64";
9109 default:
9110 llvm_unreachable("Unexpected arch");
9111 }
9112}
9113
Douglas Katzman95354292015-06-23 20:42:09 +00009114void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9115 const InputInfo &Output,
9116 const InputInfoList &Inputs,
9117 const ArgList &Args,
9118 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009119 const toolchains::Linux &ToolChain =
9120 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009121 const Driver &D = ToolChain.getDriver();
James Y Knight2db38f32015-08-15 03:45:25 +00009122
9123 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
9124 llvm::Triple Triple = llvm::Triple(TripleStr);
9125
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009126 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00009127 const bool isAndroid = ToolChain.getTriple().isAndroid();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009128 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009129 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
9130 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009131 const bool HasCRTBeginEndFiles =
9132 ToolChain.getTriple().hasEnvironment() ||
9133 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009134
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009135 ArgStringList CmdArgs;
9136
Rafael Espindolad1002f62010-11-15 18:28:16 +00009137 // Silence warning for "clang -g foo.o -o foo"
9138 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00009139 // and "clang -emit-llvm foo.o -o foo"
9140 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00009141 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00009142 // handled somewhere else.
9143 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00009144
Peter Collingbourne39719a72015-11-20 20:49:39 +00009145 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
9146 if (llvm::sys::path::filename(Exec) == "lld") {
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009147 CmdArgs.push_back("-flavor");
Rafael Espindola156aac02015-11-16 09:12:12 +00009148 CmdArgs.push_back("old-gnu");
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009149 CmdArgs.push_back("-target");
9150 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
9151 }
9152
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00009153 if (!D.SysRoot.empty())
9154 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009155
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009156 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00009157 CmdArgs.push_back("-pie");
9158
Rafael Espindola1c76c592010-11-07 22:57:16 +00009159 if (Args.hasArg(options::OPT_rdynamic))
9160 CmdArgs.push_back("-export-dynamic");
9161
Rafael Espindola34d77dc2010-11-11 19:34:42 +00009162 if (Args.hasArg(options::OPT_s))
9163 CmdArgs.push_back("-s");
9164
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009165 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
James Y Knight2db38f32015-08-15 03:45:25 +00009166 arm::appendEBLinkFlags(Args, CmdArgs, Triple);
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00009167
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00009168 for (const auto &Opt : ToolChain.ExtraOpts)
9169 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009170
9171 if (!Args.hasArg(options::OPT_static)) {
9172 CmdArgs.push_back("--eh-frame-hdr");
9173 }
9174
9175 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00009176 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009177
9178 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009179 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
9180 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009181 CmdArgs.push_back("-Bstatic");
9182 else
9183 CmdArgs.push_back("-static");
9184 } else if (Args.hasArg(options::OPT_shared)) {
9185 CmdArgs.push_back("-shared");
9186 }
9187
Saleem Abdulrasoolf56c6d82016-02-07 06:03:38 +00009188 if (!Args.hasArg(options::OPT_static)) {
9189 if (Args.hasArg(options::OPT_rdynamic))
9190 CmdArgs.push_back("-export-dynamic");
9191
9192 if (!Args.hasArg(options::OPT_shared)) {
9193 const std::string Loader =
Saleem Abdulrasool783fc632016-05-22 03:12:19 +00009194 D.DyldPrefix + ToolChain.getDynamicLinker(Args);
Saleem Abdulrasoolf56c6d82016-02-07 06:03:38 +00009195 CmdArgs.push_back("-dynamic-linker");
9196 CmdArgs.push_back(Args.MakeArgString(Loader));
9197 }
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00009198 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009199
9200 CmdArgs.push_back("-o");
9201 CmdArgs.push_back(Output.getFilename());
9202
Douglas Katzman78b37b02015-11-17 20:28:07 +00009203 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009204 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00009205 const char *crt1 = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009206 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopherac021742013-06-07 23:25:01 +00009207 if (Args.hasArg(options::OPT_pg))
9208 crt1 = "gcrt1.o";
9209 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009210 crt1 = "Scrt1.o";
9211 else
9212 crt1 = "crt1.o";
9213 }
9214 if (crt1)
9215 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009216
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009217 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
9218 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009219
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009220 const char *crtbegin;
9221 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009222 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009223 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009224 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009225 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009226 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009227 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009228 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009229
9230 if (HasCRTBeginEndFiles)
9231 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00009232
9233 // Add crtfastmath.o if available and fast math is enabled.
9234 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009235 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009236
9237 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00009238 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009239
Douglas Katzman6059ef92015-11-17 17:41:23 +00009240 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009241
Teresa Johnson945bc502015-10-15 20:35:53 +00009242 if (D.isUsingLTO())
9243 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Chandler Carruth953fb082013-01-13 11:46:33 +00009244
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00009245 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
9246 CmdArgs.push_back("--no-demangle");
9247
Alexey Samsonov52550342014-09-15 19:58:40 +00009248 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009249 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00009250 // The profile runtime also needs access to system libraries.
Xinliang David Li69306c02015-10-22 06:15:31 +00009251 getToolChain().addProfileRTLibs(Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00009252
Douglas Katzman78b37b02015-11-17 20:28:07 +00009253 if (D.CCCIsCXX() &&
9254 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00009255 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009256 !Args.hasArg(options::OPT_static);
Rafael Espindola70b8d762011-10-17 22:14:51 +00009257 if (OnlyLibstdcxxStatic)
9258 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009259 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00009260 if (OnlyLibstdcxxStatic)
9261 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009262 CmdArgs.push_back("-lm");
9263 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00009264 // Silence warnings when linking C code with a C++ '-stdlib' argument.
9265 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009266
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009267 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00009268 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9269 if (Args.hasArg(options::OPT_static))
9270 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00009271
Alexey Samsonov52550342014-09-15 19:58:40 +00009272 if (NeedsSanitizerDeps)
9273 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
9274
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009275 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
9276 Args.hasArg(options::OPT_pthreads);
9277
9278 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9279 options::OPT_fno_openmp, false)) {
9280 // OpenMP runtimes implies pthreads when using the GNU toolchain.
9281 // FIXME: Does this really make sense for all GNU toolchains?
9282 WantPthread = true;
9283
9284 // Also link the particular OpenMP runtimes.
9285 switch (getOpenMPRuntime(ToolChain, Args)) {
9286 case OMPRT_OMP:
9287 CmdArgs.push_back("-lomp");
9288 break;
9289 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00009290 CmdArgs.push_back("-lgomp");
9291
9292 // FIXME: Exclude this for platforms with libgomp that don't require
9293 // librt. Most modern Linux platforms require it, but some may not.
9294 CmdArgs.push_back("-lrt");
9295 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009296 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00009297 CmdArgs.push_back("-liomp5");
9298 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009299 case OMPRT_Unknown:
9300 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00009301 break;
9302 }
Chandler Carruth01538002013-01-17 13:19:29 +00009303 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00009304
Renato Golinc4b49242014-02-13 10:01:16 +00009305 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009306
Richard Smith31d1de22015-05-20 22:48:44 +00009307 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00009308 CmdArgs.push_back("-lpthread");
9309
Rafael Espindolab17bc532016-01-25 18:29:16 +00009310 if (Args.hasArg(options::OPT_fsplit_stack))
9311 CmdArgs.push_back("--wrap=pthread_create");
9312
Chandler Carruth94a32012012-05-14 18:31:18 +00009313 CmdArgs.push_back("-lc");
9314
9315 if (Args.hasArg(options::OPT_static))
9316 CmdArgs.push_back("--end-group");
9317 else
Renato Golinc4b49242014-02-13 10:01:16 +00009318 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00009319 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00009320
Rafael Espindola81937ec2010-12-01 01:52:43 +00009321 if (!Args.hasArg(options::OPT_nostartfiles)) {
9322 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009323 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009324 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00009325 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00009326 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00009327 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009328 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00009329
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00009330 if (HasCRTBeginEndFiles)
9331 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00009332 if (!isAndroid)
9333 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00009334 }
Sumanth Gundapanenib79fdff2015-12-02 19:12:41 +00009335 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00009336
Peter Collingbourne39719a72015-11-20 20:49:39 +00009337 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00009338}
9339
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009340// NaCl ARM assembly (inline or standalone) can be written with a set of macros
9341// for the various SFI requirements like register masking. The assembly tool
9342// inserts the file containing the macros as an input into all the assembly
9343// jobs.
Douglas Katzman95354292015-06-23 20:42:09 +00009344void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
9345 const InputInfo &Output,
9346 const InputInfoList &Inputs,
9347 const ArgList &Args,
9348 const char *LinkingOutput) const {
Douglas Katzman54366072015-07-27 16:53:08 +00009349 const toolchains::NaClToolChain &ToolChain =
9350 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Justin Lebard98cea82016-01-11 23:15:21 +00009351 InputInfo NaClMacros(types::TY_PP_Asm, ToolChain.GetNaClArmMacrosPath(),
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009352 "nacl-arm-macros.s");
9353 InputInfoList NewInputs;
9354 NewInputs.push_back(NaClMacros);
9355 NewInputs.append(Inputs.begin(), Inputs.end());
Douglas Katzman95354292015-06-23 20:42:09 +00009356 gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
9357 LinkingOutput);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009358}
9359
Douglas Katzman750cfc52015-06-29 18:42:16 +00009360// This is quite similar to gnutools::Linker::ConstructJob with changes that
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009361// we use static by default, do not yet support sanitizers or LTO, and a few
9362// others. Eventually we can support more of that and hopefully migrate back
Douglas Katzman750cfc52015-06-29 18:42:16 +00009363// to gnutools::Linker.
Douglas Katzman95354292015-06-23 20:42:09 +00009364void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9365 const InputInfo &Output,
9366 const InputInfoList &Inputs,
9367 const ArgList &Args,
9368 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009369
Douglas Katzman54366072015-07-27 16:53:08 +00009370 const toolchains::NaClToolChain &ToolChain =
9371 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009372 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009373 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009374 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009375 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009376
9377 ArgStringList CmdArgs;
9378
9379 // Silence warning for "clang -g foo.o -o foo"
9380 Args.ClaimAllArgs(options::OPT_g_Group);
9381 // and "clang -emit-llvm foo.o -o foo"
9382 Args.ClaimAllArgs(options::OPT_emit_llvm);
9383 // and for "clang -w foo.o -o foo". Other warning options are already
9384 // handled somewhere else.
9385 Args.ClaimAllArgs(options::OPT_w);
9386
9387 if (!D.SysRoot.empty())
9388 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9389
9390 if (Args.hasArg(options::OPT_rdynamic))
9391 CmdArgs.push_back("-export-dynamic");
9392
9393 if (Args.hasArg(options::OPT_s))
9394 CmdArgs.push_back("-s");
9395
Douglas Katzman54366072015-07-27 16:53:08 +00009396 // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
9397 // from there is --build-id, which we do want.
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009398 CmdArgs.push_back("--build-id");
9399
9400 if (!IsStatic)
9401 CmdArgs.push_back("--eh-frame-hdr");
9402
9403 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009404 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009405 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009406 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009407 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009408 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009409 CmdArgs.push_back("elf_x86_64_nacl");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009410 else if (Arch == llvm::Triple::mipsel)
9411 CmdArgs.push_back("mipselelf_nacl");
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009412 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00009413 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
9414 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009415
9416 if (IsStatic)
9417 CmdArgs.push_back("-static");
9418 else if (Args.hasArg(options::OPT_shared))
9419 CmdArgs.push_back("-shared");
9420
9421 CmdArgs.push_back("-o");
9422 CmdArgs.push_back(Output.getFilename());
Douglas Katzman78b37b02015-11-17 20:28:07 +00009423 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009424 if (!Args.hasArg(options::OPT_shared))
9425 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
9426 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
9427
9428 const char *crtbegin;
9429 if (IsStatic)
9430 crtbegin = "crtbeginT.o";
9431 else if (Args.hasArg(options::OPT_shared))
9432 crtbegin = "crtbeginS.o";
9433 else
9434 crtbegin = "crtbegin.o";
9435 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
9436 }
9437
9438 Args.AddAllArgs(CmdArgs, options::OPT_L);
9439 Args.AddAllArgs(CmdArgs, options::OPT_u);
9440
Douglas Katzman6059ef92015-11-17 17:41:23 +00009441 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009442
9443 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
9444 CmdArgs.push_back("--no-demangle");
9445
9446 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
9447
Douglas Katzman78b37b02015-11-17 20:28:07 +00009448 if (D.CCCIsCXX() &&
9449 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009450 bool OnlyLibstdcxxStatic =
9451 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009452 if (OnlyLibstdcxxStatic)
9453 CmdArgs.push_back("-Bstatic");
9454 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
9455 if (OnlyLibstdcxxStatic)
9456 CmdArgs.push_back("-Bdynamic");
9457 CmdArgs.push_back("-lm");
9458 }
9459
9460 if (!Args.hasArg(options::OPT_nostdlib)) {
9461 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9462 // Always use groups, since it has no effect on dynamic libraries.
9463 CmdArgs.push_back("--start-group");
9464 CmdArgs.push_back("-lc");
9465 // NaCl's libc++ currently requires libpthread, so just always include it
9466 // in the group for C++.
9467 if (Args.hasArg(options::OPT_pthread) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009468 Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009469 // Gold, used by Mips, handles nested groups differently than ld, and
9470 // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
9471 // which is not a desired behaviour here.
9472 // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
9473 if (getToolChain().getArch() == llvm::Triple::mipsel)
9474 CmdArgs.push_back("-lnacl");
9475
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009476 CmdArgs.push_back("-lpthread");
9477 }
9478
9479 CmdArgs.push_back("-lgcc");
9480 CmdArgs.push_back("--as-needed");
9481 if (IsStatic)
9482 CmdArgs.push_back("-lgcc_eh");
9483 else
9484 CmdArgs.push_back("-lgcc_s");
9485 CmdArgs.push_back("--no-as-needed");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00009486
9487 // Mips needs to create and use pnacl_legacy library that contains
9488 // definitions from bitcode/pnaclmm.c and definitions for
9489 // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
9490 if (getToolChain().getArch() == llvm::Triple::mipsel)
9491 CmdArgs.push_back("-lpnacl_legacy");
9492
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009493 CmdArgs.push_back("--end-group");
9494 }
9495
9496 if (!Args.hasArg(options::OPT_nostartfiles)) {
9497 const char *crtend;
9498 if (Args.hasArg(options::OPT_shared))
9499 crtend = "crtendS.o";
9500 else
9501 crtend = "crtend.o";
9502
9503 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
9504 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
9505 }
9506 }
9507
Peter Collingbourne39719a72015-11-20 20:49:39 +00009508 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
9509 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Derek Schuff6ab52fa2015-03-30 20:31:33 +00009510}
9511
Douglas Katzman95354292015-06-23 20:42:09 +00009512void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9513 const InputInfo &Output,
9514 const InputInfoList &Inputs,
9515 const ArgList &Args,
9516 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009517 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009518 ArgStringList CmdArgs;
9519
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009520 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009521
9522 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00009523 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00009524
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009525 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00009526 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00009527
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009528 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009529 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009530}
9531
Douglas Katzman95354292015-06-23 20:42:09 +00009532void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9533 const InputInfo &Output,
9534 const InputInfoList &Inputs,
9535 const ArgList &Args,
9536 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00009537 const Driver &D = getToolChain().getDriver();
9538 ArgStringList CmdArgs;
9539
Daniel Dunbarb440f562010-08-02 02:38:21 +00009540 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00009541 CmdArgs.push_back("-o");
9542 CmdArgs.push_back(Output.getFilename());
9543 } else {
9544 assert(Output.isNothing() && "Invalid output.");
9545 }
9546
Douglas Katzman78b37b02015-11-17 20:28:07 +00009547 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009548 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
9549 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
9550 CmdArgs.push_back(
9551 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
9552 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Eli Friedman83de5132011-12-08 23:54:21 +00009553 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00009554
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009555 Args.AddAllArgs(CmdArgs,
9556 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Chris Lattner3e2ee142010-07-07 16:01:42 +00009557
Daniel Dunbar54423b22010-09-17 00:24:54 +00009558 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009559
Xinliang David Li69306c02015-10-22 06:15:31 +00009560 getToolChain().addProfileRTLibs(Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00009561
Douglas Katzman78b37b02015-11-17 20:28:07 +00009562 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00009563 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00009564 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009565 CmdArgs.push_back("-lm");
9566 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00009567 }
9568
Douglas Katzman78b37b02015-11-17 20:28:07 +00009569 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00009570 if (Args.hasArg(options::OPT_pthread))
9571 CmdArgs.push_back("-lpthread");
9572 CmdArgs.push_back("-lc");
9573 CmdArgs.push_back("-lCompilerRT-Generic");
9574 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
9575 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009576 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009577 }
9578
Logan Chieneb9162f2014-06-26 14:23:45 +00009579 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00009580 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00009581}
9582
Daniel Dunbarcc912342009-05-02 18:28:39 +00009583/// DragonFly Tools
9584
9585// For now, DragonFly Assemble does just about the same as for
9586// FreeBSD, but this may change soon.
Douglas Katzman95354292015-06-23 20:42:09 +00009587void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9588 const InputInfo &Output,
9589 const InputInfoList &Inputs,
9590 const ArgList &Args,
9591 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009592 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009593 ArgStringList CmdArgs;
9594
9595 // When building 32-bit code on DragonFly/pc64, we have to explicitly
9596 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00009597 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00009598 CmdArgs.push_back("--32");
9599
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009600 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009601
9602 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00009603 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00009604
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009605 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00009606 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00009607
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009608 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009609 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009610}
9611
Douglas Katzman95354292015-06-23 20:42:09 +00009612void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9613 const InputInfo &Output,
9614 const InputInfoList &Inputs,
9615 const ArgList &Args,
9616 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00009617 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00009618 ArgStringList CmdArgs;
John McCall65b8da02013-04-11 22:55:55 +00009619
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00009620 if (!D.SysRoot.empty())
9621 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9622
John McCall65b8da02013-04-11 22:55:55 +00009623 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009624 if (Args.hasArg(options::OPT_static)) {
9625 CmdArgs.push_back("-Bstatic");
9626 } else {
John McCall65b8da02013-04-11 22:55:55 +00009627 if (Args.hasArg(options::OPT_rdynamic))
9628 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009629 if (Args.hasArg(options::OPT_shared))
9630 CmdArgs.push_back("-Bshareable");
9631 else {
9632 CmdArgs.push_back("-dynamic-linker");
9633 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
9634 }
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009635 CmdArgs.push_back("--hash-style=gnu");
9636 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009637 }
9638
9639 // When building 32-bit code on DragonFly/pc64, we have to explicitly
9640 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00009641 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009642 CmdArgs.push_back("-m");
9643 CmdArgs.push_back("elf_i386");
9644 }
9645
Daniel Dunbarb440f562010-08-02 02:38:21 +00009646 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009647 CmdArgs.push_back("-o");
9648 CmdArgs.push_back(Output.getFilename());
9649 } else {
9650 assert(Output.isNothing() && "Invalid output.");
9651 }
9652
Douglas Katzman78b37b02015-11-17 20:28:07 +00009653 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00009654 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00009655 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009656 CmdArgs.push_back(
9657 Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009658 else {
9659 if (Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009660 CmdArgs.push_back(
9661 Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009662 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009663 CmdArgs.push_back(
9664 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009665 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009666 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009667 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
John McCall65b8da02013-04-11 22:55:55 +00009668 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009669 CmdArgs.push_back(
9670 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009671 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009672 CmdArgs.push_back(
9673 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009674 }
9675
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009676 Args.AddAllArgs(CmdArgs,
9677 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Daniel Dunbarcc912342009-05-02 18:28:39 +00009678
Daniel Dunbar54423b22010-09-17 00:24:54 +00009679 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009680
Douglas Katzman78b37b02015-11-17 20:28:07 +00009681 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009682 CmdArgs.push_back("-L/usr/lib/gcc50");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009683
9684 if (!Args.hasArg(options::OPT_static)) {
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009685 CmdArgs.push_back("-rpath");
9686 CmdArgs.push_back("/usr/lib/gcc50");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009687 }
9688
Hans Wennborg70850d82013-07-18 20:29:38 +00009689 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00009690 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00009691 CmdArgs.push_back("-lm");
9692 }
9693
Daniel Dunbarcc912342009-05-02 18:28:39 +00009694 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00009695 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009696
9697 if (!Args.hasArg(options::OPT_nolibc)) {
9698 CmdArgs.push_back("-lc");
9699 }
9700
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009701 if (Args.hasArg(options::OPT_static) ||
9702 Args.hasArg(options::OPT_static_libgcc)) {
John McCall65b8da02013-04-11 22:55:55 +00009703 CmdArgs.push_back("-lgcc");
9704 CmdArgs.push_back("-lgcc_eh");
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009705 } else {
9706 if (Args.hasArg(options::OPT_shared_libgcc)) {
John McCall65b8da02013-04-11 22:55:55 +00009707 CmdArgs.push_back("-lgcc_pic");
9708 if (!Args.hasArg(options::OPT_shared))
9709 CmdArgs.push_back("-lgcc");
Dimitry Andricf59a2b32015-12-27 10:01:44 +00009710 } else {
John McCall65b8da02013-04-11 22:55:55 +00009711 CmdArgs.push_back("-lgcc");
9712 CmdArgs.push_back("--as-needed");
9713 CmdArgs.push_back("-lgcc_pic");
9714 CmdArgs.push_back("--no-as-needed");
John McCall65b8da02013-04-11 22:55:55 +00009715 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009716 }
9717 }
9718
Douglas Katzman78b37b02015-11-17 20:28:07 +00009719 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00009720 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009721 CmdArgs.push_back(
9722 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009723 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009724 CmdArgs.push_back(
9725 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
9726 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009727 }
9728
Xinliang David Li69306c02015-10-22 06:15:31 +00009729 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00009730
Logan Chieneb9162f2014-06-26 14:23:45 +00009731 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00009732 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009733}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009734
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009735// Try to find Exe from a Visual Studio distribution. This first tries to find
9736// an installed copy of Visual Studio and, failing that, looks in the PATH,
9737// making sure that whatever executable that's found is not a same-named exe
9738// from clang itself to prevent clang from falling back to itself.
9739static std::string FindVisualStudioExecutable(const ToolChain &TC,
9740 const char *Exe,
9741 const char *ClangProgramPath) {
9742 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
9743 std::string visualStudioBinDir;
9744 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
9745 visualStudioBinDir)) {
9746 SmallString<128> FilePath(visualStudioBinDir);
9747 llvm::sys::path::append(FilePath, Exe);
9748 if (llvm::sys::fs::can_execute(FilePath.c_str()))
9749 return FilePath.str();
9750 }
9751
9752 return Exe;
9753}
9754
Douglas Katzman95354292015-06-23 20:42:09 +00009755void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9756 const InputInfo &Output,
9757 const InputInfoList &Inputs,
9758 const ArgList &Args,
9759 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009760 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009761 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009762
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00009763 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
9764 if (Output.isFilename())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009765 CmdArgs.push_back(
9766 Args.MakeArgString(std::string("-out:") + Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009767
Douglas Katzman78b37b02015-11-17 20:28:07 +00009768 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
9769 !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009770 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009771
Zachary Turner10d75b22014-10-22 20:40:43 +00009772 if (!llvm::sys::Process::GetEnv("LIB")) {
9773 // If the VC environment hasn't been configured (perhaps because the user
9774 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00009775 // the environment variable is set however, assume the user knows what
9776 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00009777 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009778 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00009779 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
9780 SmallString<128> LibDir(VisualStudioDir);
9781 llvm::sys::path::append(LibDir, "VC", "lib");
9782 switch (MSVC.getArch()) {
9783 case llvm::Triple::x86:
9784 // x86 just puts the libraries directly in lib
9785 break;
9786 case llvm::Triple::x86_64:
9787 llvm::sys::path::append(LibDir, "amd64");
9788 break;
9789 case llvm::Triple::arm:
9790 llvm::sys::path::append(LibDir, "arm");
9791 break;
9792 default:
9793 break;
9794 }
9795 CmdArgs.push_back(
9796 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
Reid Kleckner7531f7d2015-09-11 00:09:39 +00009797
9798 if (MSVC.useUniversalCRT(VisualStudioDir)) {
9799 std::string UniversalCRTLibPath;
9800 if (MSVC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
9801 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9802 UniversalCRTLibPath.c_str()));
9803 }
Zachary Turner10d75b22014-10-22 20:40:43 +00009804 }
9805
9806 std::string WindowsSdkLibPath;
9807 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
9808 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9809 WindowsSdkLibPath.c_str()));
9810 }
9811
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009812 CmdArgs.push_back("-nologo");
9813
Reid Kleckner124955a2015-08-05 18:51:13 +00009814 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009815 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009816
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009817 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
Hans Wennborge4c47f22015-03-04 23:16:21 +00009818 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00009819 if (DLL) {
9820 CmdArgs.push_back(Args.MakeArgString("-dll"));
9821
9822 SmallString<128> ImplibName(Output.getFilename());
9823 llvm::sys::path::replace_extension(ImplibName, "lib");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009824 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00009825 }
9826
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009827 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00009828 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00009829 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009830 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009831 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
9832 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00009833 // Make sure the dynamic runtime thunk is not optimized out at link time
9834 // to ensure proper SEH handling.
9835 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009836 } else if (DLL) {
Xinliang David Li69306c02015-10-22 06:15:31 +00009837 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009838 } else {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009839 for (const auto &Lib : {"asan", "asan_cxx"})
9840 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009841 }
Hans Wennborg65f17522013-08-27 18:10:21 +00009842 }
9843
Hans Wennborg2e274592013-08-13 23:38:57 +00009844 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00009845
Alexey Bataevc7e84352015-08-19 04:49:01 +00009846 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9847 options::OPT_fno_openmp, false)) {
9848 CmdArgs.push_back("-nodefaultlib:vcomp.lib");
9849 CmdArgs.push_back("-nodefaultlib:vcompd.lib");
9850 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9851 TC.getDriver().Dir + "/../lib"));
9852 switch (getOpenMPRuntime(getToolChain(), Args)) {
9853 case OMPRT_OMP:
9854 CmdArgs.push_back("-defaultlib:libomp.lib");
9855 break;
9856 case OMPRT_IOMP5:
9857 CmdArgs.push_back("-defaultlib:libiomp5md.lib");
9858 break;
9859 case OMPRT_GOMP:
9860 break;
9861 case OMPRT_Unknown:
9862 // Already diagnosed.
9863 break;
9864 }
9865 }
9866
Andrey Turetskiya4868572016-03-14 11:19:43 +00009867 // Add compiler-rt lib in case if it was explicitly
9868 // specified as an argument for --rtlib option.
9869 if (!Args.hasArg(options::OPT_nostdlib)) {
9870 AddRunTimeLibs(TC, TC.getDriver(), CmdArgs, Args);
9871 }
9872
Reid Kleckner337188f2014-09-16 19:22:00 +00009873 // Add filenames, libraries, and other linker inputs.
9874 for (const auto &Input : Inputs) {
9875 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009876 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00009877 continue;
9878 }
9879
9880 const Arg &A = Input.getInputArg();
9881
9882 // Render -l options differently for the MSVC linker.
9883 if (A.getOption().matches(options::OPT_l)) {
9884 StringRef Lib = A.getValue();
9885 const char *LinkLibArg;
9886 if (Lib.endswith(".lib"))
9887 LinkLibArg = Args.MakeArgString(Lib);
9888 else
9889 LinkLibArg = Args.MakeArgString(Lib + ".lib");
9890 CmdArgs.push_back(LinkLibArg);
9891 continue;
9892 }
9893
9894 // Otherwise, this is some other kind of linker input option like -Wl, -z,
9895 // or -L. Render it, even if MSVC doesn't understand it.
9896 A.renderAsInput(Args, CmdArgs);
9897 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009898
Nathan Slingerlande8ddf9e2016-01-05 18:27:06 +00009899 TC.addProfileRTLibs(Args, CmdArgs);
9900
Zachary Turner719f58c2014-12-01 23:06:47 +00009901 // We need to special case some linker paths. In the case of lld, we need to
9902 // translate 'lld' into 'lld-link', and in the case of the regular msvc
9903 // linker, we need to use a special search algorithm.
9904 llvm::SmallString<128> linkPath;
9905 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
9906 if (Linker.equals_lower("lld"))
9907 Linker = "lld-link";
9908
9909 if (Linker.equals_lower("link")) {
9910 // If we're using the MSVC linker, it's not sufficient to just use link
9911 // from the program PATH, because other environments like GnuWin32 install
9912 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009913 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00009914 C.getDriver().getClangProgramPath());
9915 } else {
9916 linkPath = Linker;
9917 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009918 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00009919 }
9920
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009921 const char *Exec = Args.MakeArgString(linkPath);
Justin Bognerd3371d82015-07-17 03:35:54 +00009922 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009923}
Hans Wennborg87cfa712013-09-19 20:32:16 +00009924
Douglas Katzman95354292015-06-23 20:42:09 +00009925void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9926 const InputInfo &Output,
9927 const InputInfoList &Inputs,
9928 const ArgList &Args,
9929 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009930 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
9931}
9932
Douglas Katzman95354292015-06-23 20:42:09 +00009933std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
David Blaikiec11bf802014-09-04 16:04:28 +00009934 Compilation &C, const JobAction &JA, const InputInfo &Output,
9935 const InputInfoList &Inputs, const ArgList &Args,
9936 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009937 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00009938 CmdArgs.push_back("/nologo");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009939 CmdArgs.push_back("/c"); // Compile only.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009940 CmdArgs.push_back("/W0"); // No warnings.
9941
9942 // The goal is to be able to invoke this tool correctly based on
9943 // any flag accepted by clang-cl.
9944
9945 // These are spelled the same way in clang and cl.exe,.
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009946 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009947
9948 // Optimization level.
David Majnemer015ce0f2015-07-27 07:32:11 +00009949 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
9950 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"
9951 : "/Oi-");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009952 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
9953 if (A->getOption().getID() == options::OPT_O0) {
9954 CmdArgs.push_back("/Od");
9955 } else {
David Majnemer015ce0f2015-07-27 07:32:11 +00009956 CmdArgs.push_back("/Og");
9957
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009958 StringRef OptLevel = A->getValue();
David Majnemer015ce0f2015-07-27 07:32:11 +00009959 if (OptLevel == "s" || OptLevel == "z")
9960 CmdArgs.push_back("/Os");
9961 else
9962 CmdArgs.push_back("/Ot");
9963
9964 CmdArgs.push_back("/Ob2");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009965 }
9966 }
David Majnemer015ce0f2015-07-27 07:32:11 +00009967 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
9968 options::OPT_fno_omit_frame_pointer))
9969 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
9970 ? "/Oy"
9971 : "/Oy-");
9972 if (!Args.hasArg(options::OPT_fwritable_strings))
9973 CmdArgs.push_back("/GF");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009974
Nico Weber3f8dafb2015-03-12 19:37:10 +00009975 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009976 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
9977
David Majnemerf6072342014-07-01 22:24:56 +00009978 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
9979 /*default=*/false))
9980 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00009981 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
9982 options::OPT_fno_function_sections))
9983 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
9984 ? "/Gy"
9985 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00009986 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
9987 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00009988 CmdArgs.push_back(
9989 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009990 if (Args.hasArg(options::OPT_fsyntax_only))
9991 CmdArgs.push_back("/Zs");
Reid Kleckner124955a2015-08-05 18:51:13 +00009992 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
9993 options::OPT__SLASH_Z7))
Reid Klecknerc688daf2014-02-19 22:05:59 +00009994 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009995
Nico Weber3f8dafb2015-03-12 19:37:10 +00009996 std::vector<std::string> Includes =
9997 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009998 for (const auto &Include : Includes)
9999 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +000010000
Hans Wennborg87cfa712013-09-19 20:32:16 +000010001 // Flags that can simply be passed through.
10002 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
10003 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
David Majnemerb8809092016-02-20 09:23:44 +000010004 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX);
10005 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX_);
Reid Klecknerc542d372014-06-27 17:02:02 +000010006 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
David Majnemerbac941c2015-07-25 06:07:59 +000010007 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
Hans Wennborg87cfa712013-09-19 20:32:16 +000010008
10009 // The order of these flags is relevant, so pick the last one.
10010 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
10011 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
10012 A->render(Args, CmdArgs);
10013
Ehsan Akhgarid8518332016-01-25 21:14:52 +000010014 // Pass through all unknown arguments so that the fallback command can see
10015 // them too.
10016 Args.AddAllArgs(CmdArgs, options::OPT_UNKNOWN);
10017
Hans Wennborg87cfa712013-09-19 20:32:16 +000010018 // Input filename.
10019 assert(Inputs.size() == 1);
10020 const InputInfo &II = Inputs[0];
10021 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
10022 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
10023 if (II.isFilename())
10024 CmdArgs.push_back(II.getFilename());
10025 else
10026 II.getInputArg().renderAsInput(Args, CmdArgs);
10027
10028 // Output filename.
10029 assert(Output.getType() == types::TY_Object);
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010030 const char *Fo =
10031 Args.MakeArgString(std::string("/Fo") + Output.getFilename());
Hans Wennborg87cfa712013-09-19 20:32:16 +000010032 CmdArgs.push_back(Fo);
10033
Hans Wennborg188382e2013-09-20 18:16:35 +000010034 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +000010035 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
10036 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +000010037 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
Justin Bognerd3371d82015-07-17 03:35:54 +000010038 CmdArgs, Inputs);
Hans Wennborg87cfa712013-09-19 20:32:16 +000010039}
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010040
Yaron Keren1c0070c2015-07-02 04:45:27 +000010041/// MinGW Tools
10042void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10043 const InputInfo &Output,
10044 const InputInfoList &Inputs,
10045 const ArgList &Args,
10046 const char *LinkingOutput) const {
10047 claimNoWarnArgs(Args);
10048 ArgStringList CmdArgs;
10049
10050 if (getToolChain().getArch() == llvm::Triple::x86) {
10051 CmdArgs.push_back("--32");
10052 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
10053 CmdArgs.push_back("--64");
10054 }
10055
10056 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10057
10058 CmdArgs.push_back("-o");
10059 CmdArgs.push_back(Output.getFilename());
10060
10061 for (const auto &II : Inputs)
10062 CmdArgs.push_back(II.getFilename());
10063
10064 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010065 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +000010066
10067 if (Args.hasArg(options::OPT_gsplit_dwarf))
10068 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
10069 SplitDebugName(Args, Inputs[0]));
10070}
10071
10072void MinGW::Linker::AddLibGCC(const ArgList &Args,
10073 ArgStringList &CmdArgs) const {
10074 if (Args.hasArg(options::OPT_mthreads))
10075 CmdArgs.push_back("-lmingwthrd");
10076 CmdArgs.push_back("-lmingw32");
Reid Kleckner0213a472015-07-22 16:01:38 +000010077
Yaron Kerenaa281332015-08-09 00:24:07 +000010078 // Make use of compiler-rt if --rtlib option is used
10079 ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
10080 if (RLT == ToolChain::RLT_Libgcc) {
10081 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
10082 Args.hasArg(options::OPT_static);
10083 bool Shared = Args.hasArg(options::OPT_shared);
10084 bool CXX = getToolChain().getDriver().CCCIsCXX();
10085
10086 if (Static || (!CXX && !Shared)) {
10087 CmdArgs.push_back("-lgcc");
10088 CmdArgs.push_back("-lgcc_eh");
10089 } else {
10090 CmdArgs.push_back("-lgcc_s");
10091 CmdArgs.push_back("-lgcc");
10092 }
10093 } else {
10094 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
10095 }
Reid Kleckner0213a472015-07-22 16:01:38 +000010096
Yaron Keren1c0070c2015-07-02 04:45:27 +000010097 CmdArgs.push_back("-lmoldname");
10098 CmdArgs.push_back("-lmingwex");
10099 CmdArgs.push_back("-lmsvcrt");
10100}
10101
10102void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10103 const InputInfo &Output,
10104 const InputInfoList &Inputs,
10105 const ArgList &Args,
10106 const char *LinkingOutput) const {
10107 const ToolChain &TC = getToolChain();
10108 const Driver &D = TC.getDriver();
10109 // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
10110
10111 ArgStringList CmdArgs;
10112
10113 // Silence warning for "clang -g foo.o -o foo"
10114 Args.ClaimAllArgs(options::OPT_g_Group);
10115 // and "clang -emit-llvm foo.o -o foo"
10116 Args.ClaimAllArgs(options::OPT_emit_llvm);
10117 // and for "clang -w foo.o -o foo". Other warning options are already
10118 // handled somewhere else.
10119 Args.ClaimAllArgs(options::OPT_w);
10120
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010121 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
10122 if (LinkerName.equals_lower("lld")) {
10123 CmdArgs.push_back("-flavor");
Martell Maloneaac044e2015-11-22 05:40:06 +000010124 CmdArgs.push_back("gnu");
Yaron Kerena7fa79f2015-11-15 08:06:27 +000010125 } else if (!LinkerName.equals_lower("ld")) {
10126 D.Diag(diag::err_drv_unsupported_linker) << LinkerName;
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010127 }
10128
Yaron Keren1c0070c2015-07-02 04:45:27 +000010129 if (!D.SysRoot.empty())
10130 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10131
10132 if (Args.hasArg(options::OPT_s))
10133 CmdArgs.push_back("-s");
10134
10135 CmdArgs.push_back("-m");
10136 if (TC.getArch() == llvm::Triple::x86)
10137 CmdArgs.push_back("i386pe");
10138 if (TC.getArch() == llvm::Triple::x86_64)
10139 CmdArgs.push_back("i386pep");
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010140 if (TC.getArch() == llvm::Triple::arm)
10141 CmdArgs.push_back("thumb2pe");
Yaron Keren1c0070c2015-07-02 04:45:27 +000010142
10143 if (Args.hasArg(options::OPT_mwindows)) {
10144 CmdArgs.push_back("--subsystem");
10145 CmdArgs.push_back("windows");
10146 } else if (Args.hasArg(options::OPT_mconsole)) {
10147 CmdArgs.push_back("--subsystem");
10148 CmdArgs.push_back("console");
10149 }
10150
10151 if (Args.hasArg(options::OPT_static))
10152 CmdArgs.push_back("-Bstatic");
10153 else {
10154 if (Args.hasArg(options::OPT_mdll))
10155 CmdArgs.push_back("--dll");
10156 else if (Args.hasArg(options::OPT_shared))
10157 CmdArgs.push_back("--shared");
10158 CmdArgs.push_back("-Bdynamic");
10159 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
10160 CmdArgs.push_back("-e");
10161 if (TC.getArch() == llvm::Triple::x86)
10162 CmdArgs.push_back("_DllMainCRTStartup@12");
10163 else
10164 CmdArgs.push_back("DllMainCRTStartup");
10165 CmdArgs.push_back("--enable-auto-image-base");
10166 }
10167 }
10168
10169 CmdArgs.push_back("-o");
10170 CmdArgs.push_back(Output.getFilename());
10171
10172 Args.AddAllArgs(CmdArgs, options::OPT_e);
10173 // FIXME: add -N, -n flags
10174 Args.AddLastArg(CmdArgs, options::OPT_r);
10175 Args.AddLastArg(CmdArgs, options::OPT_s);
10176 Args.AddLastArg(CmdArgs, options::OPT_t);
10177 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
10178 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
10179
Douglas Katzman78b37b02015-11-17 20:28:07 +000010180 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Yaron Keren1c0070c2015-07-02 04:45:27 +000010181 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
10182 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
10183 } else {
10184 if (Args.hasArg(options::OPT_municode))
10185 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
10186 else
10187 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
10188 }
10189 if (Args.hasArg(options::OPT_pg))
10190 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
10191 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
10192 }
10193
10194 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010195 TC.AddFilePathLibArgs(Args, CmdArgs);
Yaron Keren1c0070c2015-07-02 04:45:27 +000010196 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
10197
10198 // TODO: Add ASan stuff here
10199
10200 // TODO: Add profile stuff here
10201
Douglas Katzman78b37b02015-11-17 20:28:07 +000010202 if (D.CCCIsCXX() &&
10203 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Yaron Keren1c0070c2015-07-02 04:45:27 +000010204 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
10205 !Args.hasArg(options::OPT_static);
10206 if (OnlyLibstdcxxStatic)
10207 CmdArgs.push_back("-Bstatic");
10208 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
10209 if (OnlyLibstdcxxStatic)
10210 CmdArgs.push_back("-Bdynamic");
10211 }
10212
10213 if (!Args.hasArg(options::OPT_nostdlib)) {
10214 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
10215 if (Args.hasArg(options::OPT_static))
10216 CmdArgs.push_back("--start-group");
10217
10218 if (Args.hasArg(options::OPT_fstack_protector) ||
10219 Args.hasArg(options::OPT_fstack_protector_strong) ||
10220 Args.hasArg(options::OPT_fstack_protector_all)) {
10221 CmdArgs.push_back("-lssp_nonshared");
10222 CmdArgs.push_back("-lssp");
10223 }
10224 if (Args.hasArg(options::OPT_fopenmp))
10225 CmdArgs.push_back("-lgomp");
10226
10227 AddLibGCC(Args, CmdArgs);
10228
10229 if (Args.hasArg(options::OPT_pg))
10230 CmdArgs.push_back("-lgmon");
10231
Yaron Kerenadce68e2015-07-06 18:52:19 +000010232 if (Args.hasArg(options::OPT_pthread))
10233 CmdArgs.push_back("-lpthread");
Yaron Keren1c0070c2015-07-02 04:45:27 +000010234
10235 // add system libraries
10236 if (Args.hasArg(options::OPT_mwindows)) {
10237 CmdArgs.push_back("-lgdi32");
10238 CmdArgs.push_back("-lcomdlg32");
10239 }
10240 CmdArgs.push_back("-ladvapi32");
10241 CmdArgs.push_back("-lshell32");
10242 CmdArgs.push_back("-luser32");
10243 CmdArgs.push_back("-lkernel32");
10244
10245 if (Args.hasArg(options::OPT_static))
10246 CmdArgs.push_back("--end-group");
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010247 else if (!LinkerName.equals_lower("lld"))
Yaron Keren1c0070c2015-07-02 04:45:27 +000010248 AddLibGCC(Args, CmdArgs);
10249 }
10250
10251 if (!Args.hasArg(options::OPT_nostartfiles)) {
10252 // Add crtfastmath.o if available and fast math is enabled.
10253 TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
10254
10255 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
10256 }
10257 }
Yaron Keren2ffb36e2015-07-14 05:23:34 +000010258 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
Justin Bognerd3371d82015-07-17 03:35:54 +000010259 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +000010260}
10261
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010262/// XCore Tools
10263// We pass assemble and link construction to the xcc tool.
10264
Douglas Katzman95354292015-06-23 20:42:09 +000010265void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10266 const InputInfo &Output,
10267 const InputInfoList &Inputs,
10268 const ArgList &Args,
10269 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +000010270 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010271 ArgStringList CmdArgs;
10272
10273 CmdArgs.push_back("-o");
10274 CmdArgs.push_back(Output.getFilename());
10275
10276 CmdArgs.push_back("-c");
10277
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010278 if (Args.hasArg(options::OPT_v))
10279 CmdArgs.push_back("-v");
10280
Robert Lytton894d25c2014-05-02 09:33:25 +000010281 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
10282 if (!A->getOption().matches(options::OPT_g0))
10283 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010284
Robert Lytton8e95d4e2014-02-11 10:34:45 +000010285 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
10286 false))
10287 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010288
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010289 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010290
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010291 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010292 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010293
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010294 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010295 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010296}
10297
Douglas Katzman95354292015-06-23 20:42:09 +000010298void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10299 const InputInfo &Output,
10300 const InputInfoList &Inputs,
10301 const ArgList &Args,
10302 const char *LinkingOutput) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010303 ArgStringList CmdArgs;
10304
10305 if (Output.isFilename()) {
10306 CmdArgs.push_back("-o");
10307 CmdArgs.push_back(Output.getFilename());
10308 } else {
10309 assert(Output.isNothing() && "Invalid output.");
10310 }
10311
Robert Lytton9e8c1a42014-02-13 10:40:12 +000010312 if (Args.hasArg(options::OPT_v))
10313 CmdArgs.push_back("-v");
10314
Reid Kleckner0bb1fc42015-07-10 22:25:44 +000010315 // Pass -fexceptions through to the linker if it was present.
10316 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
10317 false))
Robert Lyttonf7e03c12014-02-13 10:34:44 +000010318 CmdArgs.push_back("-fexceptions");
10319
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010320 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
10321
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +000010322 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010323 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +000010324}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010325
Douglas Katzman95354292015-06-23 20:42:09 +000010326void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10327 const InputInfo &Output,
10328 const InputInfoList &Inputs,
10329 const ArgList &Args,
10330 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +000010331 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010332 const auto &TC =
10333 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
10334 ArgStringList CmdArgs;
10335 const char *Exec;
10336
10337 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010338 default:
10339 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010340 case llvm::Triple::arm:
10341 case llvm::Triple::thumb:
10342 break;
10343 case llvm::Triple::x86:
10344 CmdArgs.push_back("--32");
10345 break;
10346 case llvm::Triple::x86_64:
10347 CmdArgs.push_back("--64");
10348 break;
10349 }
10350
10351 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10352
10353 CmdArgs.push_back("-o");
10354 CmdArgs.push_back(Output.getFilename());
10355
10356 for (const auto &Input : Inputs)
10357 CmdArgs.push_back(Input.getFilename());
10358
10359 const std::string Assembler = TC.GetProgramPath("as");
10360 Exec = Args.MakeArgString(Assembler);
10361
Justin Bognerd3371d82015-07-17 03:35:54 +000010362 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010363}
10364
Douglas Katzman95354292015-06-23 20:42:09 +000010365void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10366 const InputInfo &Output,
10367 const InputInfoList &Inputs,
10368 const ArgList &Args,
10369 const char *LinkingOutput) const {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010370 const auto &TC =
10371 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
10372 const llvm::Triple &T = TC.getTriple();
10373 const Driver &D = TC.getDriver();
10374 SmallString<128> EntryPoint;
10375 ArgStringList CmdArgs;
10376 const char *Exec;
10377
10378 // Silence warning for "clang -g foo.o -o foo"
10379 Args.ClaimAllArgs(options::OPT_g_Group);
10380 // and "clang -emit-llvm foo.o -o foo"
10381 Args.ClaimAllArgs(options::OPT_emit_llvm);
10382 // and for "clang -w foo.o -o foo"
10383 Args.ClaimAllArgs(options::OPT_w);
10384 // Other warning options are already handled somewhere else.
10385
10386 if (!D.SysRoot.empty())
10387 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10388
10389 if (Args.hasArg(options::OPT_pie))
10390 CmdArgs.push_back("-pie");
10391 if (Args.hasArg(options::OPT_rdynamic))
10392 CmdArgs.push_back("-export-dynamic");
10393 if (Args.hasArg(options::OPT_s))
10394 CmdArgs.push_back("--strip-all");
10395
10396 CmdArgs.push_back("-m");
10397 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010398 default:
10399 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010400 case llvm::Triple::arm:
10401 case llvm::Triple::thumb:
10402 // FIXME: this is incorrect for WinCE
10403 CmdArgs.push_back("thumb2pe");
10404 break;
10405 case llvm::Triple::x86:
10406 CmdArgs.push_back("i386pe");
10407 EntryPoint.append("_");
10408 break;
10409 case llvm::Triple::x86_64:
10410 CmdArgs.push_back("i386pep");
10411 break;
10412 }
10413
10414 if (Args.hasArg(options::OPT_shared)) {
10415 switch (T.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +000010416 default:
10417 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010418 case llvm::Triple::arm:
10419 case llvm::Triple::thumb:
10420 case llvm::Triple::x86_64:
10421 EntryPoint.append("_DllMainCRTStartup");
10422 break;
10423 case llvm::Triple::x86:
10424 EntryPoint.append("_DllMainCRTStartup@12");
10425 break;
10426 }
10427
10428 CmdArgs.push_back("-shared");
10429 CmdArgs.push_back("-Bdynamic");
10430
10431 CmdArgs.push_back("--enable-auto-image-base");
10432
10433 CmdArgs.push_back("--entry");
10434 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10435 } else {
10436 EntryPoint.append("mainCRTStartup");
10437
10438 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
10439 : "-Bdynamic");
10440
Douglas Katzman78b37b02015-11-17 20:28:07 +000010441 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010442 CmdArgs.push_back("--entry");
10443 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10444 }
10445
10446 // FIXME: handle subsystem
10447 }
10448
10449 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +000010450 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010451
10452 CmdArgs.push_back("-o");
10453 CmdArgs.push_back(Output.getFilename());
10454
10455 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
10456 SmallString<261> ImpLib(Output.getFilename());
10457 llvm::sys::path::replace_extension(ImpLib, ".lib");
10458
10459 CmdArgs.push_back("--out-implib");
10460 CmdArgs.push_back(Args.MakeArgString(ImpLib));
10461 }
10462
Douglas Katzman78b37b02015-11-17 20:28:07 +000010463 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010464 const std::string CRTPath(D.SysRoot + "/usr/lib/");
10465 const char *CRTBegin;
10466
10467 CRTBegin =
10468 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
10469 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
10470 }
10471
10472 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010473 TC.AddFilePathLibArgs(Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010474 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
10475
10476 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
10477 !Args.hasArg(options::OPT_nodefaultlibs)) {
10478 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
10479 !Args.hasArg(options::OPT_static);
10480 if (StaticCXX)
10481 CmdArgs.push_back("-Bstatic");
10482 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
10483 if (StaticCXX)
10484 CmdArgs.push_back("-Bdynamic");
10485 }
10486
10487 if (!Args.hasArg(options::OPT_nostdlib)) {
10488 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
10489 // TODO handle /MT[d] /MD[d]
10490 CmdArgs.push_back("-lmsvcrt");
10491 AddRunTimeLibs(TC, D, CmdArgs, Args);
10492 }
10493 }
10494
Saleem Abdulrasoolbb2e5e42015-10-29 03:36:45 +000010495 if (TC.getSanitizerArgs().needsAsanRt()) {
10496 // TODO handle /MT[d] /MD[d]
10497 if (Args.hasArg(options::OPT_shared)) {
10498 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
10499 } else {
10500 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
10501 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Marcin Koscielnicki10721432016-05-12 10:27:59 +000010502 // Make sure the dynamic runtime thunk is not optimized out at link time
10503 // to ensure proper SEH handling.
10504 CmdArgs.push_back(Args.MakeArgString("--undefined"));
10505 CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
10506 ? "___asan_seh_interceptor"
10507 : "__asan_seh_interceptor"));
Saleem Abdulrasoolbb2e5e42015-10-29 03:36:45 +000010508 }
10509 }
10510
Saleem Abdulrasoolfd80f832015-10-28 04:45:58 +000010511 Exec = Args.MakeArgString(TC.GetLinkerPath());
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010512
Justin Bognerd3371d82015-07-17 03:35:54 +000010513 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +000010514}
Douglas Katzman84a75642015-06-19 14:55:19 +000010515
Douglas Katzman95354292015-06-23 20:42:09 +000010516void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
10517 const InputInfo &Output,
10518 const InputInfoList &Inputs,
10519 const ArgList &Args,
10520 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +000010521 ArgStringList CmdArgs;
Douglas Katzman84a75642015-06-19 14:55:19 +000010522 assert(Inputs.size() == 1);
10523 const InputInfo &II = Inputs[0];
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010524 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX ||
10525 II.getType() == types::TY_PP_CXX);
Douglas Katzman84a75642015-06-19 14:55:19 +000010526
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010527 if (JA.getKind() == Action::PreprocessJobClass) {
10528 Args.ClaimAllArgs();
10529 CmdArgs.push_back("-E");
10530 } else {
10531 assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm.
10532 CmdArgs.push_back("-S");
10533 CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified.
10534 }
Douglas Katzman9dc4c622015-11-20 04:58:12 +000010535 CmdArgs.push_back("-DMYRIAD2");
Douglas Katzman84a75642015-06-19 14:55:19 +000010536
Douglas Katzmanf6071112015-08-03 14:34:22 +000010537 // Append all -I, -iquote, -isystem paths, defines/undefines,
10538 // 'f' flags, optimize flags, and warning options.
10539 // These are spelled the same way in clang and moviCompile.
Douglas Katzman38dca882015-09-08 19:29:55 +000010540 Args.AddAllArgs(CmdArgs, {options::OPT_I_Group, options::OPT_clang_i_Group,
Douglas Katzman642e5f92015-11-16 15:38:40 +000010541 options::OPT_std_EQ, options::OPT_D, options::OPT_U,
Douglas Katzman38dca882015-09-08 19:29:55 +000010542 options::OPT_f_Group, options::OPT_f_clang_Group,
10543 options::OPT_g_Group, options::OPT_M_Group,
Douglas Katzman4c125082016-03-15 16:41:31 +000010544 options::OPT_O_Group, options::OPT_W_Group,
10545 options::OPT_mcpu_EQ});
Douglas Katzman38dca882015-09-08 19:29:55 +000010546
10547 // If we're producing a dependency file, and assembly is the final action,
10548 // then the name of the target in the dependency file should be the '.o'
10549 // file, not the '.s' file produced by this step. For example, instead of
10550 // /tmp/mumble.s: mumble.c .../someheader.h
10551 // the filename on the lefthand side should be "mumble.o"
10552 if (Args.getLastArg(options::OPT_MF) && !Args.getLastArg(options::OPT_MT) &&
10553 C.getActions().size() == 1 &&
10554 C.getActions()[0]->getKind() == Action::AssembleJobClass) {
10555 Arg *A = Args.getLastArg(options::OPT_o);
10556 if (A) {
10557 CmdArgs.push_back("-MT");
10558 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
10559 }
10560 }
10561
Douglas Katzman84a75642015-06-19 14:55:19 +000010562 CmdArgs.push_back(II.getFilename());
10563 CmdArgs.push_back("-o");
10564 CmdArgs.push_back(Output.getFilename());
10565
10566 std::string Exec =
10567 Args.MakeArgString(getToolChain().GetProgramPath("moviCompile"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010568 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10569 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +000010570}
10571
Douglas Katzman95354292015-06-23 20:42:09 +000010572void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10573 const InputInfo &Output,
10574 const InputInfoList &Inputs,
10575 const ArgList &Args,
10576 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +000010577 ArgStringList CmdArgs;
10578
10579 assert(Inputs.size() == 1);
10580 const InputInfo &II = Inputs[0];
10581 assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input.
10582 assert(Output.getType() == types::TY_Object);
10583
10584 CmdArgs.push_back("-no6thSlotCompression");
Douglas Katzman4c125082016-03-15 16:41:31 +000010585 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
10586 if (CPUArg)
10587 CmdArgs.push_back(
10588 Args.MakeArgString("-cv:" + StringRef(CPUArg->getValue())));
Douglas Katzman84a75642015-06-19 14:55:19 +000010589 CmdArgs.push_back("-noSPrefixing");
10590 CmdArgs.push_back("-a"); // Mystery option.
Douglas Katzmanae2f3582015-09-11 21:13:46 +000010591 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10592 for (const Arg *A : Args.filtered(options::OPT_I, options::OPT_isystem)) {
10593 A->claim();
Douglas Katzman84a75642015-06-19 14:55:19 +000010594 CmdArgs.push_back(
Douglas Katzmanae2f3582015-09-11 21:13:46 +000010595 Args.MakeArgString(std::string("-i:") + A->getValue(0)));
Douglas Katzman84a75642015-06-19 14:55:19 +000010596 }
10597 CmdArgs.push_back("-elf"); // Output format.
10598 CmdArgs.push_back(II.getFilename());
10599 CmdArgs.push_back(
10600 Args.MakeArgString(std::string("-o:") + Output.getFilename()));
10601
10602 std::string Exec =
10603 Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
Justin Bognerd3371d82015-07-17 03:35:54 +000010604 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10605 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +000010606}
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010607
10608void tools::Myriad::Linker::ConstructJob(Compilation &C, const JobAction &JA,
10609 const InputInfo &Output,
10610 const InputInfoList &Inputs,
10611 const ArgList &Args,
10612 const char *LinkingOutput) const {
10613 const auto &TC =
10614 static_cast<const toolchains::MyriadToolChain &>(getToolChain());
10615 const llvm::Triple &T = TC.getTriple();
10616 ArgStringList CmdArgs;
Eric Christopher3f5d2bc2015-12-08 00:10:13 +000010617 bool UseStartfiles =
10618 !Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles);
Douglas Katzman78b37b02015-11-17 20:28:07 +000010619 bool UseDefaultLibs =
10620 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010621
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010622 if (T.getArch() == llvm::Triple::sparc)
10623 CmdArgs.push_back("-EB");
10624 else // SHAVE assumes little-endian, and sparcel is expressly so.
10625 CmdArgs.push_back("-EL");
10626
10627 // The remaining logic is mostly like gnutools::Linker::ConstructJob,
10628 // but we never pass through a --sysroot option and various other bits.
10629 // For example, there are no sanitizers (yet) nor gold linker.
10630
10631 // Eat some arguments that may be present but have no effect.
10632 Args.ClaimAllArgs(options::OPT_g_Group);
10633 Args.ClaimAllArgs(options::OPT_w);
10634 Args.ClaimAllArgs(options::OPT_static_libgcc);
10635
10636 if (Args.hasArg(options::OPT_s)) // Pass the 'strip' option.
10637 CmdArgs.push_back("-s");
10638
10639 CmdArgs.push_back("-o");
10640 CmdArgs.push_back(Output.getFilename());
10641
10642 if (UseStartfiles) {
10643 // If you want startfiles, it means you want the builtin crti and crtbegin,
10644 // but not crt0. Myriad link commands provide their own crt0.o as needed.
Douglas Katzman674a3122015-11-18 16:24:46 +000010645 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crti.o")));
10646 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010647 }
10648
10649 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
10650 options::OPT_e, options::OPT_s, options::OPT_t,
10651 options::OPT_Z_Flag, options::OPT_r});
10652
Douglas Katzman674a3122015-11-18 16:24:46 +000010653 TC.AddFilePathLibArgs(Args, CmdArgs);
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010654
10655 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
10656
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010657 if (UseDefaultLibs) {
Douglas Katzman795f57f2015-10-09 20:26:20 +000010658 if (C.getDriver().CCCIsCXX())
10659 CmdArgs.push_back("-lstdc++");
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010660 if (T.getOS() == llvm::Triple::RTEMS) {
10661 CmdArgs.push_back("--start-group");
10662 CmdArgs.push_back("-lc");
10663 // You must provide your own "-L" option to enable finding these.
10664 CmdArgs.push_back("-lrtemscpu");
10665 CmdArgs.push_back("-lrtemsbsp");
10666 CmdArgs.push_back("--end-group");
10667 } else {
10668 CmdArgs.push_back("-lc");
10669 }
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010670 CmdArgs.push_back("-lgcc");
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010671 }
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010672 if (UseStartfiles) {
Douglas Katzman674a3122015-11-18 16:24:46 +000010673 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
10674 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtn.o")));
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010675 }
10676
10677 std::string Exec =
10678 Args.MakeArgString(TC.GetProgramPath("sparc-myriad-elf-ld"));
10679 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10680 CmdArgs, Inputs));
10681}
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010682
10683void PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
10684 const InputInfo &Output,
10685 const InputInfoList &Inputs,
10686 const ArgList &Args,
10687 const char *LinkingOutput) const {
10688 claimNoWarnArgs(Args);
10689 ArgStringList CmdArgs;
10690
10691 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10692
10693 CmdArgs.push_back("-o");
10694 CmdArgs.push_back(Output.getFilename());
10695
10696 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
10697 const InputInfo &Input = Inputs[0];
10698 assert(Input.isFilename() && "Invalid input.");
10699 CmdArgs.push_back(Input.getFilename());
10700
10701 const char *Exec =
Paul Robinson9d613612016-05-16 17:22:25 +000010702 Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010703 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
10704}
10705
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010706static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
10707 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
10708 if (SanArgs.needsUbsanRt()) {
10709 CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
10710 }
10711 if (SanArgs.needsAsanRt()) {
10712 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
10713 }
10714}
10715
10716static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
10717 const JobAction &JA, const InputInfo &Output,
10718 const InputInfoList &Inputs,
10719 const ArgList &Args,
10720 const char *LinkingOutput) {
10721 const toolchains::FreeBSD &ToolChain =
10722 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10723 const Driver &D = ToolChain.getDriver();
10724 ArgStringList CmdArgs;
10725
10726 // Silence warning for "clang -g foo.o -o foo"
10727 Args.ClaimAllArgs(options::OPT_g_Group);
10728 // and "clang -emit-llvm foo.o -o foo"
10729 Args.ClaimAllArgs(options::OPT_emit_llvm);
10730 // and for "clang -w foo.o -o foo". Other warning options are already
10731 // handled somewhere else.
10732 Args.ClaimAllArgs(options::OPT_w);
10733
10734 if (!D.SysRoot.empty())
10735 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10736
10737 if (Args.hasArg(options::OPT_pie))
10738 CmdArgs.push_back("-pie");
10739
10740 if (Args.hasArg(options::OPT_rdynamic))
10741 CmdArgs.push_back("-export-dynamic");
10742 if (Args.hasArg(options::OPT_shared))
10743 CmdArgs.push_back("--oformat=so");
10744
10745 if (Output.isFilename()) {
10746 CmdArgs.push_back("-o");
10747 CmdArgs.push_back(Output.getFilename());
10748 } else {
10749 assert(Output.isNothing() && "Invalid output.");
10750 }
10751
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010752 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10753
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010754 Args.AddAllArgs(CmdArgs, options::OPT_L);
10755 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10756 Args.AddAllArgs(CmdArgs, options::OPT_e);
10757 Args.AddAllArgs(CmdArgs, options::OPT_s);
10758 Args.AddAllArgs(CmdArgs, options::OPT_t);
10759 Args.AddAllArgs(CmdArgs, options::OPT_r);
10760
10761 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10762 CmdArgs.push_back("--no-demangle");
10763
10764 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10765
10766 if (Args.hasArg(options::OPT_pthread)) {
10767 CmdArgs.push_back("-lpthread");
10768 }
10769
Paul Robinson9d613612016-05-16 17:22:25 +000010770 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010771
10772 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10773}
10774
10775static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
10776 const JobAction &JA, const InputInfo &Output,
10777 const InputInfoList &Inputs,
10778 const ArgList &Args,
10779 const char *LinkingOutput) {
10780 const toolchains::FreeBSD &ToolChain =
10781 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10782 const Driver &D = ToolChain.getDriver();
10783 ArgStringList CmdArgs;
10784
10785 // Silence warning for "clang -g foo.o -o foo"
10786 Args.ClaimAllArgs(options::OPT_g_Group);
10787 // and "clang -emit-llvm foo.o -o foo"
10788 Args.ClaimAllArgs(options::OPT_emit_llvm);
10789 // and for "clang -w foo.o -o foo". Other warning options are already
10790 // handled somewhere else.
10791 Args.ClaimAllArgs(options::OPT_w);
10792
10793 if (!D.SysRoot.empty())
10794 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10795
10796 if (Args.hasArg(options::OPT_pie))
10797 CmdArgs.push_back("-pie");
10798
10799 if (Args.hasArg(options::OPT_static)) {
10800 CmdArgs.push_back("-Bstatic");
10801 } else {
10802 if (Args.hasArg(options::OPT_rdynamic))
10803 CmdArgs.push_back("-export-dynamic");
10804 CmdArgs.push_back("--eh-frame-hdr");
10805 if (Args.hasArg(options::OPT_shared)) {
10806 CmdArgs.push_back("-Bshareable");
10807 } else {
10808 CmdArgs.push_back("-dynamic-linker");
10809 CmdArgs.push_back("/libexec/ld-elf.so.1");
10810 }
10811 CmdArgs.push_back("--enable-new-dtags");
10812 }
10813
10814 if (Output.isFilename()) {
10815 CmdArgs.push_back("-o");
10816 CmdArgs.push_back(Output.getFilename());
10817 } else {
10818 assert(Output.isNothing() && "Invalid output.");
10819 }
10820
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010821 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10822
Douglas Katzman78b37b02015-11-17 20:28:07 +000010823 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010824 const char *crt1 = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010825 if (!Args.hasArg(options::OPT_shared)) {
10826 if (Args.hasArg(options::OPT_pg))
10827 crt1 = "gcrt1.o";
10828 else if (Args.hasArg(options::OPT_pie))
10829 crt1 = "Scrt1.o";
10830 else
10831 crt1 = "crt1.o";
10832 }
10833 if (crt1)
10834 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
10835
10836 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
10837
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010838 const char *crtbegin = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010839 if (Args.hasArg(options::OPT_static))
10840 crtbegin = "crtbeginT.o";
10841 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10842 crtbegin = "crtbeginS.o";
10843 else
10844 crtbegin = "crtbegin.o";
10845
10846 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
10847 }
10848
10849 Args.AddAllArgs(CmdArgs, options::OPT_L);
Douglas Katzman6059ef92015-11-17 17:41:23 +000010850 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010851 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10852 Args.AddAllArgs(CmdArgs, options::OPT_e);
10853 Args.AddAllArgs(CmdArgs, options::OPT_s);
10854 Args.AddAllArgs(CmdArgs, options::OPT_t);
10855 Args.AddAllArgs(CmdArgs, options::OPT_r);
10856
10857 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10858 CmdArgs.push_back("--no-demangle");
10859
10860 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10861
Douglas Katzman78b37b02015-11-17 20:28:07 +000010862 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010863 // For PS4, we always want to pass libm, libstdc++ and libkernel
10864 // libraries for both C and C++ compilations.
10865 CmdArgs.push_back("-lkernel");
10866 if (D.CCCIsCXX()) {
10867 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
10868 if (Args.hasArg(options::OPT_pg))
10869 CmdArgs.push_back("-lm_p");
10870 else
10871 CmdArgs.push_back("-lm");
10872 }
10873 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
10874 // the default system libraries. Just mimic this for now.
10875 if (Args.hasArg(options::OPT_pg))
10876 CmdArgs.push_back("-lgcc_p");
10877 else
10878 CmdArgs.push_back("-lcompiler_rt");
10879 if (Args.hasArg(options::OPT_static)) {
10880 CmdArgs.push_back("-lstdc++");
10881 } else if (Args.hasArg(options::OPT_pg)) {
10882 CmdArgs.push_back("-lgcc_eh_p");
10883 } else {
10884 CmdArgs.push_back("--as-needed");
10885 CmdArgs.push_back("-lstdc++");
10886 CmdArgs.push_back("--no-as-needed");
10887 }
10888
10889 if (Args.hasArg(options::OPT_pthread)) {
10890 if (Args.hasArg(options::OPT_pg))
10891 CmdArgs.push_back("-lpthread_p");
10892 else
10893 CmdArgs.push_back("-lpthread");
10894 }
10895
10896 if (Args.hasArg(options::OPT_pg)) {
10897 if (Args.hasArg(options::OPT_shared))
10898 CmdArgs.push_back("-lc");
10899 else {
10900 if (Args.hasArg(options::OPT_static)) {
10901 CmdArgs.push_back("--start-group");
10902 CmdArgs.push_back("-lc_p");
10903 CmdArgs.push_back("-lpthread_p");
10904 CmdArgs.push_back("--end-group");
10905 } else {
10906 CmdArgs.push_back("-lc_p");
10907 }
10908 }
10909 CmdArgs.push_back("-lgcc_p");
10910 } else {
10911 if (Args.hasArg(options::OPT_static)) {
10912 CmdArgs.push_back("--start-group");
10913 CmdArgs.push_back("-lc");
10914 CmdArgs.push_back("-lpthread");
10915 CmdArgs.push_back("--end-group");
10916 } else {
10917 CmdArgs.push_back("-lc");
10918 }
10919 CmdArgs.push_back("-lcompiler_rt");
10920 }
10921
10922 if (Args.hasArg(options::OPT_static)) {
10923 CmdArgs.push_back("-lstdc++");
10924 } else if (Args.hasArg(options::OPT_pg)) {
10925 CmdArgs.push_back("-lgcc_eh_p");
10926 } else {
10927 CmdArgs.push_back("--as-needed");
10928 CmdArgs.push_back("-lstdc++");
10929 CmdArgs.push_back("--no-as-needed");
10930 }
10931 }
10932
Douglas Katzman78b37b02015-11-17 20:28:07 +000010933 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010934 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10935 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
10936 else
10937 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
10938 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
10939 }
10940
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010941 const char *Exec =
10942#ifdef LLVM_ON_WIN32
Paul Robinson9d613612016-05-16 17:22:25 +000010943 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010944#else
Paul Robinson9d613612016-05-16 17:22:25 +000010945 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010946#endif
10947
10948 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10949}
10950
10951void PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
10952 const InputInfo &Output,
10953 const InputInfoList &Inputs,
10954 const ArgList &Args,
10955 const char *LinkingOutput) const {
10956 const toolchains::FreeBSD &ToolChain =
10957 static_cast<const toolchains::FreeBSD &>(getToolChain());
10958 const Driver &D = ToolChain.getDriver();
10959 bool PS4Linker;
10960 StringRef LinkerOptName;
10961 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
10962 LinkerOptName = A->getValue();
10963 if (LinkerOptName != "ps4" && LinkerOptName != "gold")
10964 D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
10965 }
10966
10967 if (LinkerOptName == "gold")
10968 PS4Linker = false;
10969 else if (LinkerOptName == "ps4")
10970 PS4Linker = true;
10971 else
10972 PS4Linker = !Args.hasArg(options::OPT_shared);
10973
10974 if (PS4Linker)
10975 ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10976 else
10977 ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10978}
Justin Lebar21e5d4f2016-01-14 21:41:27 +000010979
10980void NVPTX::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
10981 const InputInfo &Output,
10982 const InputInfoList &Inputs,
10983 const ArgList &Args,
10984 const char *LinkingOutput) const {
10985 const auto &TC =
10986 static_cast<const toolchains::CudaToolChain &>(getToolChain());
Justin Lebarb2db4502016-01-23 21:28:08 +000010987 assert(TC.getTriple().isNVPTX() && "Wrong platform");
Justin Lebar21e5d4f2016-01-14 21:41:27 +000010988
10989 std::vector<std::string> gpu_archs =
10990 Args.getAllArgValues(options::OPT_march_EQ);
10991 assert(gpu_archs.size() == 1 && "Exactly one GPU Arch required for ptxas.");
10992 const std::string& gpu_arch = gpu_archs[0];
10993
Justin Lebar21e5d4f2016-01-14 21:41:27 +000010994 ArgStringList CmdArgs;
10995 CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-m64" : "-m32");
Justin Lebarb41f33c2016-04-19 02:27:11 +000010996 if (Args.hasFlag(options::OPT_cuda_noopt_device_debug,
10997 options::OPT_no_cuda_noopt_device_debug, false)) {
Artem Belevich0a0e54c2016-02-16 22:03:20 +000010998 // ptxas does not accept -g option if optimization is enabled, so
10999 // we ignore the compiler's -O* options if we want debug info.
11000 CmdArgs.push_back("-g");
11001 CmdArgs.push_back("--dont-merge-basicblocks");
11002 CmdArgs.push_back("--return-at-end");
11003 } else if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
11004 // Map the -O we received to -O{0,1,2,3}.
11005 //
11006 // TODO: Perhaps we should map host -O2 to ptxas -O3. -O3 is ptxas's
11007 // default, so it may correspond more closely to the spirit of clang -O2.
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011008
Justin Lebar2836dcd2016-01-19 19:52:21 +000011009 // -O3 seems like the least-bad option when -Osomething is specified to
11010 // clang but it isn't handled below.
11011 StringRef OOpt = "3";
11012 if (A->getOption().matches(options::OPT_O4) ||
11013 A->getOption().matches(options::OPT_Ofast))
11014 OOpt = "3";
11015 else if (A->getOption().matches(options::OPT_O0))
11016 OOpt = "0";
11017 else if (A->getOption().matches(options::OPT_O)) {
11018 // -Os, -Oz, and -O(anything else) map to -O2, for lack of better options.
11019 OOpt = llvm::StringSwitch<const char *>(A->getValue())
11020 .Case("1", "1")
11021 .Case("2", "2")
11022 .Case("3", "3")
11023 .Case("s", "2")
11024 .Case("z", "2")
11025 .Default("2");
11026 }
11027 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-O") + OOpt));
11028 } else {
11029 // If no -O was passed, pass -O0 to ptxas -- no opt flag should correspond
11030 // to no optimizations, but ptxas's default is -O3.
11031 CmdArgs.push_back("-O0");
11032 }
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011033
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011034 CmdArgs.push_back("--gpu-name");
11035 CmdArgs.push_back(Args.MakeArgString(gpu_arch));
11036 CmdArgs.push_back("--output-file");
11037 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
11038 for (const auto& II : Inputs)
11039 CmdArgs.push_back(Args.MakeArgString(II.getFilename()));
11040
11041 for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
11042 CmdArgs.push_back(Args.MakeArgString(A));
11043
11044 const char *Exec = Args.MakeArgString(TC.GetProgramPath("ptxas"));
11045 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
11046}
11047
11048// All inputs to this linker must be from CudaDeviceActions, as we need to look
11049// at the Inputs' Actions in order to figure out which GPU architecture they
11050// correspond to.
11051void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
11052 const InputInfo &Output,
11053 const InputInfoList &Inputs,
11054 const ArgList &Args,
11055 const char *LinkingOutput) const {
11056 const auto &TC =
11057 static_cast<const toolchains::CudaToolChain &>(getToolChain());
Justin Lebarb2db4502016-01-23 21:28:08 +000011058 assert(TC.getTriple().isNVPTX() && "Wrong platform");
Justin Lebar21e5d4f2016-01-14 21:41:27 +000011059
11060 ArgStringList CmdArgs;
11061 CmdArgs.push_back("--cuda");
11062 CmdArgs.push_back(TC.getTriple().isArch64Bit() ? "-64" : "-32");
11063 CmdArgs.push_back(Args.MakeArgString("--create"));
11064 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
11065
11066 for (const auto& II : Inputs) {
11067 auto* A = cast<const CudaDeviceAction>(II.getAction());
11068 // We need to pass an Arch of the form "sm_XX" for cubin files and
11069 // "compute_XX" for ptx.
11070 const char *Arch = (II.getType() == types::TY_PP_Asm)
11071 ? A->getComputeArchName()
11072 : A->getGpuArchName();
11073 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("--image=profile=") +
11074 Arch + ",file=" + II.getFilename()));
11075 }
11076
11077 for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
11078 CmdArgs.push_back(Args.MakeArgString(A));
11079
11080 const char *Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
11081 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
11082}