blob: e821de5520be143b97cfc1d8d66af55d1492be07 [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
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +000055static const char *getSparcAsmModeForCPU(StringRef Name,
56 const llvm::Triple &Triple) {
57 if (Triple.getArch() == llvm::Triple::sparcv9) {
58 return llvm::StringSwitch<const char *>(Name)
59 .Case("niagara", "-Av9b")
60 .Case("niagara2", "-Av9b")
61 .Case("niagara3", "-Av9d")
62 .Case("niagara4", "-Av9d")
63 .Default("-Av9");
64 } else {
65 return llvm::StringSwitch<const char *>(Name)
66 .Case("v8", "-Av8")
67 .Case("supersparc", "-Av8")
68 .Case("sparclite", "-Asparclite")
69 .Case("f934", "-Asparclite")
70 .Case("hypersparc", "-Av8")
71 .Case("sparclite86x", "-Asparclite")
72 .Case("sparclet", "-Asparclet")
73 .Case("tsc701", "-Asparclet")
74 .Case("v9", "-Av8plus")
75 .Case("ultrasparc", "-Av8plus")
76 .Case("ultrasparc3", "-Av8plus")
77 .Case("niagara", "-Av8plusb")
78 .Case("niagara2", "-Av8plusb")
79 .Case("niagara3", "-Av8plusd")
80 .Case("niagara4", "-Av8plusd")
81 .Default("-Av8");
82 }
83}
84
Daniel Dunbar64198ef2009-09-10 01:21:05 +000085/// CheckPreprocessingOptions - Perform some validation of preprocessing
86/// arguments that is shared with gcc.
87static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
Hans Wennborg8f008372014-06-11 19:44:53 +000088 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
89 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
90 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000091 D.Diag(diag::err_drv_argument_only_allowed_with)
Hans Wennborg8f008372014-06-11 19:44:53 +000092 << A->getBaseArg().getAsString(Args)
93 << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
94 }
95 }
Daniel Dunbar64198ef2009-09-10 01:21:05 +000096}
97
Daniel Dunbar4eadb602009-09-10 01:21:12 +000098/// CheckCodeGenerationOptions - Perform some validation of code generation
99/// arguments that is shared with gcc.
100static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
101 // In gcc, only ARM checks this, but it seems reasonable to check universally.
102 if (Args.hasArg(options::OPT_static))
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000103 if (const Arg *A =
104 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
105 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
106 << "-static";
Daniel Dunbar4eadb602009-09-10 01:21:12 +0000107}
108
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000109// Add backslashes to escape spaces and other backslashes.
110// This is used for the space-separated argument list specified with
111// the -dwarf-debug-flags option.
112static void EscapeSpacesAndBackslashes(const char *Arg,
113 SmallVectorImpl<char> &Res) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000114 for (; *Arg; ++Arg) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000115 switch (*Arg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000116 default:
117 break;
Bob Wilsond5aad2a2014-11-04 22:28:48 +0000118 case ' ':
119 case '\\':
120 Res.push_back('\\');
121 break;
122 }
123 Res.push_back(*Arg);
124 }
125}
126
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000127// Quote target names for inclusion in GNU Make dependency files.
128// Only the characters '$', '#', ' ', '\t' are quoted.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000129static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000130 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
131 switch (Target[i]) {
132 case ' ':
133 case '\t':
134 // Escape the preceding backslashes
135 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
136 Res.push_back('\\');
137
138 // Escape the space/tab
139 Res.push_back('\\');
140 break;
141 case '$':
142 Res.push_back('$');
143 break;
144 case '#':
145 Res.push_back('\\');
146 break;
147 default:
148 break;
149 }
150
151 Res.push_back(Target[i]);
152 }
153}
154
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000155static void addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
156 const char *ArgName, const char *EnvVar) {
Bill Wendlingc0938f32012-03-12 22:10:06 +0000157 const char *DirList = ::getenv(EnvVar);
Chad Rosier616e8a52012-10-30 21:42:09 +0000158 bool CombinedArg = false;
159
Bill Wendling281ca292012-03-12 21:22:35 +0000160 if (!DirList)
161 return; // Nothing to do.
162
Chad Rosier616e8a52012-10-30 21:42:09 +0000163 StringRef Name(ArgName);
164 if (Name.equals("-I") || Name.equals("-L"))
165 CombinedArg = true;
166
Bill Wendling281ca292012-03-12 21:22:35 +0000167 StringRef Dirs(DirList);
168 if (Dirs.empty()) // Empty string should not add '.'.
169 return;
170
171 StringRef::size_type Delim;
Rafael Espindola04b3fc42013-06-25 14:29:51 +0000172 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
Bill Wendling281ca292012-03-12 21:22:35 +0000173 if (Delim == 0) { // Leading colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000174 if (CombinedArg) {
175 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
176 } else {
177 CmdArgs.push_back(ArgName);
178 CmdArgs.push_back(".");
179 }
Bill Wendling281ca292012-03-12 21:22:35 +0000180 } else {
Chad Rosier616e8a52012-10-30 21:42:09 +0000181 if (CombinedArg) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000182 CmdArgs.push_back(
183 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
Chad Rosier616e8a52012-10-30 21:42:09 +0000184 } else {
185 CmdArgs.push_back(ArgName);
186 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
187 }
Bill Wendling281ca292012-03-12 21:22:35 +0000188 }
Nico Weber89355782012-03-19 15:00:03 +0000189 Dirs = Dirs.substr(Delim + 1);
Bill Wendling281ca292012-03-12 21:22:35 +0000190 }
191
192 if (Dirs.empty()) { // Trailing colon.
Chad Rosier616e8a52012-10-30 21:42:09 +0000193 if (CombinedArg) {
194 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
195 } else {
196 CmdArgs.push_back(ArgName);
197 CmdArgs.push_back(".");
198 }
Bill Wendling281ca292012-03-12 21:22:35 +0000199 } else { // Add the last path.
Chad Rosier616e8a52012-10-30 21:42:09 +0000200 if (CombinedArg) {
201 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
202 } else {
203 CmdArgs.push_back(ArgName);
204 CmdArgs.push_back(Args.MakeArgString(Dirs));
205 }
Bill Wendling281ca292012-03-12 21:22:35 +0000206 }
207}
208
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000209static void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
210 const ArgList &Args, ArgStringList &CmdArgs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000211 const Driver &D = TC.getDriver();
212
Daniel Dunbar1094bb12011-02-19 05:33:51 +0000213 // Add extra linker input arguments which are not treated as inputs
214 // (constructed via -Xarch_).
215 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
216
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000217 for (const auto &II : Inputs) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000218 if (!TC.HasNativeLLVMSupport()) {
219 // Don't try to pass LLVM inputs unless we have native support.
220 if (II.getType() == types::TY_LLVM_IR ||
221 II.getType() == types::TY_LTO_IR ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000222 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
223 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
Daniel Dunbar54423b22010-09-17 00:24:54 +0000224 }
225
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000226 // Add filenames immediately.
227 if (II.isFilename()) {
Daniel Dunbar54423b22010-09-17 00:24:54 +0000228 CmdArgs.push_back(II.getFilename());
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000229 continue;
230 }
231
232 // Otherwise, this is a linker input argument.
233 const Arg &A = II.getInputArg();
234
235 // Handle reserved library options.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000236 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
Daniel Dunbar3f7796f2010-09-17 01:20:05 +0000237 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +0000238 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
Shantonu Senafeb03b2010-09-17 18:39:08 +0000239 TC.AddCCKextLibArgs(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000240 else if (A.getOption().matches(options::OPT_z)) {
241 // Pass -z prefix for gcc linker compatibility.
242 A.claim();
243 A.render(Args, CmdArgs);
244 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000245 A.renderAsInput(Args, CmdArgs);
Arthur Marble31fb6f42014-07-16 21:16:16 +0000246 }
Daniel Dunbar54423b22010-09-17 00:24:54 +0000247 }
Bill Wendling281ca292012-03-12 21:22:35 +0000248
249 // LIBRARY_PATH - included following the user specified library paths.
Richard Barton5828d7b2013-12-17 11:11:25 +0000250 // and only supported on native toolchains.
251 if (!TC.isCrossCompiling())
252 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
Daniel Dunbar54423b22010-09-17 00:24:54 +0000253}
254
John McCall31168b02011-06-15 23:02:42 +0000255/// \brief Determine whether Objective-C automated reference counting is
256/// enabled.
257static bool isObjCAutoRefCount(const ArgList &Args) {
258 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
259}
260
Ted Kremeneke65b0862012-03-06 20:05:56 +0000261/// \brief Determine whether we are linking the ObjC runtime.
262static bool isObjCRuntimeLinked(const ArgList &Args) {
Bob Wilson29536fc2012-08-07 19:58:00 +0000263 if (isObjCAutoRefCount(Args)) {
264 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000265 return true;
Bob Wilson29536fc2012-08-07 19:58:00 +0000266 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000267 return Args.hasArg(options::OPT_fobjc_link_runtime);
268}
269
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000270static bool forwardToGCC(const Option &O) {
Reid Kleckner3793d5e2013-06-19 15:09:06 +0000271 // Don't forward inputs from the original command line. They are added from
272 // InputInfoList.
Richard Smith8e5e9762013-06-20 01:33:59 +0000273 return O.getKind() != Option::InputClass &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000274 !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000275}
276
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000277void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
278 const Driver &D, const ArgList &Args,
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000279 ArgStringList &CmdArgs,
280 const InputInfo &Output,
281 const InputInfoList &Inputs) const {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000282 Arg *A;
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000283
Daniel Dunbar64198ef2009-09-10 01:21:05 +0000284 CheckPreprocessingOptions(D, Args);
285
286 Args.AddLastArg(CmdArgs, options::OPT_C);
287 Args.AddLastArg(CmdArgs, options::OPT_CC);
Daniel Dunbar367dbb92009-06-08 21:48:20 +0000288
289 // Handle dependency file generation.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000290 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000291 (A = Args.getLastArg(options::OPT_MD)) ||
292 (A = Args.getLastArg(options::OPT_MMD))) {
293 // Determine the output location.
294 const char *DepFile;
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000295 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000296 DepFile = MF->getValue();
Chad Rosier633dcdc2013-01-24 19:14:47 +0000297 C.addFailureResultFile(DepFile, &JA);
Benjamin Kramer2715fce2012-09-26 19:01:49 +0000298 } else if (Output.getType() == types::TY_Dependencies) {
299 DepFile = Output.getFilename();
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000300 } else if (A->getOption().matches(options::OPT_M) ||
301 A->getOption().matches(options::OPT_MM)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000302 DepFile = "-";
303 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +0000304 DepFile = getDependencyFileName(Args, Inputs);
Chad Rosier633dcdc2013-01-24 19:14:47 +0000305 C.addFailureResultFile(DepFile, &JA);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000306 }
307 CmdArgs.push_back("-dependency-file");
308 CmdArgs.push_back(DepFile);
309
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000310 // Add a default target if one wasn't specified.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000311 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
312 const char *DepTarget;
313
314 // If user provided -o, that is the dependency target, except
315 // when we are only generating a dependency file.
316 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
317 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000318 DepTarget = OutputOpt->getValue();
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000319 } else {
320 // Otherwise derive from the base input.
321 //
322 // FIXME: This should use the computed output file location.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000323 SmallString<128> P(Inputs[0].getBaseInput());
Michael J. Spencere1696752010-12-18 00:19:12 +0000324 llvm::sys::path::replace_extension(P, "o");
325 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000326 }
327
328 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000329 SmallString<128> Quoted;
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000330 QuoteTarget(DepTarget, Quoted);
331 CmdArgs.push_back(Args.MakeArgString(Quoted));
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000332 }
333
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000334 if (A->getOption().matches(options::OPT_M) ||
335 A->getOption().matches(options::OPT_MD))
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000336 CmdArgs.push_back("-sys-header-deps");
Manuel Klimekc68aa162015-03-19 12:00:22 +0000337 if ((isa<PrecompileJobAction>(JA) &&
338 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
339 Args.hasArg(options::OPT_fmodule_file_deps))
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000340 CmdArgs.push_back("-module-file-deps");
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000341 }
342
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000343 if (Args.hasArg(options::OPT_MG)) {
344 if (!A || A->getOption().matches(options::OPT_MD) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000345 A->getOption().matches(options::OPT_MMD))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000346 D.Diag(diag::err_drv_mg_requires_m_or_mm);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000347 CmdArgs.push_back("-MG");
348 }
349
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000350 Args.AddLastArg(CmdArgs, options::OPT_MP);
Paul Robinsond7214a72015-04-27 18:14:32 +0000351 Args.AddLastArg(CmdArgs, options::OPT_MV);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000352
353 // Convert all -MQ <target> args to -MT <quoted target>
Sean Silva14facf32015-06-09 01:57:17 +0000354 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000355 A->claim();
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000356
Daniel Dunbara442fd52010-06-11 22:00:13 +0000357 if (A->getOption().matches(options::OPT_MQ)) {
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000358 CmdArgs.push_back("-MT");
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000359 SmallString<128> Quoted;
Richard Smithbd55daf2012-11-01 04:30:05 +0000360 QuoteTarget(A->getValue(), Quoted);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000361 CmdArgs.push_back(Args.MakeArgString(Quoted));
362
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000363 // -MT flag - no change
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000364 } else {
Daniel Dunbara442fd52010-06-11 22:00:13 +0000365 A->render(Args, CmdArgs);
Chris Lattnerbf2803f2010-03-29 17:55:58 +0000366 }
367 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000368
Douglas Gregor111af7d2009-04-18 00:34:01 +0000369 // Add -i* options, and automatically translate to
370 // -include-pch/-include-pth for transparent PCH support. It's
371 // wonky, but we include looking for .gch so we can support seamless
372 // replacement into a build system already set up to be generating
373 // .gch files.
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000374 bool RenderedImplicitInclude = false;
Sean Silva14facf32015-06-09 01:57:17 +0000375 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000376 if (A->getOption().matches(options::OPT_include)) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000377 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
378 RenderedImplicitInclude = true;
379
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +0000380 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000381 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000382
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000383 bool FoundPTH = false;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000384 bool FoundPCH = false;
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000385 SmallString<128> P(A->getValue());
386 // We want the files to have a name like foo.h.pch. Add a dummy extension
387 // so that replace_extension does the right thing.
388 P += ".dummy";
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000389 if (UsePCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000390 llvm::sys::path::replace_extension(P, "pch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000391 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000392 FoundPCH = true;
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000393 }
394
Douglas Gregor111af7d2009-04-18 00:34:01 +0000395 if (!FoundPCH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000396 llvm::sys::path::replace_extension(P, "pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000397 if (llvm::sys::fs::exists(P))
Douglas Gregor111af7d2009-04-18 00:34:01 +0000398 FoundPTH = true;
Mike Stump11289f42009-09-09 15:08:12 +0000399 }
400
Douglas Gregor111af7d2009-04-18 00:34:01 +0000401 if (!FoundPCH && !FoundPTH) {
Rafael Espindola00eaafd2013-06-25 15:03:59 +0000402 llvm::sys::path::replace_extension(P, "gch");
Yaron Keren92e1b622015-03-18 10:17:07 +0000403 if (llvm::sys::fs::exists(P)) {
Daniel Dunbarcbc34b72009-10-15 20:02:44 +0000404 FoundPCH = UsePCH;
405 FoundPTH = !UsePCH;
Douglas Gregor111af7d2009-04-18 00:34:01 +0000406 }
Douglas Gregor111af7d2009-04-18 00:34:01 +0000407 }
408
409 if (FoundPCH || FoundPTH) {
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000410 if (IsFirstImplicitInclude) {
411 A->claim();
412 if (UsePCH)
413 CmdArgs.push_back("-include-pch");
414 else
415 CmdArgs.push_back("-include-pth");
Yaron Keren92e1b622015-03-18 10:17:07 +0000416 CmdArgs.push_back(Args.MakeArgString(P));
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000417 continue;
418 } else {
419 // Ignore the PCH if not first on command line and emit warning.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000420 D.Diag(diag::warn_drv_pch_not_first_include) << P
421 << A->getAsString(Args);
Argyrios Kyrtzidis2f23b412010-09-30 16:53:47 +0000422 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000423 }
424 }
425
426 // Not translated, render as usual.
427 A->claim();
428 A->render(Args, CmdArgs);
429 }
430
Douglas Katzman57a9c7e2015-07-29 18:39:14 +0000431 Args.AddAllArgs(CmdArgs,
432 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
433 options::OPT_F, options::OPT_index_header_map});
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000434
Douglas Katzman9dc81a42015-10-02 14:41:38 +0000435 // Add -Wp, and -Xpreprocessor if using the preprocessor.
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000436
437 // FIXME: There is a very unfortunate problem here, some troubled
438 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
439 // really support that we would have to parse and then translate
440 // those options. :(
441 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
442 options::OPT_Xpreprocessor);
Daniel Dunbar38b62792009-10-29 01:53:44 +0000443
444 // -I- is a deprecated GCC feature, reject it.
445 if (Arg *A = Args.getLastArg(options::OPT_I_))
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000446 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
Chandler Carruth24e17e12010-10-20 07:00:47 +0000447
448 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
449 // -isysroot to the CC1 invocation.
Sebastian Pop980920a2012-04-16 04:16:43 +0000450 StringRef sysroot = C.getSysRoot();
451 if (sysroot != "") {
Chandler Carruth24e17e12010-10-20 07:00:47 +0000452 if (!Args.hasArg(options::OPT_isysroot)) {
453 CmdArgs.push_back("-isysroot");
Sebastian Pop980920a2012-04-16 04:16:43 +0000454 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Chandler Carruth24e17e12010-10-20 07:00:47 +0000455 }
456 }
Douglas Gregor5dc38992013-02-07 00:21:12 +0000457
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000458 // Parse additional include paths from environment variables.
Chandler Carruth9802c142011-11-04 07:12:58 +0000459 // FIXME: We should probably sink the logic for handling these from the
460 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000461 // CPATH - included following the user specified includes (but prior to
462 // builtin and standard includes).
Bill Wendlingc0938f32012-03-12 22:10:06 +0000463 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000464 // C_INCLUDE_PATH - system includes enabled when compiling C.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000465 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000466 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000467 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000468 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000469 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
Benjamin Kramer8404eb02011-09-22 21:41:16 +0000470 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
Bill Wendlingc0938f32012-03-12 22:10:06 +0000471 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000472
Chandler Carruth6bfd84f2011-11-04 07:12:53 +0000473 // Add C++ include arguments, if needed.
Chandler Carruth4c81dfa2011-11-04 07:43:33 +0000474 if (types::isCXX(Inputs[0].getType()))
Chandler Carruth491db322011-11-04 07:34:47 +0000475 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
Chandler Carrutha796f532011-11-05 20:17:13 +0000476
477 // Add system include arguments.
478 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +0000479}
480
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000481// FIXME: Move to target hook.
482static bool isSignedCharDefault(const llvm::Triple &Triple) {
483 switch (Triple.getArch()) {
484 default:
485 return true;
486
Tim Northover9bb857a2013-01-31 12:13:10 +0000487 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +0000488 case llvm::Triple::aarch64_be:
Jim Grosbach7c2c6642011-05-24 15:40:46 +0000489 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +0000490 case llvm::Triple::armeb:
Oliver Stannardabed2ee2014-10-24 11:28:47 +0000491 case llvm::Triple::thumb:
492 case llvm::Triple::thumbeb:
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000493 if (Triple.isOSDarwin() || Triple.isOSWindows())
494 return true;
495 return false;
496
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000497 case llvm::Triple::ppc:
498 case llvm::Triple::ppc64:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +0000499 if (Triple.isOSDarwin())
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000500 return true;
501 return false;
Ulrich Weigand47445072013-05-06 16:26:41 +0000502
David Majnemerdcecd932015-05-23 19:23:55 +0000503 case llvm::Triple::hexagon:
Bill Schmidt778d3872013-07-26 01:36:11 +0000504 case llvm::Triple::ppc64le:
Ulrich Weigand47445072013-05-06 16:26:41 +0000505 case llvm::Triple::systemz:
Robert Lytton0e076492013-08-13 09:43:10 +0000506 case llvm::Triple::xcore:
Ulrich Weigand47445072013-05-06 16:26:41 +0000507 return false;
Daniel Dunbard609b7b2009-11-17 06:37:03 +0000508 }
509}
510
Robert Lytton0e076492013-08-13 09:43:10 +0000511static bool isNoCommonDefault(const llvm::Triple &Triple) {
512 switch (Triple.getArch()) {
513 default:
514 return false;
515
516 case llvm::Triple::xcore:
Dan Gohmanc2853072015-09-03 22:51:53 +0000517 case llvm::Triple::wasm32:
518 case llvm::Triple::wasm64:
Robert Lytton0e076492013-08-13 09:43:10 +0000519 return true;
520 }
521}
522
Renato Goline17c5802015-07-27 23:44:42 +0000523// ARM tools start.
524
525// Get SubArch (vN).
526static int getARMSubArchVersionNumber(const llvm::Triple &Triple) {
527 llvm::StringRef Arch = Triple.getArchName();
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000528 return llvm::ARM::parseArchVersion(Arch);
Renato Goline17c5802015-07-27 23:44:42 +0000529}
530
531// True if M-profile.
532static bool isARMMProfile(const llvm::Triple &Triple) {
533 llvm::StringRef Arch = Triple.getArchName();
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000534 unsigned Profile = llvm::ARM::parseArchProfile(Arch);
Renato Goline17c5802015-07-27 23:44:42 +0000535 return Profile == llvm::ARM::PK_M;
536}
537
538// Get Arch/CPU from args.
Renato Golin7c542b42015-07-27 23:44:45 +0000539static void getARMArchCPUFromArgs(const ArgList &Args, llvm::StringRef &Arch,
540 llvm::StringRef &CPU, bool FromAs = false) {
Renato Goline17c5802015-07-27 23:44:42 +0000541 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
542 CPU = A->getValue();
543 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
544 Arch = A->getValue();
Renato Golin7c542b42015-07-27 23:44:45 +0000545 if (!FromAs)
546 return;
547
548 for (const Arg *A :
549 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
550 StringRef Value = A->getValue();
551 if (Value.startswith("-mcpu="))
552 CPU = Value.substr(6);
553 if (Value.startswith("-march="))
554 Arch = Value.substr(7);
555 }
Renato Goline17c5802015-07-27 23:44:42 +0000556}
557
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000558// Handle -mhwdiv=.
Renato Golin7c542b42015-07-27 23:44:45 +0000559// FIXME: Use ARMTargetParser.
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000560static void getARMHWDivFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000561 const ArgList &Args, StringRef HWDiv,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000562 std::vector<const char *> &Features) {
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000563 unsigned HWDivID = llvm::ARM::parseHWDiv(HWDiv);
564 if (!llvm::ARM::getHWDivFeatures(HWDivID, Features))
Silviu Barangaf9671dd2013-10-21 10:54:53 +0000565 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
566}
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000567
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000568// Handle -mfpu=.
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000569static void getARMFPUFeatures(const Driver &D, const Arg *A,
Renato Golin7c542b42015-07-27 23:44:45 +0000570 const ArgList &Args, StringRef FPU,
Amara Emerson4cdb87b2013-10-01 10:20:54 +0000571 std::vector<const char *> &Features) {
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000572 unsigned FPUID = llvm::ARM::parseFPU(FPU);
573 if (!llvm::ARM::getFPUFeatures(FPUID, Features))
Chad Rosiercfbfc582012-04-04 20:51:35 +0000574 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
575}
576
Renato Golin7c542b42015-07-27 23:44:45 +0000577// Check if -march is valid by checking if it can be canonicalised and parsed.
578// getARMArch is used here instead of just checking the -march value in order
579// to handle -march=native correctly.
580static void checkARMArchName(const Driver &D, const Arg *A, const ArgList &Args,
Renato Goline17c5802015-07-27 23:44:42 +0000581 llvm::StringRef ArchName,
582 const llvm::Triple &Triple) {
583 std::string MArch = arm::getARMArch(ArchName, Triple);
Chandler Carruthaa0caeb2015-08-30 02:16:36 +0000584 if (llvm::ARM::parseArch(MArch) == llvm::ARM::AK_INVALID)
Renato Goline17c5802015-07-27 23:44:42 +0000585 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000586}
587
Renato Golin7c542b42015-07-27 23:44:45 +0000588// Check -mcpu=. Needs ArchName to handle -mcpu=generic.
589static void checkARMCPUName(const Driver &D, const Arg *A, const ArgList &Args,
590 llvm::StringRef CPUName, llvm::StringRef ArchName,
Renato Goline17c5802015-07-27 23:44:42 +0000591 const llvm::Triple &Triple) {
592 std::string CPU = arm::getARMTargetCPU(CPUName, ArchName, Triple);
Vladimir Sukharev64f68242015-09-23 09:29:32 +0000593 if (arm::getLLVMArchSuffixForARM(CPU, ArchName, Triple).empty())
Renato Goline17c5802015-07-27 23:44:42 +0000594 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
John Brawn94fd9632015-05-21 12:19:49 +0000595}
596
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000597static bool useAAPCSForMachO(const llvm::Triple &T) {
598 // The backend is hardwired to assume AAPCS for M-class processors, ensure
599 // the frontend matches that.
600 return T.getEnvironment() == llvm::Triple::EABI ||
601 T.getOS() == llvm::Triple::UnknownOS || isARMMProfile(T);
602}
603
Asiri Rathnayake9e3c7cb2014-10-03 09:11:41 +0000604// Select the float ABI as determined by -msoft-float, -mhard-float, and
605// -mfloat-abi=.
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000606arm::FloatABI arm::getARMFloatABI(const ToolChain &TC, const ArgList &Args) {
607 const Driver &D = TC.getDriver();
608 const llvm::Triple Triple(TC.ComputeEffectiveClangTriple(Args));
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000609 auto SubArch = getARMSubArchVersionNumber(Triple);
610 arm::FloatABI ABI = FloatABI::Invalid;
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000611 if (Arg *A =
612 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
613 options::OPT_mfloat_abi_EQ)) {
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000614 if (A->getOption().matches(options::OPT_msoft_float)) {
615 ABI = FloatABI::Soft;
616 } else if (A->getOption().matches(options::OPT_mhard_float)) {
617 ABI = FloatABI::Hard;
618 } else {
619 ABI = llvm::StringSwitch<arm::FloatABI>(A->getValue())
620 .Case("soft", FloatABI::Soft)
621 .Case("softfp", FloatABI::SoftFP)
622 .Case("hard", FloatABI::Hard)
623 .Default(FloatABI::Invalid);
624 if (ABI == FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000625 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000626 ABI = FloatABI::Soft;
Daniel Dunbar78485922009-09-10 23:00:09 +0000627 }
628 }
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000629
630 // It is incorrect to select hard float ABI on MachO platforms if the ABI is
631 // "apcs-gnu".
632 if (Triple.isOSBinFormatMachO() && !useAAPCSForMachO(Triple) &&
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000633 ABI == FloatABI::Hard) {
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000634 D.Diag(diag::err_drv_unsupported_opt_for_target) << A->getAsString(Args)
635 << Triple.getArchName();
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000636 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000637 }
638
639 // If unspecified, choose the default based on the platform.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000640 if (ABI == FloatABI::Invalid) {
Rafael Espindola0e1fb4f2010-06-28 17:18:09 +0000641 switch (Triple.getOS()) {
Bob Wilson6524dd32011-10-14 05:03:44 +0000642 case llvm::Triple::Darwin:
643 case llvm::Triple::MacOSX:
Tim Northover756447a2015-10-30 16:30:36 +0000644 case llvm::Triple::IOS:
645 case llvm::Triple::TvOS: {
Daniel Dunbar78485922009-09-10 23:00:09 +0000646 // Darwin defaults to "softfp" for v6 and v7.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000647 ABI = (SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
Daniel Dunbar78485922009-09-10 23:00:09 +0000648 break;
649 }
Tim Northover756447a2015-10-30 16:30:36 +0000650 case llvm::Triple::WatchOS:
651 ABI = FloatABI::Hard;
652 break;
Daniel Dunbar78485922009-09-10 23:00:09 +0000653
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000654 // FIXME: this is invalid for WindowsCE
655 case llvm::Triple::Win32:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000656 ABI = FloatABI::Hard;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000657 break;
658
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000659 case llvm::Triple::FreeBSD:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000660 switch (Triple.getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +0000661 case llvm::Triple::GNUEABIHF:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000662 ABI = FloatABI::Hard;
Renato Golinf4421f72014-02-19 10:44:07 +0000663 break;
664 default:
665 // FreeBSD defaults to soft float
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000666 ABI = FloatABI::Soft;
Renato Golinf4421f72014-02-19 10:44:07 +0000667 break;
668 }
Rafael Espindola0f207ed2012-12-13 04:17:14 +0000669 break;
670
Daniel Dunbar78485922009-09-10 23:00:09 +0000671 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000672 switch (Triple.getEnvironment()) {
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000673 case llvm::Triple::GNUEABIHF:
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000674 case llvm::Triple::EABIHF:
675 ABI = FloatABI::Hard;
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000676 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000677 case llvm::Triple::GNUEABI:
Bob Wilsond1447c42011-02-04 17:59:28 +0000678 case llvm::Triple::EABI:
679 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000680 ABI = FloatABI::SoftFP;
Bob Wilsond1447c42011-02-04 17:59:28 +0000681 break;
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000682 case llvm::Triple::Android:
683 ABI = (SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
Chandler Carruthc89aa9d2012-01-10 19:47:42 +0000684 break;
Bob Wilsond1447c42011-02-04 17:59:28 +0000685 default:
686 // Assume "soft", but warn the user we are guessing.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000687 ABI = FloatABI::Soft;
Saleem Abdulrasool377066a2014-03-27 22:50:18 +0000688 if (Triple.getOS() != llvm::Triple::UnknownOS ||
689 !Triple.isOSBinFormatMachO())
690 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
Bob Wilsond1447c42011-02-04 17:59:28 +0000691 break;
692 }
Daniel Dunbar78485922009-09-10 23:00:09 +0000693 }
694 }
695
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000696 assert(ABI != FloatABI::Invalid && "must select an ABI");
697 return ABI;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000698}
699
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000700static void getARMTargetFeatures(const ToolChain &TC,
701 const llvm::Triple &Triple,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000702 const ArgList &Args,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +0000703 std::vector<const char *> &Features,
704 bool ForAS) {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000705 const Driver &D = TC.getDriver();
706
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000707 bool KernelOrKext =
708 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000709 arm::FloatABI ABI = arm::getARMFloatABI(TC, Args);
Renato Golin7c542b42015-07-27 23:44:45 +0000710 const Arg *WaCPU = nullptr, *WaFPU = nullptr;
711 const Arg *WaHDiv = nullptr, *WaArch = nullptr;
712
Nico Weber6e0ebae2015-04-29 21:16:40 +0000713 if (!ForAS) {
714 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
715 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
716 // stripped out by the ARM target. We should probably pass this a new
717 // -target-option, which is handled by the -cc1/-cc1as invocation.
718 //
719 // FIXME2: For consistency, it would be ideal if we set up the target
720 // machine state the same when using the frontend or the assembler. We don't
721 // currently do that for the assembler, we pass the options directly to the
722 // backend and never even instantiate the frontend TargetInfo. If we did,
723 // and used its handleTargetFeatures hook, then we could ensure the
724 // assembler and the frontend behave the same.
725
726 // Use software floating point operations?
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000727 if (ABI == arm::FloatABI::Soft)
Nico Weber6e0ebae2015-04-29 21:16:40 +0000728 Features.push_back("+soft-float");
729
730 // Use software floating point argument passing?
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000731 if (ABI != arm::FloatABI::Hard)
Nico Weber6e0ebae2015-04-29 21:16:40 +0000732 Features.push_back("+soft-float-abi");
Renato Golin7c542b42015-07-27 23:44:45 +0000733 } else {
734 // Here, we make sure that -Wa,-mfpu/cpu/arch/hwdiv will be passed down
735 // to the assembler correctly.
736 for (const Arg *A :
737 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
738 StringRef Value = A->getValue();
739 if (Value.startswith("-mfpu=")) {
740 WaFPU = A;
741 } else if (Value.startswith("-mcpu=")) {
742 WaCPU = A;
743 } else if (Value.startswith("-mhwdiv=")) {
744 WaHDiv = A;
745 } else if (Value.startswith("-march=")) {
746 WaArch = A;
747 }
748 }
Nico Weber6e0ebae2015-04-29 21:16:40 +0000749 }
750
Renato Golin7c542b42015-07-27 23:44:45 +0000751 // Check -march. ClangAs gives preference to -Wa,-march=.
752 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000753 StringRef ArchName;
Renato Golin7c542b42015-07-27 23:44:45 +0000754 if (WaArch) {
755 if (ArchArg)
756 D.Diag(clang::diag::warn_drv_unused_argument)
757 << ArchArg->getAsString(Args);
758 ArchName = StringRef(WaArch->getValue()).substr(7);
759 checkARMArchName(D, WaArch, Args, ArchName, Triple);
760 // FIXME: Set Arch.
761 D.Diag(clang::diag::warn_drv_unused_argument) << WaArch->getAsString(Args);
762 } else if (ArchArg) {
763 ArchName = ArchArg->getValue();
764 checkARMArchName(D, ArchArg, Args, ArchName, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000765 }
766
Renato Golin7c542b42015-07-27 23:44:45 +0000767 // Check -mcpu. ClangAs gives preference to -Wa,-mcpu=.
768 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
Renato Goline17c5802015-07-27 23:44:42 +0000769 StringRef CPUName;
Renato Golin7c542b42015-07-27 23:44:45 +0000770 if (WaCPU) {
771 if (CPUArg)
772 D.Diag(clang::diag::warn_drv_unused_argument)
773 << CPUArg->getAsString(Args);
774 CPUName = StringRef(WaCPU->getValue()).substr(6);
775 checkARMCPUName(D, WaCPU, Args, CPUName, ArchName, Triple);
776 } else if (CPUArg) {
777 CPUName = CPUArg->getValue();
778 checkARMCPUName(D, CPUArg, Args, CPUName, ArchName, Triple);
John Brawn94fd9632015-05-21 12:19:49 +0000779 }
John Brawna95c1a82015-05-08 12:52:18 +0000780
Renato Golin23459c62015-07-30 16:40:17 +0000781 // Add CPU features for generic CPUs
782 if (CPUName == "native") {
783 llvm::StringMap<bool> HostFeatures;
784 if (llvm::sys::getHostCPUFeatures(HostFeatures))
785 for (auto &F : HostFeatures)
786 Features.push_back(
787 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
788 }
789
790 // Honor -mfpu=. ClangAs gives preference to -Wa,-mfpu=.
791 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
792 if (WaFPU) {
793 if (FPUArg)
794 D.Diag(clang::diag::warn_drv_unused_argument)
795 << FPUArg->getAsString(Args);
796 getARMFPUFeatures(D, WaFPU, Args, StringRef(WaFPU->getValue()).substr(6),
797 Features);
798 } else if (FPUArg) {
799 getARMFPUFeatures(D, FPUArg, Args, FPUArg->getValue(), Features);
800 }
801
802 // Honor -mhwdiv=. ClangAs gives preference to -Wa,-mhwdiv=.
803 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
804 if (WaHDiv) {
805 if (HDivArg)
806 D.Diag(clang::diag::warn_drv_unused_argument)
807 << HDivArg->getAsString(Args);
808 getARMHWDivFeatures(D, WaHDiv, Args,
809 StringRef(WaHDiv->getValue()).substr(8), Features);
810 } else if (HDivArg)
811 getARMHWDivFeatures(D, HDivArg, Args, HDivArg->getValue(), Features);
812
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000813 // Setting -msoft-float effectively disables NEON because of the GCC
814 // implementation, although the same isn't true of VFP or VFP3.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000815 if (ABI == arm::FloatABI::Soft) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000816 Features.push_back("-neon");
Amara Emersonecbe18e2014-02-12 10:22:35 +0000817 // Also need to explicitly disable features which imply NEON.
818 Features.push_back("-crypto");
819 }
Bernard Ogden18b57012013-10-29 09:47:51 +0000820
Eric Christopher269c2a22015-04-04 03:34:43 +0000821 // En/disable crc code generation.
822 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bernard Ogden18b57012013-10-29 09:47:51 +0000823 if (A->getOption().matches(options::OPT_mcrc))
824 Features.push_back("+crc");
825 else
826 Features.push_back("-crc");
827 }
Vladimir Sukharevc6dab752015-05-14 08:25:18 +0000828
829 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
830 Features.insert(Features.begin(), "+v8.1a");
831 }
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000832
Akira Hatanakac2694822015-07-07 08:28:42 +0000833 // Look for the last occurrence of -mlong-calls or -mno-long-calls. If
834 // neither options are specified, see if we are compiling for kernel/kext and
835 // decide whether to pass "+long-calls" based on the OS and its version.
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000836 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
837 options::OPT_mno_long_calls)) {
838 if (A->getOption().matches(options::OPT_mlong_calls))
839 Features.push_back("+long-calls");
Tim Northover756447a2015-10-30 16:30:36 +0000840 } else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
841 !Triple.isWatchOS()) {
Akira Hatanaka3fb33a52015-07-07 06:42:05 +0000842 Features.push_back("+long-calls");
843 }
Akira Hatanaka580efb22015-07-16 00:43:00 +0000844
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000845 // Kernel code has more strict alignment requirements.
846 if (KernelOrKext)
847 Features.push_back("+strict-align");
848 else if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
849 options::OPT_munaligned_access)) {
850 if (A->getOption().matches(options::OPT_munaligned_access)) {
851 // No v6M core supports unaligned memory access (v6M ARM ARM A3.2).
852 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
853 D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
854 } else
855 Features.push_back("+strict-align");
856 } else {
857 // Assume pre-ARMv6 doesn't support unaligned accesses.
858 //
859 // ARMv6 may or may not support unaligned accesses depending on the
860 // SCTLR.U bit, which is architecture-specific. We assume ARMv6
861 // Darwin and NetBSD targets support unaligned accesses, and others don't.
862 //
863 // ARMv7 always has SCTLR.U set to 1, but it has a new SCTLR.A bit
864 // which raises an alignment fault on unaligned accesses. Linux
865 // defaults this bit to 0 and handles it as a system-wide (not
866 // per-process) setting. It is therefore safe to assume that ARMv7+
867 // Linux targets support unaligned accesses. The same goes for NaCl.
868 //
869 // The above behavior is consistent with GCC.
870 int VersionNum = getARMSubArchVersionNumber(Triple);
871 if (Triple.isOSDarwin() || Triple.isOSNetBSD()) {
Alexandros Lamprineaseda554a2015-10-05 12:45:10 +0000872 if (VersionNum < 6 ||
873 Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
Akira Hatanaka7651dd82015-07-28 22:26:45 +0000874 Features.push_back("+strict-align");
875 } else if (Triple.isOSLinux() || Triple.isOSNaCl()) {
876 if (VersionNum < 7)
877 Features.push_back("+strict-align");
878 } else
879 Features.push_back("+strict-align");
880 }
881
Akira Hatanaka0a23fac2015-07-21 01:41:08 +0000882 // llvm does not support reserving registers in general. There is support
883 // for reserving r9 on ARM though (defined as a platform-specific register
884 // in ARM EABI).
885 if (Args.hasArg(options::OPT_ffixed_r9))
886 Features.push_back("+reserve-r9");
887
Akira Hatanaka580efb22015-07-16 00:43:00 +0000888 // The kext linker doesn't know how to deal with movw/movt.
889 if (KernelOrKext)
890 Features.push_back("+no-movt");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +0000891}
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000892
Saleem Abdulrasoolce63ce92015-09-19 18:19:44 +0000893void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
894 ArgStringList &CmdArgs, bool KernelOrKext) const {
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000895 // Select the ABI to use.
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000896 // FIXME: Support -meabi.
Eric Christopher52276532014-12-10 22:58:34 +0000897 // FIXME: Parts of this are duplicated in the backend, unify this somehow.
Craig Topper92fc2df2014-05-17 16:56:41 +0000898 const char *ABIName = nullptr;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000899 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000900 ABIName = A->getValue();
Tim Northovere5c6f4c2014-05-22 12:54:30 +0000901 } else if (Triple.isOSBinFormatMachO()) {
Akira Hatanaka9d99bb52015-08-26 19:00:11 +0000902 if (useAAPCSForMachO(Triple)) {
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000903 ABIName = "aapcs";
Tim Northover756447a2015-10-30 16:30:36 +0000904 } else if (Triple.isWatchOS()) {
905 ABIName = "aapcs16";
Daniel Dunbar5f18f6e2012-10-22 18:30:51 +0000906 } else {
907 ABIName = "apcs-gnu";
908 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +0000909 } else if (Triple.isOSWindows()) {
910 // FIXME: this is invalid for WindowsCE
911 ABIName = "aapcs";
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000912 } else {
913 // Select the default based on the platform.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000914 switch (Triple.getEnvironment()) {
Logan Chienc6fd8202012-09-02 09:30:11 +0000915 case llvm::Triple::Android:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000916 case llvm::Triple::GNUEABI:
Jiangning Liu61b06cb2012-07-31 08:06:29 +0000917 case llvm::Triple::GNUEABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000918 ABIName = "aapcs-linux";
919 break;
Joerg Sonnenbergerd75a1f82013-12-16 19:16:04 +0000920 case llvm::Triple::EABIHF:
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000921 case llvm::Triple::EABI:
922 ABIName = "aapcs";
923 break;
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000924 default:
Eric Christopher7a8b31d2014-12-18 02:08:51 +0000925 if (Triple.getOS() == llvm::Triple::NetBSD)
926 ABIName = "apcs-gnu";
927 else
928 ABIName = "aapcs";
Oliver Stannardec8b6b32014-09-04 10:38:53 +0000929 break;
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000930 }
931 }
932 CmdArgs.push_back("-target-abi");
933 CmdArgs.push_back(ABIName);
934
Anton Korobeynikova29e4622012-04-09 13:38:30 +0000935 // Determine floating point ABI from the options & target defaults.
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +0000936 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000937 if (ABI == arm::FloatABI::Soft) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000938 // Floating point operations and argument passing are soft.
Daniel Dunbar78485922009-09-10 23:00:09 +0000939 // FIXME: This changes CPP defines, we need -target-soft-float.
Daniel Dunbara74f8ff2009-11-30 08:42:00 +0000940 CmdArgs.push_back("-msoft-float");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000941 CmdArgs.push_back("-mfloat-abi");
942 CmdArgs.push_back("soft");
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000943 } else if (ABI == arm::FloatABI::SoftFP) {
Daniel Dunbar78485922009-09-10 23:00:09 +0000944 // Floating point operations are hard, but argument passing is soft.
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000945 CmdArgs.push_back("-mfloat-abi");
946 CmdArgs.push_back("soft");
Daniel Dunbar78485922009-09-10 23:00:09 +0000947 } else {
948 // Floating point operations and argument passing are hard.
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +0000949 assert(ABI == arm::FloatABI::Hard && "Invalid float abi!");
Daniel Dunbar6cc525b2009-12-08 19:49:51 +0000950 CmdArgs.push_back("-mfloat-abi");
951 CmdArgs.push_back("hard");
Daniel Dunbar78485922009-09-10 23:00:09 +0000952 }
Daniel Dunbar893d4752009-12-19 04:15:38 +0000953
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000954 // Forward the -mglobal-merge option for explicit control over the pass.
Chad Rosierba3df1d2011-08-26 00:26:29 +0000955 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
956 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000957 CmdArgs.push_back("-backend-option");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000958 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +0000959 CmdArgs.push_back("-arm-global-merge=false");
960 else
961 CmdArgs.push_back("-arm-global-merge=true");
Chad Rosierba3df1d2011-08-26 00:26:29 +0000962 }
Chad Rosierf1985d22012-05-16 20:40:09 +0000963
Bob Wilson9c8af452013-04-11 18:53:25 +0000964 if (!Args.hasFlag(options::OPT_mimplicit_float,
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000965 options::OPT_mno_implicit_float, true))
Chad Rosierf1985d22012-05-16 20:40:09 +0000966 CmdArgs.push_back("-no-implicit-float");
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000967}
Renato Goline17c5802015-07-27 23:44:42 +0000968// ARM tools end.
Daniel Dunbar0f5c5422009-09-10 04:57:17 +0000969
Tim Northover573cbee2014-05-24 12:52:07 +0000970/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
971/// targeting.
972static std::string getAArch64TargetCPU(const ArgList &Args) {
Kevin Qin110db6f2014-07-18 07:03:22 +0000973 Arg *A;
974 std::string CPU;
975 // If we have -mtune or -mcpu, use that.
976 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +0000977 CPU = StringRef(A->getValue()).lower();
Kevin Qin110db6f2014-07-18 07:03:22 +0000978 } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
Renato Golin4045f662015-05-08 15:44:36 +0000979 StringRef Mcpu = A->getValue();
Gabor Ballabas726ce7f2015-06-12 17:33:37 +0000980 CPU = Mcpu.split("+").first.lower();
Tim Northovera2ee4332014-03-29 15:09:45 +0000981 }
982
Kevin Qin110db6f2014-07-18 07:03:22 +0000983 // Handle CPU name is 'native'.
984 if (CPU == "native")
985 return llvm::sys::getHostCPUName();
986 else if (CPU.size())
987 return CPU;
Tim Northovera2ee4332014-03-29 15:09:45 +0000988
James Molloy9b1586b2014-04-17 12:51:17 +0000989 // Make sure we pick "cyclone" if -arch is used.
990 // FIXME: Should this be picked by checking the target triple instead?
991 if (Args.getLastArg(options::OPT_arch))
992 return "cyclone";
993
994 return "generic";
Tim Northovera2ee4332014-03-29 15:09:45 +0000995}
996
Tim Northover573cbee2014-05-24 12:52:07 +0000997void Clang::AddAArch64TargetArgs(const ArgList &Args,
998 ArgStringList &CmdArgs) const {
Tim Northovera2ee4332014-03-29 15:09:45 +0000999 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1000 llvm::Triple Triple(TripleStr);
1001
1002 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1003 Args.hasArg(options::OPT_mkernel) ||
1004 Args.hasArg(options::OPT_fapple_kext))
1005 CmdArgs.push_back("-disable-red-zone");
1006
1007 if (!Args.hasFlag(options::OPT_mimplicit_float,
1008 options::OPT_mno_implicit_float, true))
1009 CmdArgs.push_back("-no-implicit-float");
1010
Craig Topper92fc2df2014-05-17 16:56:41 +00001011 const char *ABIName = nullptr;
Tim Northovera2ee4332014-03-29 15:09:45 +00001012 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1013 ABIName = A->getValue();
1014 else if (Triple.isOSDarwin())
1015 ABIName = "darwinpcs";
1016 else
1017 ABIName = "aapcs";
1018
1019 CmdArgs.push_back("-target-abi");
1020 CmdArgs.push_back(ABIName);
1021
Bradley Smith9ff64332014-10-13 10:16:06 +00001022 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1023 options::OPT_mno_fix_cortex_a53_835769)) {
1024 CmdArgs.push_back("-backend-option");
1025 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1026 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
1027 else
1028 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001029 } else if (Triple.isAndroid()) {
Bradley Smith04ee8aa2014-10-16 16:35:14 +00001030 // Enabled A53 errata (835769) workaround by default on android
1031 CmdArgs.push_back("-backend-option");
1032 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
Bradley Smith9ff64332014-10-13 10:16:06 +00001033 }
1034
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001035 // Forward the -mglobal-merge option for explicit control over the pass.
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001036 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1037 options::OPT_mno_global_merge)) {
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001038 CmdArgs.push_back("-backend-option");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001039 if (A->getOption().matches(options::OPT_mno_global_merge))
Ahmed Bougacha256a8692015-04-11 00:10:44 +00001040 CmdArgs.push_back("-aarch64-global-merge=false");
1041 else
1042 CmdArgs.push_back("-aarch64-global-merge=true");
Bob Wilsonbdd2b3c2014-05-29 19:43:02 +00001043 }
Tim Northovera2ee4332014-03-29 15:09:45 +00001044}
1045
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001046// Get CPU and ABI names. They are not independent
1047// so we have to calculate them together.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001048void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple,
1049 StringRef &CPUName, StringRef &ABIName) {
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00001050 const char *DefMips32CPU = "mips32r2";
1051 const char *DefMips64CPU = "mips64r2";
Akira Hatanaka37fd9e92011-09-26 21:07:52 +00001052
Daniel Sanders2bf13662014-07-10 14:40:57 +00001053 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
1054 // default for mips64(el)?-img-linux-gnu.
1055 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1056 Triple.getEnvironment() == llvm::Triple::GNU) {
1057 DefMips32CPU = "mips32r6";
1058 DefMips64CPU = "mips64r6";
1059 }
Renato Golin7c542b42015-07-27 23:44:45 +00001060
Petar Jovanovic9fe32cd2015-07-17 12:57:30 +00001061 // MIPS64r6 is the default for Android MIPS64 (mips64el-linux-android).
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001062 if (Triple.isAndroid())
Petar Jovanovic9fe32cd2015-07-17 12:57:30 +00001063 DefMips64CPU = "mips64r6";
Daniel Sanders2bf13662014-07-10 14:40:57 +00001064
Brad Smithba26f582015-01-06 02:53:17 +00001065 // MIPS3 is the default for mips64*-unknown-openbsd.
1066 if (Triple.getOS() == llvm::Triple::OpenBSD)
1067 DefMips64CPU = "mips3";
1068
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001069 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
Simon Atanasyane0cc7c72013-10-09 12:12:24 +00001070 CPUName = A->getValue();
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001071
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001072 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001073 ABIName = A->getValue();
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001074 // Convert a GNU style Mips ABI name to the name
1075 // accepted by LLVM Mips backend.
1076 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001077 .Case("32", "o32")
1078 .Case("64", "n64")
1079 .Default(ABIName);
Simon Atanasyan4938ddb2013-04-21 13:30:10 +00001080 }
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001081
1082 // Setup default CPU and ABI names.
1083 if (CPUName.empty() && ABIName.empty()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001084 switch (Triple.getArch()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001085 default:
1086 llvm_unreachable("Unexpected triple arch name");
1087 case llvm::Triple::mips:
1088 case llvm::Triple::mipsel:
1089 CPUName = DefMips32CPU;
1090 break;
1091 case llvm::Triple::mips64:
1092 case llvm::Triple::mips64el:
1093 CPUName = DefMips64CPU;
1094 break;
1095 }
1096 }
1097
Simon Atanasyana42a84e2014-07-02 13:20:36 +00001098 if (ABIName.empty()) {
1099 // Deduce ABI name from the target triple.
1100 if (Triple.getArch() == llvm::Triple::mips ||
1101 Triple.getArch() == llvm::Triple::mipsel)
1102 ABIName = "o32";
1103 else
1104 ABIName = "n64";
1105 }
1106
1107 if (CPUName.empty()) {
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001108 // Deduce CPU name from ABI name.
1109 CPUName = llvm::StringSwitch<const char *>(ABIName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001110 .Cases("o32", "eabi", DefMips32CPU)
1111 .Cases("n32", "n64", DefMips64CPU)
1112 .Default("");
Simon Atanasyan464a7f72012-09-10 08:32:41 +00001113 }
Simon Atanasyanc92717f2014-07-23 09:27:10 +00001114
1115 // FIXME: Warn on inconsistent use of -march and -mabi.
Simon Atanasyan3b7589a2012-04-07 22:09:23 +00001116}
1117
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00001118std::string mips::getMipsABILibSuffix(const ArgList &Args,
1119 const llvm::Triple &Triple) {
1120 StringRef CPUName, ABIName;
1121 tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1122 return llvm::StringSwitch<std::string>(ABIName)
1123 .Case("o32", "")
1124 .Case("n32", "32")
1125 .Case("n64", "64");
1126}
1127
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001128// Convert ABI name to the GNU tools acceptable variant.
1129static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1130 return llvm::StringSwitch<llvm::StringRef>(ABI)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001131 .Case("o32", "32")
1132 .Case("n64", "64")
1133 .Default(ABI);
Simon Atanasyan0da400c2013-02-27 14:55:49 +00001134}
1135
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001136// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1137// and -mfloat-abi=.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001138static mips::FloatABI getMipsFloatABI(const Driver &D, const ArgList &Args) {
1139 mips::FloatABI ABI = mips::FloatABI::Invalid;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001140 if (Arg *A =
1141 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1142 options::OPT_mfloat_abi_EQ)) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001143 if (A->getOption().matches(options::OPT_msoft_float))
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001144 ABI = mips::FloatABI::Soft;
Eric Christopher0b26a612010-03-02 02:41:08 +00001145 else if (A->getOption().matches(options::OPT_mhard_float))
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001146 ABI = mips::FloatABI::Hard;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001147 else {
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001148 ABI = llvm::StringSwitch<mips::FloatABI>(A->getValue())
1149 .Case("soft", mips::FloatABI::Soft)
1150 .Case("hard", mips::FloatABI::Hard)
1151 .Default(mips::FloatABI::Invalid);
1152 if (ABI == mips::FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001153 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001154 ABI = mips::FloatABI::Hard;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001155 }
1156 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001157 }
1158
1159 // If unspecified, choose the default based on the platform.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001160 if (ABI == mips::FloatABI::Invalid) {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001161 // Assume "hard", because it's a default value used by gcc.
1162 // When we start to recognize specific target MIPS processors,
1163 // we will be able to select the default more correctly.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001164 ABI = mips::FloatABI::Hard;
Eric Christopher0b26a612010-03-02 02:41:08 +00001165 }
1166
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001167 assert(ABI != mips::FloatABI::Invalid && "must select an ABI");
1168 return ABI;
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001169}
1170
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001171static void AddTargetFeature(const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001172 std::vector<const char *> &Features,
1173 OptSpecifier OnOpt, OptSpecifier OffOpt,
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001174 StringRef FeatureName) {
1175 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001176 if (A->getOption().matches(OnOpt))
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001177 Features.push_back(Args.MakeArgString("+" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001178 else
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001179 Features.push_back(Args.MakeArgString("-" + FeatureName));
Simon Atanasyan9b1932d2012-07-05 18:51:43 +00001180 }
1181}
1182
Daniel Sanders379d44b2014-07-16 11:52:23 +00001183static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1184 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001185 std::vector<const char *> &Features) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00001186 StringRef CPUName;
1187 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001188 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00001189 ABIName = getGnuCompatibleMipsABIName(ABIName);
1190
Daniel Sandersfeb61302014-08-08 15:47:17 +00001191 AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1192 options::OPT_mabicalls, "noabicalls");
Daniel Sanderse805f442014-08-08 13:44:50 +00001193
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001194 mips::FloatABI FloatABI = getMipsFloatABI(D, Args);
1195 if (FloatABI == mips::FloatABI::Soft) {
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001196 // FIXME: Note, this is a hack. We need to pass the selected float
1197 // mode to the MipsTargetInfoBase to define appropriate macros there.
1198 // Now it is the only method.
1199 Features.push_back("+soft-float");
1200 }
1201
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001202 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
Matheus Almeida602bff32014-05-07 16:16:07 +00001203 StringRef Val = StringRef(A->getValue());
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00001204 if (Val == "2008") {
1205 if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1206 Features.push_back("+nan2008");
1207 else {
1208 Features.push_back("-nan2008");
1209 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1210 }
1211 } else if (Val == "legacy") {
1212 if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1213 Features.push_back("-nan2008");
1214 else {
1215 Features.push_back("+nan2008");
1216 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1217 }
1218 } else
Matheus Almeida602bff32014-05-07 16:16:07 +00001219 D.Diag(diag::err_drv_unsupported_option_argument)
1220 << A->getOption().getName() << Val;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00001221 }
1222
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001223 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1224 options::OPT_mdouble_float, "single-float");
1225 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1226 "mips16");
1227 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1228 options::OPT_mno_micromips, "micromips");
1229 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1230 "dsp");
1231 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1232 "dspr2");
1233 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1234 "msa");
Daniel Sanders379d44b2014-07-16 11:52:23 +00001235
1236 // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1237 // pass -mfpxx
1238 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1239 options::OPT_mfp64)) {
1240 if (A->getOption().matches(options::OPT_mfp32))
1241 Features.push_back(Args.MakeArgString("-fp64"));
1242 else if (A->getOption().matches(options::OPT_mfpxx)) {
1243 Features.push_back(Args.MakeArgString("+fpxx"));
1244 Features.push_back(Args.MakeArgString("+nooddspreg"));
1245 } else
1246 Features.push_back(Args.MakeArgString("+fp64"));
Toma Tabacu94ea6862015-06-16 13:54:13 +00001247 } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) {
Daniel Sanders2e9427a2014-07-16 09:57:54 +00001248 Features.push_back(Args.MakeArgString("+fpxx"));
1249 Features.push_back(Args.MakeArgString("+nooddspreg"));
1250 }
Daniel Sanders379d44b2014-07-16 11:52:23 +00001251
Daniel Sanders28e5d392014-07-10 10:39:51 +00001252 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1253 options::OPT_modd_spreg, "nooddspreg");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001254}
1255
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001256void Clang::AddMIPSTargetArgs(const ArgList &Args,
Simon Atanasyanf0087242013-04-14 14:07:41 +00001257 ArgStringList &CmdArgs) const {
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001258 const Driver &D = getToolChain().getDriver();
1259 StringRef CPUName;
1260 StringRef ABIName;
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001261 const llvm::Triple &Triple = getToolChain().getTriple();
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001262 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
Simon Atanasyan590ad8f2012-06-02 15:06:29 +00001263
1264 CmdArgs.push_back("-target-abi");
1265 CmdArgs.push_back(ABIName.data());
1266
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001267 mips::FloatABI ABI = getMipsFloatABI(D, Args);
1268 if (ABI == mips::FloatABI::Soft) {
Eric Christopher0b26a612010-03-02 02:41:08 +00001269 // Floating point operations and argument passing are soft.
Eric Christopher0b26a612010-03-02 02:41:08 +00001270 CmdArgs.push_back("-msoft-float");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001271 CmdArgs.push_back("-mfloat-abi");
1272 CmdArgs.push_back("soft");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001273 } else {
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001274 // Floating point operations and argument passing are hard.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00001275 assert(ABI == mips::FloatABI::Hard && "Invalid float abi!");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00001276 CmdArgs.push_back("-mfloat-abi");
1277 CmdArgs.push_back("hard");
Eric Christopher0b26a612010-03-02 02:41:08 +00001278 }
Simon Atanasyan6f23fa02012-07-05 14:19:39 +00001279
Simon Atanasyan2eaec512012-12-01 18:27:21 +00001280 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1281 if (A->getOption().matches(options::OPT_mxgot)) {
1282 CmdArgs.push_back("-mllvm");
1283 CmdArgs.push_back("-mxgot");
1284 }
1285 }
1286
Simon Atanasyanc580b322013-05-11 06:33:44 +00001287 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1288 options::OPT_mno_ldc1_sdc1)) {
1289 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1290 CmdArgs.push_back("-mllvm");
1291 CmdArgs.push_back("-mno-ldc1-sdc1");
1292 }
1293 }
1294
Akira Hatanaka0aa60ef2013-07-19 18:58:48 +00001295 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1296 options::OPT_mno_check_zero_division)) {
1297 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1298 CmdArgs.push_back("-mllvm");
1299 CmdArgs.push_back("-mno-check-zero-division");
1300 }
1301 }
1302
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001303 if (Arg *A = Args.getLastArg(options::OPT_G)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001304 StringRef v = A->getValue();
Simon Atanasyanec4b1c12012-08-27 20:55:56 +00001305 CmdArgs.push_back("-mllvm");
1306 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1307 A->claim();
1308 }
Eric Christopher0b26a612010-03-02 02:41:08 +00001309}
1310
Hal Finkel8eb59282012-06-11 22:35:19 +00001311/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1312static std::string getPPCTargetCPU(const ArgList &Args) {
1313 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001314 StringRef CPUName = A->getValue();
Hal Finkel8eb59282012-06-11 22:35:19 +00001315
1316 if (CPUName == "native") {
1317 std::string CPU = llvm::sys::getHostCPUName();
1318 if (!CPU.empty() && CPU != "generic")
1319 return CPU;
1320 else
1321 return "";
1322 }
1323
1324 return llvm::StringSwitch<const char *>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001325 .Case("common", "generic")
1326 .Case("440", "440")
1327 .Case("440fp", "440")
1328 .Case("450", "450")
1329 .Case("601", "601")
1330 .Case("602", "602")
1331 .Case("603", "603")
1332 .Case("603e", "603e")
1333 .Case("603ev", "603ev")
1334 .Case("604", "604")
1335 .Case("604e", "604e")
1336 .Case("620", "620")
1337 .Case("630", "pwr3")
1338 .Case("G3", "g3")
1339 .Case("7400", "7400")
1340 .Case("G4", "g4")
1341 .Case("7450", "7450")
1342 .Case("G4+", "g4+")
1343 .Case("750", "750")
1344 .Case("970", "970")
1345 .Case("G5", "g5")
1346 .Case("a2", "a2")
1347 .Case("a2q", "a2q")
1348 .Case("e500mc", "e500mc")
1349 .Case("e5500", "e5500")
1350 .Case("power3", "pwr3")
1351 .Case("power4", "pwr4")
1352 .Case("power5", "pwr5")
1353 .Case("power5x", "pwr5x")
1354 .Case("power6", "pwr6")
1355 .Case("power6x", "pwr6x")
1356 .Case("power7", "pwr7")
1357 .Case("power8", "pwr8")
1358 .Case("pwr3", "pwr3")
1359 .Case("pwr4", "pwr4")
1360 .Case("pwr5", "pwr5")
1361 .Case("pwr5x", "pwr5x")
1362 .Case("pwr6", "pwr6")
1363 .Case("pwr6x", "pwr6x")
1364 .Case("pwr7", "pwr7")
1365 .Case("pwr8", "pwr8")
1366 .Case("powerpc", "ppc")
1367 .Case("powerpc64", "ppc64")
1368 .Case("powerpc64le", "ppc64le")
1369 .Default("");
Hal Finkel8eb59282012-06-11 22:35:19 +00001370 }
1371
1372 return "";
1373}
1374
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001375static void getPPCTargetFeatures(const ArgList &Args,
1376 std::vector<const char *> &Features) {
Sean Silva14facf32015-06-09 01:57:17 +00001377 for (const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1378 StringRef Name = A->getOption().getName();
1379 A->claim();
Eric Christopher643bb6a2013-10-16 20:40:08 +00001380
1381 // Skip over "-m".
1382 assert(Name.startswith("m") && "Invalid feature name.");
1383 Name = Name.substr(1);
1384
1385 bool IsNegative = Name.startswith("no-");
1386 if (IsNegative)
1387 Name = Name.substr(3);
1388
1389 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1390 // pass the correct option to the backend while calling the frontend
1391 // option the same.
1392 // TODO: Change the LLVM backend option maybe?
1393 if (Name == "mfcrf")
1394 Name = "mfocrf";
1395
1396 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1397 }
1398
1399 // Altivec is a bit weird, allow overriding of the Altivec feature here.
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001400 AddTargetFeature(Args, Features, options::OPT_faltivec,
1401 options::OPT_fno_altivec, "altivec");
Hal Finkel8eb59282012-06-11 22:35:19 +00001402}
1403
Ulrich Weigand8afad612014-07-28 13:17:52 +00001404void Clang::AddPPCTargetArgs(const ArgList &Args,
1405 ArgStringList &CmdArgs) const {
1406 // Select the ABI to use.
1407 const char *ABIName = nullptr;
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001408 if (getToolChain().getTriple().isOSLinux())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001409 switch (getToolChain().getArch()) {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001410 case llvm::Triple::ppc64: {
1411 // When targeting a processor that supports QPX, or if QPX is
1412 // specifically enabled, default to using the ABI that supports QPX (so
1413 // long as it is not specifically disabled).
1414 bool HasQPX = false;
1415 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1416 HasQPX = A->getValue() == StringRef("a2q");
1417 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1418 if (HasQPX) {
1419 ABIName = "elfv1-qpx";
1420 break;
1421 }
1422
Ulrich Weigand8afad612014-07-28 13:17:52 +00001423 ABIName = "elfv1";
1424 break;
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001425 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001426 case llvm::Triple::ppc64le:
1427 ABIName = "elfv2";
1428 break;
1429 default:
1430 break;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001431 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001432
Eric Christopher71e5e3d2015-07-10 18:25:54 +00001433 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1434 // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
1435 // the option if given as we don't have backend support for any targets
1436 // that don't use the altivec abi.
1437 if (StringRef(A->getValue()) != "altivec")
1438 ABIName = A->getValue();
1439
Ulrich Weigand8afad612014-07-28 13:17:52 +00001440 if (ABIName) {
1441 CmdArgs.push_back("-target-abi");
1442 CmdArgs.push_back(ABIName);
1443 }
1444}
1445
1446bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1447 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1448 return A && (A->getValue() == StringRef(Value));
1449}
1450
Tom Stellard6674c702013-04-01 20:56:53 +00001451/// Get the (LLVM) name of the R600 gpu we are targeting.
1452static std::string getR600TargetGPU(const ArgList &Args) {
1453 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001454 const char *GPUName = A->getValue();
Tom Stellard6674c702013-04-01 20:56:53 +00001455 return llvm::StringSwitch<const char *>(GPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001456 .Cases("rv630", "rv635", "r600")
1457 .Cases("rv610", "rv620", "rs780", "rs880")
1458 .Case("rv740", "rv770")
1459 .Case("palm", "cedar")
1460 .Cases("sumo", "sumo2", "sumo")
1461 .Case("hemlock", "cypress")
1462 .Case("aruba", "cayman")
1463 .Default(GPUName);
Tom Stellard6674c702013-04-01 20:56:53 +00001464 }
1465 return "";
1466}
1467
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001468void Clang::AddSparcTargetArgs(const ArgList &Args,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001469 ArgStringList &CmdArgs) const {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001470 const Driver &D = getToolChain().getDriver();
James Y Knightb2406522015-06-15 20:51:24 +00001471 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001472
James Y Knightb2406522015-06-15 20:51:24 +00001473 bool SoftFloatABI = false;
1474 if (Arg *A =
1475 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001476 if (A->getOption().matches(options::OPT_msoft_float))
James Y Knightb2406522015-06-15 20:51:24 +00001477 SoftFloatABI = true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001478 }
1479
James Y Knightb2406522015-06-15 20:51:24 +00001480 // Only the hard-float ABI on Sparc is standardized, and it is the
1481 // default. GCC also supports a nonstandard soft-float ABI mode, and
1482 // perhaps LLVM should implement that, too. However, since llvm
1483 // currently does not support Sparc soft-float, at all, display an
1484 // error if it's requested.
1485 if (SoftFloatABI) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001486 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-msoft-float"
1487 << Triple;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00001488 }
1489}
1490
Richard Sandiford4652d892013-07-19 16:51:51 +00001491static const char *getSystemZTargetCPU(const ArgList &Args) {
1492 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1493 return A->getValue();
1494 return "z10";
1495}
1496
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001497static void getSystemZTargetFeatures(const ArgList &Args,
1498 std::vector<const char *> &Features) {
1499 // -m(no-)htm overrides use of the transactional-execution facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001500 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001501 if (A->getOption().matches(options::OPT_mhtm))
1502 Features.push_back("+transactional-execution");
1503 else
1504 Features.push_back("-transactional-execution");
1505 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001506 // -m(no-)vx overrides use of the vector facility.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001507 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00001508 if (A->getOption().matches(options::OPT_mvx))
1509 Features.push_back("+vector");
1510 else
1511 Features.push_back("-vector");
1512 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00001513}
1514
Chandler Carruth953fb082013-01-13 11:46:33 +00001515static const char *getX86TargetCPU(const ArgList &Args,
1516 const llvm::Triple &Triple) {
1517 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001518 if (StringRef(A->getValue()) != "native") {
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001519 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
Jim Grosbach82eee262013-11-16 00:53:35 +00001520 return "core-avx2";
1521
Chandler Carruth953fb082013-01-13 11:46:33 +00001522 return A->getValue();
Jim Grosbach82eee262013-11-16 00:53:35 +00001523 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001524
1525 // FIXME: Reject attempts to use -march=native unless the target matches
1526 // the host.
1527 //
1528 // FIXME: We should also incorporate the detected target features for use
1529 // with -native.
1530 std::string CPU = llvm::sys::getHostCPUName();
1531 if (!CPU.empty() && CPU != "generic")
1532 return Args.MakeArgString(CPU);
1533 }
1534
Reid Kleckner3123eff2015-06-30 16:32:04 +00001535 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1536 // Mapping built by referring to X86TargetInfo::getDefaultFeatures().
1537 StringRef Arch = A->getValue();
1538 const char *CPU;
1539 if (Triple.getArch() == llvm::Triple::x86) {
1540 CPU = llvm::StringSwitch<const char *>(Arch)
1541 .Case("IA32", "i386")
1542 .Case("SSE", "pentium3")
1543 .Case("SSE2", "pentium4")
1544 .Case("AVX", "sandybridge")
1545 .Case("AVX2", "haswell")
1546 .Default(nullptr);
1547 } else {
1548 CPU = llvm::StringSwitch<const char *>(Arch)
1549 .Case("AVX", "sandybridge")
1550 .Case("AVX2", "haswell")
1551 .Default(nullptr);
1552 }
1553 if (CPU)
1554 return CPU;
1555 }
1556
Chandler Carruth953fb082013-01-13 11:46:33 +00001557 // Select the default CPU if none was given (or detection failed).
1558
1559 if (Triple.getArch() != llvm::Triple::x86_64 &&
1560 Triple.getArch() != llvm::Triple::x86)
Craig Topper92fc2df2014-05-17 16:56:41 +00001561 return nullptr; // This routine is only handling x86 targets.
Chandler Carruth953fb082013-01-13 11:46:33 +00001562
1563 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1564
1565 // FIXME: Need target hooks.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001566 if (Triple.isOSDarwin()) {
Jim Grosbach82eee262013-11-16 00:53:35 +00001567 if (Triple.getArchName() == "x86_64h")
1568 return "core-avx2";
Chandler Carruth953fb082013-01-13 11:46:33 +00001569 return Is64Bit ? "core2" : "yonah";
Jim Grosbach82eee262013-11-16 00:53:35 +00001570 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001571
Filipe Cabecinhas4b442572015-01-27 17:27:37 +00001572 // Set up default CPU name for PS4 compilers.
1573 if (Triple.isPS4CPU())
1574 return "btver2";
1575
Alexey Bataev286d1b92014-01-31 04:07:13 +00001576 // On Android use targets compatible with gcc
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001577 if (Triple.isAndroid())
Alexey Bataev286d1b92014-01-31 04:07:13 +00001578 return Is64Bit ? "x86-64" : "i686";
Chandler Carruth953fb082013-01-13 11:46:33 +00001579
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00001580 // Everything else goes to x86-64 in 64-bit mode.
1581 if (Is64Bit)
1582 return "x86-64";
1583
1584 switch (Triple.getOS()) {
1585 case llvm::Triple::FreeBSD:
1586 case llvm::Triple::NetBSD:
1587 case llvm::Triple::OpenBSD:
1588 return "i486";
1589 case llvm::Triple::Haiku:
1590 return "i586";
1591 case llvm::Triple::Bitrig:
1592 return "i686";
1593 default:
1594 // Fallback to p4.
1595 return "pentium4";
1596 }
Chandler Carruth953fb082013-01-13 11:46:33 +00001597}
1598
Dan Gohmanc2853072015-09-03 22:51:53 +00001599/// Get the (LLVM) name of the WebAssembly cpu we are targeting.
1600static StringRef getWebAssemblyTargetCPU(const ArgList &Args) {
1601 // If we have -mcpu=, use that.
1602 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1603 StringRef CPU = A->getValue();
1604
1605#ifdef __wasm__
1606 // Handle "native" by examining the host. "native" isn't meaningful when
1607 // cross compiling, so only support this when the host is also WebAssembly.
1608 if (CPU == "native")
1609 return llvm::sys::getHostCPUName();
1610#endif
1611
1612 return CPU;
1613 }
1614
1615 return "generic";
1616}
1617
Renato Golin7c542b42015-07-27 23:44:45 +00001618static std::string getCPUName(const ArgList &Args, const llvm::Triple &T,
1619 bool FromAs = false) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001620 switch (T.getArch()) {
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001621 default:
1622 return "";
1623
Amara Emerson703da2e2013-10-31 09:32:33 +00001624 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00001625 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00001626 return getAArch64TargetCPU(Args);
Quentin Colombetd9f26202014-04-15 00:27:35 +00001627
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001628 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00001629 case llvm::Triple::armeb:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001630 case llvm::Triple::thumb:
Renato Goline17c5802015-07-27 23:44:42 +00001631 case llvm::Triple::thumbeb: {
1632 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00001633 getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs);
Renato Goline17c5802015-07-27 23:44:42 +00001634 return arm::getARMTargetCPU(MCPU, MArch, T);
1635 }
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001636 case llvm::Triple::mips:
1637 case llvm::Triple::mipsel:
1638 case llvm::Triple::mips64:
1639 case llvm::Triple::mips64el: {
1640 StringRef CPUName;
1641 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00001642 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001643 return CPUName;
1644 }
1645
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001646 case llvm::Triple::nvptx:
1647 case llvm::Triple::nvptx64:
1648 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1649 return A->getValue();
1650 return "";
1651
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001652 case llvm::Triple::ppc:
1653 case llvm::Triple::ppc64:
1654 case llvm::Triple::ppc64le: {
1655 std::string TargetCPUName = getPPCTargetCPU(Args);
1656 // LLVM may default to generating code for the native CPU,
1657 // but, like gcc, we default to a more generic option for
1658 // each architecture. (except on Darwin)
1659 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1660 if (T.getArch() == llvm::Triple::ppc64)
1661 TargetCPUName = "ppc64";
1662 else if (T.getArch() == llvm::Triple::ppc64le)
1663 TargetCPUName = "ppc64le";
1664 else
1665 TargetCPUName = "ppc";
1666 }
1667 return TargetCPUName;
1668 }
1669
1670 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00001671 case llvm::Triple::sparcel:
Roman Divackyb1ae3d42014-02-25 18:35:30 +00001672 case llvm::Triple::sparcv9:
1673 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001674 return A->getValue();
1675 return "";
1676
1677 case llvm::Triple::x86:
1678 case llvm::Triple::x86_64:
1679 return getX86TargetCPU(Args, T);
1680
1681 case llvm::Triple::hexagon:
Douglas Katzman54366072015-07-27 16:53:08 +00001682 return "hexagon" + toolchains::HexagonToolChain::GetTargetCPU(Args).str();
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001683
1684 case llvm::Triple::systemz:
1685 return getSystemZTargetCPU(Args);
1686
1687 case llvm::Triple::r600:
Tom Stellardd8e38a32015-01-06 20:34:47 +00001688 case llvm::Triple::amdgcn:
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001689 return getR600TargetGPU(Args);
Dan Gohmanc2853072015-09-03 22:51:53 +00001690
1691 case llvm::Triple::wasm32:
1692 case llvm::Triple::wasm64:
1693 return getWebAssemblyTargetCPU(Args);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00001694 }
1695}
1696
Alp Tokerce365ca2013-12-02 12:43:03 +00001697static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
Teresa Johnson945bc502015-10-15 20:35:53 +00001698 ArgStringList &CmdArgs, bool IsThinLTO) {
Alp Tokerce365ca2013-12-02 12:43:03 +00001699 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1700 // as gold requires -plugin to come before any -plugin-opt that -Wl might
1701 // forward.
1702 CmdArgs.push_back("-plugin");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001703 std::string Plugin =
1704 ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
Alp Tokerce365ca2013-12-02 12:43:03 +00001705 CmdArgs.push_back(Args.MakeArgString(Plugin));
1706
1707 // Try to pass driver level flags relevant to LTO code generation down to
1708 // the plugin.
1709
1710 // Handle flags for selecting CPU variants.
1711 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1712 if (!CPU.empty())
1713 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
Teresa Johnson945bc502015-10-15 20:35:53 +00001714
Teresa Johnson6ef80dc2015-11-02 18:03:12 +00001715 if (IsThinLTO)
1716 CmdArgs.push_back("-plugin-opt=thinlto");
Alp Tokerce365ca2013-12-02 12:43:03 +00001717}
1718
Sanjay Patel2987c292015-06-11 14:53:41 +00001719/// This is a helper function for validating the optional refinement step
1720/// parameter in reciprocal argument strings. Return false if there is an error
1721/// parsing the refinement step. Otherwise, return true and set the Position
1722/// of the refinement step in the input string.
Craig Topper3db9ba42015-09-21 00:20:04 +00001723static bool getRefinementStep(StringRef In, const Driver &D,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001724 const Arg &A, size_t &Position) {
Sanjay Patel2987c292015-06-11 14:53:41 +00001725 const char RefinementStepToken = ':';
1726 Position = In.find(RefinementStepToken);
1727 if (Position != StringRef::npos) {
1728 StringRef Option = A.getOption().getName();
1729 StringRef RefStep = In.substr(Position + 1);
1730 // Allow exactly one numeric character for the additional refinement
1731 // step parameter. This is reasonable for all currently-supported
1732 // operations and architectures because we would expect that a larger value
1733 // of refinement steps would cause the estimate "optimization" to
1734 // under-perform the native operation. Also, if the estimate does not
1735 // converge quickly, it probably will not ever converge, so further
1736 // refinement steps will not produce a better answer.
1737 if (RefStep.size() != 1) {
1738 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1739 return false;
1740 }
1741 char RefStepChar = RefStep[0];
1742 if (RefStepChar < '0' || RefStepChar > '9') {
1743 D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1744 return false;
1745 }
1746 }
1747 return true;
1748}
1749
1750/// The -mrecip flag requires processing of many optional parameters.
1751static void ParseMRecip(const Driver &D, const ArgList &Args,
1752 ArgStringList &OutStrings) {
1753 StringRef DisabledPrefixIn = "!";
1754 StringRef DisabledPrefixOut = "!";
1755 StringRef EnabledPrefixOut = "";
1756 StringRef Out = "-mrecip=";
1757
1758 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1759 if (!A)
1760 return;
1761
1762 unsigned NumOptions = A->getNumValues();
1763 if (NumOptions == 0) {
1764 // No option is the same as "all".
1765 OutStrings.push_back(Args.MakeArgString(Out + "all"));
1766 return;
1767 }
1768
1769 // Pass through "all", "none", or "default" with an optional refinement step.
1770 if (NumOptions == 1) {
1771 StringRef Val = A->getValue(0);
1772 size_t RefStepLoc;
1773 if (!getRefinementStep(Val, D, *A, RefStepLoc))
1774 return;
1775 StringRef ValBase = Val.slice(0, RefStepLoc);
1776 if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1777 OutStrings.push_back(Args.MakeArgString(Out + Val));
1778 return;
1779 }
1780 }
1781
1782 // Each reciprocal type may be enabled or disabled individually.
1783 // Check each input value for validity, concatenate them all back together,
1784 // and pass through.
1785
1786 llvm::StringMap<bool> OptionStrings;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001787 OptionStrings.insert(std::make_pair("divd", false));
1788 OptionStrings.insert(std::make_pair("divf", false));
1789 OptionStrings.insert(std::make_pair("vec-divd", false));
1790 OptionStrings.insert(std::make_pair("vec-divf", false));
1791 OptionStrings.insert(std::make_pair("sqrtd", false));
1792 OptionStrings.insert(std::make_pair("sqrtf", false));
1793 OptionStrings.insert(std::make_pair("vec-sqrtd", false));
1794 OptionStrings.insert(std::make_pair("vec-sqrtf", false));
Sanjay Patel2987c292015-06-11 14:53:41 +00001795
1796 for (unsigned i = 0; i != NumOptions; ++i) {
1797 StringRef Val = A->getValue(i);
1798
1799 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1800 // Ignore the disablement token for string matching.
1801 if (IsDisabled)
1802 Val = Val.substr(1);
1803
1804 size_t RefStep;
1805 if (!getRefinementStep(Val, D, *A, RefStep))
1806 return;
1807
1808 StringRef ValBase = Val.slice(0, RefStep);
1809 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1810 if (OptionIter == OptionStrings.end()) {
1811 // Try again specifying float suffix.
1812 OptionIter = OptionStrings.find(ValBase.str() + 'f');
1813 if (OptionIter == OptionStrings.end()) {
1814 // The input name did not match any known option string.
1815 D.Diag(diag::err_drv_unknown_argument) << Val;
1816 return;
1817 }
1818 // The option was specified without a float or double suffix.
1819 // Make sure that the double entry was not already specified.
1820 // The float entry will be checked below.
1821 if (OptionStrings[ValBase.str() + 'd']) {
1822 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1823 return;
1824 }
1825 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001826
Sanjay Patel2987c292015-06-11 14:53:41 +00001827 if (OptionIter->second == true) {
1828 // Duplicate option specified.
1829 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1830 return;
1831 }
1832
1833 // Mark the matched option as found. Do not allow duplicate specifiers.
1834 OptionIter->second = true;
1835
1836 // If the precision was not specified, also mark the double entry as found.
1837 if (ValBase.back() != 'f' && ValBase.back() != 'd')
1838 OptionStrings[ValBase.str() + 'd'] = true;
1839
1840 // Build the output string.
1841 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1842 Out = Args.MakeArgString(Out + Prefix + Val);
1843 if (i != NumOptions - 1)
1844 Out = Args.MakeArgString(Out + ",");
1845 }
1846
1847 OutStrings.push_back(Args.MakeArgString(Out));
1848}
1849
Eric Christopherc54920a2015-03-23 19:26:05 +00001850static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
Jim Grosbach82eee262013-11-16 00:53:35 +00001851 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001852 std::vector<const char *> &Features) {
Craig Toppera8bd6002015-03-31 05:45:00 +00001853 // If -march=native, autodetect the feature list.
1854 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1855 if (StringRef(A->getValue()) == "native") {
1856 llvm::StringMap<bool> HostFeatures;
1857 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1858 for (auto &F : HostFeatures)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001859 Features.push_back(
1860 Args.MakeArgString((F.second ? "+" : "-") + F.first()));
Craig Toppera8bd6002015-03-31 05:45:00 +00001861 }
1862 }
1863
Jim Grosbach82eee262013-11-16 00:53:35 +00001864 if (Triple.getArchName() == "x86_64h") {
1865 // x86_64h implies quite a few of the more modern subtarget features
1866 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1867 Features.push_back("-rdrnd");
1868 Features.push_back("-aes");
1869 Features.push_back("-pclmul");
1870 Features.push_back("-rtm");
1871 Features.push_back("-hle");
1872 Features.push_back("-fsgsbase");
1873 }
1874
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001875 const llvm::Triple::ArchType ArchType = Triple.getArch();
Eric Christopherc54920a2015-03-23 19:26:05 +00001876 // Add features to be compatible with gcc for Android.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00001877 if (Triple.isAndroid()) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001878 if (ArchType == llvm::Triple::x86_64) {
Alexey Volkov54ff0802014-06-25 12:15:36 +00001879 Features.push_back("+sse4.2");
1880 Features.push_back("+popcnt");
1881 } else
1882 Features.push_back("+ssse3");
Alexey Bataev286d1b92014-01-31 04:07:13 +00001883 }
1884
Eric Christopherc54920a2015-03-23 19:26:05 +00001885 // Set features according to the -arch flag on MSVC.
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001886 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1887 StringRef Arch = A->getValue();
1888 bool ArchUsed = false;
1889 // First, look for flags that are shared in x86 and x86-64.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001890 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001891 if (Arch == "AVX" || Arch == "AVX2") {
1892 ArchUsed = true;
1893 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1894 }
1895 }
1896 // Then, look for x86-specific flags.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00001897 if (ArchType == llvm::Triple::x86) {
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00001898 if (Arch == "IA32") {
1899 ArchUsed = true;
1900 } else if (Arch == "SSE" || Arch == "SSE2") {
1901 ArchUsed = true;
1902 Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1903 }
1904 }
1905 if (!ArchUsed)
1906 D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1907 }
1908
Jim Grosbach82eee262013-11-16 00:53:35 +00001909 // Now add any that the user explicitly requested on the command line,
1910 // which may override the defaults.
Sean Silva14facf32015-06-09 01:57:17 +00001911 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1912 StringRef Name = A->getOption().getName();
1913 A->claim();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00001914
1915 // Skip over "-m".
1916 assert(Name.startswith("m") && "Invalid feature name.");
1917 Name = Name.substr(1);
1918
1919 bool IsNegative = Name.startswith("no-");
1920 if (IsNegative)
1921 Name = Name.substr(3);
1922
1923 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1924 }
1925}
1926
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001927void Clang::AddX86TargetArgs(const ArgList &Args,
1928 ArgStringList &CmdArgs) const {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001929 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001930 Args.hasArg(options::OPT_mkernel) ||
1931 Args.hasArg(options::OPT_fapple_kext))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001932 CmdArgs.push_back("-disable-red-zone");
Daniel Dunbare2cf8f72009-09-10 22:59:57 +00001933
Bob Wilson2616e2e2013-02-10 16:01:41 +00001934 // Default to avoid implicit floating-point for kernel/kext code, but allow
1935 // that to be overridden with -mno-soft-float.
1936 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1937 Args.hasArg(options::OPT_fapple_kext));
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001938 if (Arg *A = Args.getLastArg(
1939 options::OPT_msoft_float, options::OPT_mno_soft_float,
1940 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
Bob Wilson2616e2e2013-02-10 16:01:41 +00001941 const Option &O = A->getOption();
1942 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1943 O.matches(options::OPT_msoft_float));
1944 }
1945 if (NoImplicitFloat)
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00001946 CmdArgs.push_back("-no-implicit-float");
Nico Weberad8e36c2014-05-13 11:11:24 +00001947
1948 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1949 StringRef Value = A->getValue();
1950 if (Value == "intel" || Value == "att") {
1951 CmdArgs.push_back("-mllvm");
1952 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1953 } else {
1954 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1955 << A->getOption().getName() << Value;
1956 }
1957 }
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00001958}
1959
Tony Linthicum76329bf2011-12-12 21:14:55 +00001960void Clang::AddHexagonTargetArgs(const ArgList &Args,
1961 ArgStringList &CmdArgs) const {
Matthew Curtis6b222782012-12-07 13:52:44 +00001962 CmdArgs.push_back("-mqdsp6-compat");
1963 CmdArgs.push_back("-Wreturn-type");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001964
Douglas Katzman54366072015-07-27 16:53:08 +00001965 if (const char *v =
1966 toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001967 std::string SmallDataThreshold = "-hexagon-small-data-threshold=";
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001968 SmallDataThreshold += v;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001969 CmdArgs.push_back("-mllvm");
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00001970 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
Tony Linthicum76329bf2011-12-12 21:14:55 +00001971 }
1972
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001973 if (!Args.hasArg(options::OPT_fno_short_enums))
1974 CmdArgs.push_back("-fshort-enums");
1975 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001976 CmdArgs.push_back("-mllvm");
1977 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00001978 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001979 CmdArgs.push_back("-mllvm");
1980 CmdArgs.push_back("-machine-sink-split=0");
Tony Linthicum76329bf2011-12-12 21:14:55 +00001981}
1982
Kevin Qin110db6f2014-07-18 07:03:22 +00001983// Decode AArch64 features from string like +[no]featureA+[no]featureB+...
Craig Topperbf3e3272014-08-30 16:55:52 +00001984static bool DecodeAArch64Features(const Driver &D, StringRef text,
Kevin Qin110db6f2014-07-18 07:03:22 +00001985 std::vector<const char *> &Features) {
1986 SmallVector<StringRef, 8> Split;
1987 text.split(Split, StringRef("+"), -1, false);
1988
Benjamin Kramer72e64312015-09-24 14:48:49 +00001989 for (StringRef Feature : Split) {
Douglas Katzman2675d012015-06-29 19:12:56 +00001990 const char *result = llvm::StringSwitch<const char *>(Feature)
Kevin Qin110db6f2014-07-18 07:03:22 +00001991 .Case("fp", "+fp-armv8")
1992 .Case("simd", "+neon")
1993 .Case("crc", "+crc")
1994 .Case("crypto", "+crypto")
1995 .Case("nofp", "-fp-armv8")
1996 .Case("nosimd", "-neon")
1997 .Case("nocrc", "-crc")
1998 .Case("nocrypto", "-crypto")
1999 .Default(nullptr);
2000 if (result)
2001 Features.push_back(result);
Douglas Katzman2675d012015-06-29 19:12:56 +00002002 else if (Feature == "neon" || Feature == "noneon")
Kevin Qin110db6f2014-07-18 07:03:22 +00002003 D.Diag(diag::err_drv_no_neon_modifier);
2004 else
2005 return false;
2006 }
2007 return true;
2008}
2009
2010// Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
2011// decode CPU and feature.
2012static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
2013 std::vector<const char *> &Features) {
2014 std::pair<StringRef, StringRef> Split = Mcpu.split("+");
2015 CPU = Split.first;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002016 if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" ||
2017 CPU == "cortex-a72") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002018 Features.push_back("+neon");
2019 Features.push_back("+crc");
2020 Features.push_back("+crypto");
2021 } else if (CPU == "generic") {
2022 Features.push_back("+neon");
2023 } else {
2024 return false;
2025 }
2026
2027 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
2028 return false;
2029
2030 return true;
2031}
2032
2033static bool
2034getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
2035 const ArgList &Args,
2036 std::vector<const char *> &Features) {
Gabor Ballabas36451492015-06-18 14:23:12 +00002037 std::string MarchLowerCase = March.lower();
2038 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002039
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002040 if (Split.first == "armv8-a" || Split.first == "armv8a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002041 // ok, no additional features.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002042 } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") {
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002043 Features.push_back("+v8.1a");
2044 } else {
Kevin Qin110db6f2014-07-18 07:03:22 +00002045 return false;
Vladimir Sukhareve851e042015-04-16 15:53:09 +00002046 }
Kevin Qin110db6f2014-07-18 07:03:22 +00002047
2048 if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
2049 return false;
2050
2051 return true;
2052}
2053
2054static bool
2055getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2056 const ArgList &Args,
2057 std::vector<const char *> &Features) {
2058 StringRef CPU;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002059 std::string McpuLowerCase = Mcpu.lower();
2060 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
Kevin Qin110db6f2014-07-18 07:03:22 +00002061 return false;
2062
2063 return true;
2064}
2065
2066static bool
2067getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
2068 const ArgList &Args,
2069 std::vector<const char *> &Features) {
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002070 std::string MtuneLowerCase = Mtune.lower();
Kevin Qin110db6f2014-07-18 07:03:22 +00002071 // Handle CPU name is 'native'.
Gabor Ballabasa24a1a42015-07-20 11:28:20 +00002072 if (MtuneLowerCase == "native")
2073 MtuneLowerCase = llvm::sys::getHostCPUName();
2074 if (MtuneLowerCase == "cyclone") {
Kevin Qin110db6f2014-07-18 07:03:22 +00002075 Features.push_back("+zcm");
2076 Features.push_back("+zcz");
2077 }
2078 return true;
2079}
2080
2081static bool
2082getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
2083 const ArgList &Args,
2084 std::vector<const char *> &Features) {
2085 StringRef CPU;
2086 std::vector<const char *> DecodedFeature;
Gabor Ballabas726ce7f2015-06-12 17:33:37 +00002087 std::string McpuLowerCase = Mcpu.lower();
2088 if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
Kevin Qin110db6f2014-07-18 07:03:22 +00002089 return false;
2090
2091 return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
2092}
2093
Akira Hatanaka92500472015-07-27 19:29:04 +00002094static void getAArch64TargetFeatures(const Driver &D,
2095 const llvm::Triple &Triple,
2096 const ArgList &Args,
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002097 std::vector<const char *> &Features) {
Kevin Qin110db6f2014-07-18 07:03:22 +00002098 Arg *A;
2099 bool success = true;
2100 // Enable NEON by default.
2101 Features.push_back("+neon");
2102 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2103 success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
2104 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2105 success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002106 else if (Args.hasArg(options::OPT_arch))
2107 success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
2108 Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002109
2110 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2111 success =
2112 getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
2113 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2114 success =
2115 getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
Tim Northover642e7702014-11-10 21:17:23 +00002116 else if (Args.hasArg(options::OPT_arch))
2117 success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
2118 Args, Features);
Kevin Qin110db6f2014-07-18 07:03:22 +00002119
2120 if (!success)
2121 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Amara Emerson04e2ecf2014-01-23 15:48:30 +00002122
2123 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2124 Features.push_back("-fp-armv8");
2125 Features.push_back("-crypto");
2126 Features.push_back("-neon");
2127 }
Bradley Smith418c5932014-05-02 15:17:51 +00002128
2129 // En/disable crc
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002130 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
Bradley Smith418c5932014-05-02 15:17:51 +00002131 if (A->getOption().matches(options::OPT_mcrc))
2132 Features.push_back("+crc");
2133 else
2134 Features.push_back("-crc");
2135 }
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002136
Akira Hatanaka085da7e2015-07-29 14:25:58 +00002137 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2138 options::OPT_munaligned_access))
2139 if (A->getOption().matches(options::OPT_mno_unaligned_access))
2140 Features.push_back("+strict-align");
2141
Akira Hatanaka92500472015-07-27 19:29:04 +00002142 if (Args.hasArg(options::OPT_ffixed_x18) || Triple.isOSDarwin())
Akira Hatanaka4e3c86f2015-07-25 00:18:00 +00002143 Features.push_back("+reserve-x18");
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002144}
2145
Dan Gohmanc2853072015-09-03 22:51:53 +00002146static void getWebAssemblyTargetFeatures(const ArgList &Args,
2147 std::vector<const char *> &Features) {
2148 for (const Arg *A : Args.filtered(options::OPT_m_wasm_Features_Group)) {
2149 StringRef Name = A->getOption().getName();
2150 A->claim();
2151
2152 // Skip over "-m".
2153 assert(Name.startswith("m") && "Invalid feature name.");
2154 Name = Name.substr(1);
2155
2156 bool IsNegative = Name.startswith("no-");
2157 if (IsNegative)
2158 Name = Name.substr(3);
2159
2160 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
2161 }
2162}
2163
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002164static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple,
Rafael Espindola9c6fb0f2013-11-23 14:36:40 +00002165 const ArgList &Args, ArgStringList &CmdArgs,
2166 bool ForAS) {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002167 const Driver &D = TC.getDriver();
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002168 std::vector<const char *> Features;
2169 switch (Triple.getArch()) {
2170 default:
2171 break;
2172 case llvm::Triple::mips:
2173 case llvm::Triple::mipsel:
2174 case llvm::Triple::mips64:
2175 case llvm::Triple::mips64el:
Daniel Sanders379d44b2014-07-16 11:52:23 +00002176 getMIPSTargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002177 break;
2178
2179 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002180 case llvm::Triple::armeb:
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002181 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00002182 case llvm::Triple::thumbeb:
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00002183 getARMTargetFeatures(TC, Triple, Args, Features, ForAS);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002184 break;
2185
2186 case llvm::Triple::ppc:
2187 case llvm::Triple::ppc64:
2188 case llvm::Triple::ppc64le:
2189 getPPCTargetFeatures(Args, Features);
2190 break;
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00002191 case llvm::Triple::systemz:
2192 getSystemZTargetFeatures(Args, Features);
2193 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002194 case llvm::Triple::aarch64:
Christian Pirker9b019ae2014-02-25 13:51:00 +00002195 case llvm::Triple::aarch64_be:
Akira Hatanaka92500472015-07-27 19:29:04 +00002196 getAArch64TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002197 break;
2198 case llvm::Triple::x86:
2199 case llvm::Triple::x86_64:
Ehsan Akhgarieeb7e652014-07-15 18:27:51 +00002200 getX86TargetFeatures(D, Triple, Args, Features);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002201 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00002202 case llvm::Triple::wasm32:
2203 case llvm::Triple::wasm64:
2204 getWebAssemblyTargetFeatures(Args, Features);
2205 break;
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002206 }
Rafael Espindola43964802013-08-21 17:34:32 +00002207
2208 // Find the last of each feature.
2209 llvm::StringMap<unsigned> LastOpt;
2210 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2211 const char *Name = Features[I];
2212 assert(Name[0] == '-' || Name[0] == '+');
2213 LastOpt[Name + 1] = I;
2214 }
2215
2216 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2217 // If this feature was overridden, ignore it.
2218 const char *Name = Features[I];
2219 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2220 assert(LastI != LastOpt.end());
2221 unsigned Last = LastI->second;
2222 if (Last != I)
2223 continue;
2224
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002225 CmdArgs.push_back("-target-feature");
Rafael Espindola43964802013-08-21 17:34:32 +00002226 CmdArgs.push_back(Name);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00002227 }
Tim Northover2fe823a2013-08-01 09:23:19 +00002228}
2229
David Majnemerae394812014-12-09 00:12:30 +00002230static bool
2231shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2232 const llvm::Triple &Triple) {
2233 // We use the zero-cost exception tables for Objective-C if the non-fragile
2234 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2235 // later.
2236 if (runtime.isNonFragile())
2237 return true;
2238
2239 if (!Triple.isMacOSX())
2240 return false;
2241
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002242 return (!Triple.isMacOSXVersionLT(10, 5) &&
David Majnemerae394812014-12-09 00:12:30 +00002243 (Triple.getArch() == llvm::Triple::x86_64 ||
2244 Triple.getArch() == llvm::Triple::arm));
2245}
2246
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002247/// Adds exception related arguments to the driver command arguments. There's a
2248/// master flag, -fexceptions and also language specific flags to enable/disable
2249/// C++ and Objective-C exceptions. This makes it possible to for example
2250/// disable C++ exceptions but enable Objective-C exceptions.
Anders Carlssone96ab552011-02-28 02:27:16 +00002251static void addExceptionArgs(const ArgList &Args, types::ID InputType,
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002252 const ToolChain &TC, bool KernelOrKext,
John McCall5fb5df92012-06-20 06:18:46 +00002253 const ObjCRuntime &objcRuntime,
Anders Carlssone96ab552011-02-28 02:27:16 +00002254 ArgStringList &CmdArgs) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002255 const Driver &D = TC.getDriver();
2256 const llvm::Triple &Triple = TC.getTriple();
2257
Chad Rosier4fab82c2012-03-26 22:04:46 +00002258 if (KernelOrKext) {
2259 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2260 // arguments now to avoid warnings about unused arguments.
2261 Args.ClaimAllArgs(options::OPT_fexceptions);
2262 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2263 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2264 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2265 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2266 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002267 return;
Chad Rosier4fab82c2012-03-26 22:04:46 +00002268 }
Anders Carlssone96ab552011-02-28 02:27:16 +00002269
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002270 // See if the user explicitly enabled exceptions.
2271 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2272 false);
Daniel Dunbar30a12b82010-09-14 23:12:31 +00002273
David Majnemerae394812014-12-09 00:12:30 +00002274 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2275 // is not necessarily sensible, but follows GCC.
2276 if (types::isObjC(InputType) &&
2277 Args.hasFlag(options::OPT_fobjc_exceptions,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002278 options::OPT_fno_objc_exceptions, true)) {
David Majnemerae394812014-12-09 00:12:30 +00002279 CmdArgs.push_back("-fobjc-exceptions");
Anders Carlssone96ab552011-02-28 02:27:16 +00002280
David Majnemerae394812014-12-09 00:12:30 +00002281 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
Anders Carlssone96ab552011-02-28 02:27:16 +00002282 }
2283
2284 if (types::isCXX(InputType)) {
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00002285 // Disable C++ EH by default on XCore, PS4, and MSVC.
2286 // FIXME: Remove MSVC from this list once things work.
2287 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
2288 !Triple.isPS4CPU() &&
2289 !Triple.isWindowsMSVCEnvironment();
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002290 Arg *ExceptionArg = Args.getLastArg(
2291 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2292 options::OPT_fexceptions, options::OPT_fno_exceptions);
2293 if (ExceptionArg)
David Majnemer8de68642014-12-05 08:11:58 +00002294 CXXExceptionsEnabled =
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002295 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2296 ExceptionArg->getOption().matches(options::OPT_fexceptions);
Anders Carlssone96ab552011-02-28 02:27:16 +00002297
2298 if (CXXExceptionsEnabled) {
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00002299 if (Triple.isPS4CPU()) {
2300 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2301 assert(ExceptionArg &&
2302 "On the PS4 exceptions should only be enabled if passing "
2303 "an argument");
2304 if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2305 const Arg *RTTIArg = TC.getRTTIArg();
2306 assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2307 D.Diag(diag::err_drv_argument_not_allowed_with)
2308 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2309 } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2310 D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2311 } else
2312 assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2313
Anders Carlssone96ab552011-02-28 02:27:16 +00002314 CmdArgs.push_back("-fcxx-exceptions");
2315
David Majnemer8de68642014-12-05 08:11:58 +00002316 EH = true;
Anders Carlssone96ab552011-02-28 02:27:16 +00002317 }
2318 }
2319
David Majnemer8de68642014-12-05 08:11:58 +00002320 if (EH)
Anders Carlssone96ab552011-02-28 02:27:16 +00002321 CmdArgs.push_back("-fexceptions");
Rafael Espindola00a66572009-10-01 13:33:33 +00002322}
2323
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002324static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) {
Daniel Dunbare246fbe2013-04-16 18:21:19 +00002325 bool Default = true;
2326 if (TC.getTriple().isOSDarwin()) {
2327 // The native darwin assembler doesn't support the linker_option directives,
2328 // so we disable them if we think the .s file will be passed to it.
2329 Default = TC.useIntegratedAs();
2330 }
2331 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2332 Default);
2333}
2334
Ted Kremenek62093662013-03-12 17:02:12 +00002335static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2336 const ToolChain &TC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002337 bool UseDwarfDirectory =
2338 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2339 options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
Nick Lewycky1d617ac2011-10-17 23:05:52 +00002340 return !UseDwarfDirectory;
2341}
2342
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002343/// \brief Check whether the given input tree contains any compilation actions.
2344static bool ContainsCompileAction(const Action *A) {
Bob Wilson23a55f12014-12-21 07:00:00 +00002345 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002346 return true;
2347
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002348 for (const auto &Act : *A)
2349 if (ContainsCompileAction(Act))
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002350 return true;
2351
2352 return false;
2353}
2354
2355/// \brief Check if -relax-all should be passed to the internal assembler.
2356/// This is done by default when compiling non-assembler source with -O0.
2357static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2358 bool RelaxDefault = true;
2359
2360 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2361 RelaxDefault = A->getOption().matches(options::OPT_O0);
2362
2363 if (RelaxDefault) {
2364 RelaxDefault = false;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00002365 for (const auto &Act : C.getActions()) {
2366 if (ContainsCompileAction(Act)) {
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002367 RelaxDefault = true;
2368 break;
2369 }
2370 }
2371 }
2372
2373 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002374 RelaxDefault);
Joerg Sonnenbergeref317a22011-05-06 14:35:16 +00002375}
2376
Douglas Katzman3459ce22015-10-08 04:24:12 +00002377// Extract the integer N from a string spelled "-dwarf-N", returning 0
2378// on mismatch. The StringRef input (rather than an Arg) allows
2379// for use by the "-Xassembler" option parser.
2380static unsigned DwarfVersionNum(StringRef ArgValue) {
2381 return llvm::StringSwitch<unsigned>(ArgValue)
2382 .Case("-gdwarf-2", 2)
2383 .Case("-gdwarf-3", 3)
2384 .Case("-gdwarf-4", 4)
2385 .Default(0);
2386}
2387
2388static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
2389 CodeGenOptions::DebugInfoKind DebugInfoKind,
2390 unsigned DwarfVersion) {
2391 switch (DebugInfoKind) {
2392 case CodeGenOptions::DebugLineTablesOnly:
2393 CmdArgs.push_back("-debug-info-kind=line-tables-only");
2394 break;
2395 case CodeGenOptions::LimitedDebugInfo:
2396 CmdArgs.push_back("-debug-info-kind=limited");
2397 break;
2398 case CodeGenOptions::FullDebugInfo:
2399 CmdArgs.push_back("-debug-info-kind=standalone");
2400 break;
2401 default:
2402 break;
2403 }
2404 if (DwarfVersion > 0)
2405 CmdArgs.push_back(
Benjamin Kramer32bd3c82015-10-08 10:31:17 +00002406 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
Douglas Katzman3459ce22015-10-08 04:24:12 +00002407}
2408
David Blaikie9260ed62013-07-25 21:19:01 +00002409static void CollectArgsForIntegratedAssembler(Compilation &C,
2410 const ArgList &Args,
2411 ArgStringList &CmdArgs,
2412 const Driver &D) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002413 if (UseRelaxAll(C, Args))
2414 CmdArgs.push_back("-mrelax-all");
David Blaikie9260ed62013-07-25 21:19:01 +00002415
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002416 // When passing -I arguments to the assembler we sometimes need to
2417 // unconditionally take the next argument. For example, when parsing
2418 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2419 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2420 // arg after parsing the '-I' arg.
2421 bool TakeNextArg = false;
David Peixottodfb66142013-11-14 22:52:58 +00002422
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002423 // When using an integrated assembler, translate -Wa, and -Xassembler
2424 // options.
2425 bool CompressDebugSections = false;
2426 for (const Arg *A :
2427 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2428 A->claim();
David Blaikie9260ed62013-07-25 21:19:01 +00002429
Benjamin Kramer72e64312015-09-24 14:48:49 +00002430 for (StringRef Value : A->getValues()) {
Renato Golin7c542b42015-07-27 23:44:45 +00002431 if (TakeNextArg) {
2432 CmdArgs.push_back(Value.data());
2433 TakeNextArg = false;
2434 continue;
2435 }
David Blaikie9260ed62013-07-25 21:19:01 +00002436
Daniel Sanders3d5e5682015-10-27 18:04:42 +00002437 switch (C.getDefaultToolChain().getArch()) {
2438 default:
2439 break;
2440 case llvm::Triple::mips:
2441 case llvm::Triple::mipsel:
2442 case llvm::Triple::mips64:
2443 case llvm::Triple::mips64el:
2444 if (Value == "--trap") {
2445 CmdArgs.push_back("-target-feature");
2446 CmdArgs.push_back("+use-tcc-in-div");
2447 continue;
2448 }
2449 if (Value == "--break") {
2450 CmdArgs.push_back("-target-feature");
2451 CmdArgs.push_back("-use-tcc-in-div");
2452 continue;
2453 }
2454 if (Value.startswith("-msoft-float")) {
2455 CmdArgs.push_back("-target-feature");
2456 CmdArgs.push_back("+soft-float");
2457 continue;
2458 }
2459 if (Value.startswith("-mhard-float")) {
2460 CmdArgs.push_back("-target-feature");
2461 CmdArgs.push_back("-soft-float");
2462 continue;
2463 }
2464 break;
2465 }
2466
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002467 if (Value == "-force_cpusubtype_ALL") {
2468 // Do nothing, this is the default and we don't support anything else.
2469 } else if (Value == "-L") {
2470 CmdArgs.push_back("-msave-temp-labels");
2471 } else if (Value == "--fatal-warnings") {
2472 CmdArgs.push_back("-massembler-fatal-warnings");
2473 } else if (Value == "--noexecstack") {
2474 CmdArgs.push_back("-mnoexecstack");
2475 } else if (Value == "-compress-debug-sections" ||
2476 Value == "--compress-debug-sections") {
2477 CompressDebugSections = true;
2478 } else if (Value == "-nocompress-debug-sections" ||
2479 Value == "--nocompress-debug-sections") {
2480 CompressDebugSections = false;
2481 } else if (Value.startswith("-I")) {
2482 CmdArgs.push_back(Value.data());
2483 // We need to consume the next argument if the current arg is a plain
2484 // -I. The next arg will be the include directory.
2485 if (Value == "-I")
2486 TakeNextArg = true;
2487 } else if (Value.startswith("-gdwarf-")) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00002488 // "-gdwarf-N" options are not cc1as options.
2489 unsigned DwarfVersion = DwarfVersionNum(Value);
2490 if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.
2491 CmdArgs.push_back(Value.data());
2492 } else {
2493 RenderDebugEnablingArgs(
2494 Args, CmdArgs, CodeGenOptions::LimitedDebugInfo, DwarfVersion);
2495 }
Renato Golin7c542b42015-07-27 23:44:45 +00002496 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
2497 Value.startswith("-mhwdiv") || Value.startswith("-march")) {
2498 // Do nothing, we'll validate it later.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002499 } else {
2500 D.Diag(diag::err_drv_unsupported_option_argument)
David Blaikie9260ed62013-07-25 21:19:01 +00002501 << A->getOption().getName() << Value;
David Blaikie9260ed62013-07-25 21:19:01 +00002502 }
2503 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002504 }
2505 if (CompressDebugSections) {
2506 if (llvm::zlib::isAvailable())
2507 CmdArgs.push_back("-compress-debug-sections");
2508 else
2509 D.Diag(diag::warn_debug_compression_unavailable);
2510 }
David Blaikie9260ed62013-07-25 21:19:01 +00002511}
2512
Alexey Samsonov99ee10d2014-05-22 21:13:30 +00002513// This adds the static libclang_rt.builtins-arch.a directly to the command line
Renato Golinc4b49242014-02-13 10:01:16 +00002514// FIXME: Make sure we can also emit shared objects if they're requested
2515// and available, check for possible errors, etc.
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00002516static void addClangRT(const ToolChain &TC, const ArgList &Args,
2517 ArgStringList &CmdArgs) {
Xinliang David Li69306c02015-10-22 06:15:31 +00002518 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins"));
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002519}
2520
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002521namespace {
2522enum OpenMPRuntimeKind {
2523 /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2524 /// without knowing what runtime to target.
2525 OMPRT_Unknown,
2526
2527 /// The LLVM OpenMP runtime. When completed and integrated, this will become
2528 /// the default for Clang.
2529 OMPRT_OMP,
2530
2531 /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2532 /// this runtime but can swallow the pragmas, and find and link against the
2533 /// runtime library itself.
2534 OMPRT_GOMP,
2535
Chandler Carruthc6625c62015-05-28 21:10:31 +00002536 /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002537 /// OpenMP runtime. We support this mode for users with existing dependencies
2538 /// on this runtime library name.
2539 OMPRT_IOMP5
2540};
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002541}
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002542
2543/// Compute the desired OpenMP runtime from the flag provided.
Chandler Carruthc6625c62015-05-28 21:10:31 +00002544static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2545 const ArgList &Args) {
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002546 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2547
2548 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2549 if (A)
2550 RuntimeName = A->getValue();
2551
2552 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002553 .Case("libomp", OMPRT_OMP)
2554 .Case("libgomp", OMPRT_GOMP)
2555 .Case("libiomp5", OMPRT_IOMP5)
2556 .Default(OMPRT_Unknown);
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002557
2558 if (RT == OMPRT_Unknown) {
2559 if (A)
2560 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002561 << A->getOption().getName() << A->getValue();
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00002562 else
2563 // FIXME: We could use a nicer diagnostic here.
2564 TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2565 }
2566
2567 return RT;
2568}
2569
Joerg Sonnenberger95a90132015-09-23 14:06:52 +00002570static void addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC,
2571 const ArgList &Args) {
2572 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
2573 options::OPT_fno_openmp, false))
2574 return;
2575
2576 switch (getOpenMPRuntime(TC, Args)) {
2577 case OMPRT_OMP:
2578 CmdArgs.push_back("-lomp");
2579 break;
2580 case OMPRT_GOMP:
2581 CmdArgs.push_back("-lgomp");
2582 break;
2583 case OMPRT_IOMP5:
2584 CmdArgs.push_back("-liomp5");
2585 break;
2586 case OMPRT_Unknown:
2587 // Already diagnosed.
2588 break;
2589 }
2590}
2591
Alexey Samsonov52550342014-09-15 19:58:40 +00002592static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2593 ArgStringList &CmdArgs, StringRef Sanitizer,
2594 bool IsShared) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002595 // Static runtimes must be forced into executable, so we wrap them in
Peter Collingbournef7ef3fd812013-10-20 21:29:13 +00002596 // whole-archive.
Xinliang David Li69306c02015-10-22 06:15:31 +00002597 if (!IsShared) CmdArgs.push_back("-whole-archive");
2598 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Sanitizer, IsShared));
2599 if (!IsShared) CmdArgs.push_back("-no-whole-archive");
Alexey Samsonovbfb0cd32013-02-27 11:14:55 +00002600}
2601
Alexey Samsonov52550342014-09-15 19:58:40 +00002602// Tries to use a file with the list of dynamic symbols that need to be exported
2603// from the runtime library. Returns true if the file was found.
2604static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2605 ArgStringList &CmdArgs,
2606 StringRef Sanitizer) {
Vasileios Kalintiris447e3572015-10-01 16:54:58 +00002607 SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer));
Saleem Abdulrasool68150942014-12-30 22:52:08 +00002608 if (llvm::sys::fs::exists(SanRT + ".syms")) {
2609 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
Alexey Samsonov52550342014-09-15 19:58:40 +00002610 return true;
2611 }
2612 return false;
2613}
2614
2615static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2616 ArgStringList &CmdArgs) {
2617 // Force linking against the system libraries sanitizers depends on
2618 // (see PR15823 why this is necessary).
2619 CmdArgs.push_back("--no-as-needed");
2620 CmdArgs.push_back("-lpthread");
2621 CmdArgs.push_back("-lrt");
2622 CmdArgs.push_back("-lm");
2623 // There's no libdl on FreeBSD.
2624 if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2625 CmdArgs.push_back("-ldl");
2626}
2627
2628static void
2629collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2630 SmallVectorImpl<StringRef> &SharedRuntimes,
2631 SmallVectorImpl<StringRef> &StaticRuntimes,
2632 SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2633 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2634 // Collect shared runtimes.
2635 if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2636 SharedRuntimes.push_back("asan");
Evgeniy Stepanov77866712012-04-25 08:59:22 +00002637 }
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002638
Alexey Samsonov52550342014-09-15 19:58:40 +00002639 // Collect static runtimes.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00002640 if (Args.hasArg(options::OPT_shared) || TC.getTriple().isAndroid()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002641 // Don't link static runtimes into DSOs or if compiling for Android.
Alexey Samsonovbdfa6c22014-04-01 13:31:10 +00002642 return;
Alexey Samsonov52550342014-09-15 19:58:40 +00002643 }
2644 if (SanArgs.needsAsanRt()) {
2645 if (SanArgs.needsSharedAsanRt()) {
2646 HelperStaticRuntimes.push_back("asan-preinit");
2647 } else {
2648 StaticRuntimes.push_back("asan");
2649 if (SanArgs.linkCXXRuntimes())
2650 StaticRuntimes.push_back("asan_cxx");
2651 }
2652 }
2653 if (SanArgs.needsDfsanRt())
2654 StaticRuntimes.push_back("dfsan");
2655 if (SanArgs.needsLsanRt())
2656 StaticRuntimes.push_back("lsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002657 if (SanArgs.needsMsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002658 StaticRuntimes.push_back("msan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002659 if (SanArgs.linkCXXRuntimes())
2660 StaticRuntimes.push_back("msan_cxx");
2661 }
2662 if (SanArgs.needsTsanRt()) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002663 StaticRuntimes.push_back("tsan");
Alexey Samsonov381845d2015-04-27 22:07:50 +00002664 if (SanArgs.linkCXXRuntimes())
2665 StaticRuntimes.push_back("tsan_cxx");
2666 }
Alexey Samsonov52550342014-09-15 19:58:40 +00002667 if (SanArgs.needsUbsanRt()) {
Alexey Samsonov31095462015-04-01 22:42:25 +00002668 StaticRuntimes.push_back("ubsan_standalone");
2669 if (SanArgs.linkCXXRuntimes())
2670 StaticRuntimes.push_back("ubsan_standalone_cxx");
Alexey Samsonovb01f9362014-05-12 18:39:51 +00002671 }
Peter Collingbournec4122c12015-06-15 21:08:13 +00002672 if (SanArgs.needsSafeStackRt())
2673 StaticRuntimes.push_back("safestack");
Kostya Serebryany7bca6c22011-11-30 01:39:16 +00002674}
2675
Alexey Samsonov52550342014-09-15 19:58:40 +00002676// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2677// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2678static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
Alexey Samsonovce8ab102014-02-25 12:43:43 +00002679 ArgStringList &CmdArgs) {
Alexey Samsonov52550342014-09-15 19:58:40 +00002680 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2681 HelperStaticRuntimes;
2682 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2683 HelperStaticRuntimes);
2684 for (auto RT : SharedRuntimes)
2685 addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2686 for (auto RT : HelperStaticRuntimes)
2687 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2688 bool AddExportDynamic = false;
2689 for (auto RT : StaticRuntimes) {
2690 addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2691 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2692 }
2693 // If there is a static runtime with no dynamic list, force all the symbols
2694 // to be dynamic to be sure we export sanitizer interface functions.
2695 if (AddExportDynamic)
2696 CmdArgs.push_back("-export-dynamic");
2697 return !StaticRuntimes.empty();
Peter Collingbournec3772752013-08-07 22:47:34 +00002698}
2699
Reid Kleckner86ea7702015-02-04 23:45:07 +00002700static bool areOptimizationsEnabled(const ArgList &Args) {
2701 // Find the last -O arg and see if it is non-zero.
2702 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2703 return !A->getOption().matches(options::OPT_O0);
2704 // Defaults to -O0.
2705 return false;
2706}
2707
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002708static bool shouldUseFramePointerForTarget(const ArgList &Args,
2709 const llvm::Triple &Triple) {
Dan Gohmanc2853072015-09-03 22:51:53 +00002710 switch (Triple.getArch()) {
2711 case llvm::Triple::xcore:
2712 case llvm::Triple::wasm32:
2713 case llvm::Triple::wasm64:
2714 // XCore never wants frame pointers, regardless of OS.
2715 // WebAssembly never wants frame pointers.
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002716 return false;
Dan Gohmanc2853072015-09-03 22:51:53 +00002717 default:
2718 break;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002719 }
Reid Kleckner86ea7702015-02-04 23:45:07 +00002720
2721 if (Triple.isOSLinux()) {
2722 switch (Triple.getArch()) {
2723 // Don't use a frame pointer on linux if optimizing for certain targets.
2724 case llvm::Triple::mips64:
2725 case llvm::Triple::mips64el:
2726 case llvm::Triple::mips:
2727 case llvm::Triple::mipsel:
2728 case llvm::Triple::systemz:
2729 case llvm::Triple::x86:
2730 case llvm::Triple::x86_64:
2731 return !areOptimizationsEnabled(Args);
2732 default:
2733 return true;
2734 }
2735 }
2736
2737 if (Triple.isOSWindows()) {
2738 switch (Triple.getArch()) {
2739 case llvm::Triple::x86:
2740 return !areOptimizationsEnabled(Args);
Saleem Abdulrasoola8180a22015-10-03 03:39:28 +00002741 case llvm::Triple::arm:
2742 case llvm::Triple::thumb:
2743 // Windows on ARM builds with FPO disabled to aid fast stack walking
2744 return true;
Reid Kleckner86ea7702015-02-04 23:45:07 +00002745 default:
2746 // All other supported Windows ISAs use xdata unwind information, so frame
2747 // pointers are not generally useful.
2748 return false;
2749 }
2750 }
2751
2752 return true;
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002753}
2754
Rafael Espindola224dd632011-12-14 21:02:23 +00002755static bool shouldUseFramePointer(const ArgList &Args,
2756 const llvm::Triple &Triple) {
2757 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2758 options::OPT_fomit_frame_pointer))
2759 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2760
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002761 return shouldUseFramePointerForTarget(Args, Triple);
Rafael Espindola224dd632011-12-14 21:02:23 +00002762}
2763
Eric Christopherb7d97e92013-04-03 01:58:53 +00002764static bool shouldUseLeafFramePointer(const ArgList &Args,
2765 const llvm::Triple &Triple) {
2766 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2767 options::OPT_momit_leaf_frame_pointer))
2768 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2769
Filipe Cabecinhasb1e6c2d2015-01-27 18:08:32 +00002770 if (Triple.isPS4CPU())
2771 return false;
2772
Benjamin Kramer34cb0432013-10-16 17:42:39 +00002773 return shouldUseFramePointerForTarget(Args, Triple);
Eric Christopherb7d97e92013-04-03 01:58:53 +00002774}
2775
Rafael Espindolac7367ff2013-08-10 01:40:10 +00002776/// Add a CC1 option to specify the debug compilation directory.
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002777static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
Benjamin Kramer698d7c82013-04-27 08:12:29 +00002778 SmallString<128> cwd;
2779 if (!llvm::sys::fs::current_path(cwd)) {
Chad Rosiera35d5a32013-04-26 20:49:50 +00002780 CmdArgs.push_back("-fdebug-compilation-dir");
2781 CmdArgs.push_back(Args.MakeArgString(cwd));
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00002782 }
2783}
2784
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002785static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
Eric Christopherd3804002013-02-22 20:12:52 +00002786 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2787 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2788 SmallString<128> T(FinalOutput->getValue());
2789 llvm::sys::path::replace_extension(T, "dwo");
2790 return Args.MakeArgString(T);
2791 } else {
2792 // Use the compilation dir.
Nico Webere8e53112014-05-11 01:04:02 +00002793 SmallString<128> T(
2794 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
Artem Belevichba558952015-05-06 18:20:23 +00002795 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
Eric Christopherd3804002013-02-22 20:12:52 +00002796 llvm::sys::path::replace_extension(F, "dwo");
2797 T += F;
2798 return Args.MakeArgString(F);
2799 }
2800}
2801
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002802static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
2803 const JobAction &JA, const ArgList &Args,
2804 const InputInfo &Output, const char *OutFile) {
Eric Christopher248357f2013-02-21 22:35:01 +00002805 ArgStringList ExtractArgs;
2806 ExtractArgs.push_back("--extract-dwo");
2807
2808 ArgStringList StripArgs;
2809 StripArgs.push_back("--strip-dwo");
2810
2811 // Grabbing the output of the earlier compile step.
2812 StripArgs.push_back(Output.getFilename());
2813 ExtractArgs.push_back(Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002814 ExtractArgs.push_back(OutFile);
2815
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002816 const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
Justin Bognerd3371d82015-07-17 03:35:54 +00002817 InputInfo II(Output.getFilename(), types::TY_Object, Output.getFilename());
Eric Christopher248357f2013-02-21 22:35:01 +00002818
2819 // First extract the dwo sections.
Justin Bognerd3371d82015-07-17 03:35:54 +00002820 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00002821
2822 // Then remove them from the original .o file.
Justin Bognerd3371d82015-07-17 03:35:54 +00002823 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
Eric Christopher248357f2013-02-21 22:35:01 +00002824}
2825
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002826/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002827/// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2828static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002829 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
Rafael Espindolaad70d962013-08-27 16:58:15 +00002830 if (A->getOption().matches(options::OPT_O4) ||
2831 A->getOption().matches(options::OPT_Ofast))
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002832 return true;
2833
2834 if (A->getOption().matches(options::OPT_O0))
2835 return false;
2836
2837 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2838
Rafael Espindola91780de2013-08-26 14:05:41 +00002839 // Vectorize -Os.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002840 StringRef S(A->getValue());
Rafael Espindola91780de2013-08-26 14:05:41 +00002841 if (S == "s")
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002842 return true;
2843
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002844 // Don't vectorize -Oz, unless it's the slp vectorizer.
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002845 if (S == "z")
Chad Rosier3ba81bd2014-05-02 18:41:57 +00002846 return isSlpVec;
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00002847
2848 unsigned OptLevel = 0;
2849 if (S.getAsInteger(10, OptLevel))
2850 return false;
2851
2852 return OptLevel > 1;
2853 }
2854
2855 return false;
2856}
2857
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002858/// Add -x lang to \p CmdArgs for \p Input.
2859static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2860 ArgStringList &CmdArgs) {
2861 // When using -verify-pch, we don't want to provide the type
2862 // 'precompiled-header' if it was inferred from the file extension
2863 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2864 return;
2865
2866 CmdArgs.push_back("-x");
2867 if (Args.hasArg(options::OPT_rewrite_objc))
2868 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2869 else
2870 CmdArgs.push_back(types::getTypeName(Input.getType()));
2871}
2872
David Majnemerc371ff02015-03-22 08:39:22 +00002873static VersionTuple getMSCompatibilityVersion(unsigned Version) {
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002874 if (Version < 100)
David Majnemerc371ff02015-03-22 08:39:22 +00002875 return VersionTuple(Version);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002876
2877 if (Version < 10000)
David Majnemerc371ff02015-03-22 08:39:22 +00002878 return VersionTuple(Version / 100, Version % 100);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002879
2880 unsigned Build = 0, Factor = 1;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002881 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002882 Build = Build + (Version % 10) * Factor;
David Majnemerc371ff02015-03-22 08:39:22 +00002883 return VersionTuple(Version / 100, Version % 100, Build);
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +00002884}
2885
Rafael Espindola577637a2015-01-03 00:06:04 +00002886// Claim options we don't want to warn if they are unused. We do this for
Rafael Espindola7a45e872015-01-05 13:44:59 +00002887// options that build systems might add but are unused when assembling or only
2888// running the preprocessor for example.
Rafael Espindola577637a2015-01-03 00:06:04 +00002889static void claimNoWarnArgs(const ArgList &Args) {
2890 // Don't warn about unused -f(no-)?lto. This can happen when we're
Rafael Espindola7a45e872015-01-05 13:44:59 +00002891 // preprocessing, precompiling or assembling.
Teresa Johnson945bc502015-10-15 20:35:53 +00002892 Args.ClaimAllArgs(options::OPT_flto_EQ);
Rafael Espindola577637a2015-01-03 00:06:04 +00002893 Args.ClaimAllArgs(options::OPT_flto);
2894 Args.ClaimAllArgs(options::OPT_fno_lto);
2895}
2896
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002897static void appendUserToPath(SmallVectorImpl<char> &Result) {
2898#ifdef LLVM_ON_UNIX
2899 const char *Username = getenv("LOGNAME");
2900#else
2901 const char *Username = getenv("USERNAME");
2902#endif
2903 if (Username) {
2904 // Validate that LoginName can be used in a path, and get its length.
2905 size_t Len = 0;
2906 for (const char *P = Username; *P; ++P, ++Len) {
Ben Langmuire056ec32015-02-04 18:34:23 +00002907 if (!isAlphanumeric(*P) && *P != '_') {
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002908 Username = nullptr;
2909 break;
2910 }
2911 }
2912
2913 if (Username && Len > 0) {
2914 Result.append(Username, Username + Len);
2915 return;
2916 }
2917 }
2918
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002919// Fallback to user id.
Ben Langmuir3b7b5402015-02-03 19:28:37 +00002920#ifdef LLVM_ON_UNIX
2921 std::string UID = llvm::utostr(getuid());
2922#else
2923 // FIXME: Windows seems to have an 'SID' that might work.
2924 std::string UID = "9999";
2925#endif
2926 Result.append(UID.begin(), UID.end());
2927}
2928
David Majnemere11d3732015-06-08 00:22:46 +00002929VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2930 const llvm::Triple &Triple,
2931 const llvm::opt::ArgList &Args,
2932 bool IsWindowsMSVC) {
2933 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2934 IsWindowsMSVC) ||
2935 Args.hasArg(options::OPT_fmsc_version) ||
2936 Args.hasArg(options::OPT_fms_compatibility_version)) {
2937 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2938 const Arg *MSCompatibilityVersion =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002939 Args.getLastArg(options::OPT_fms_compatibility_version);
David Majnemere11d3732015-06-08 00:22:46 +00002940
2941 if (MSCVersion && MSCompatibilityVersion) {
2942 if (D)
2943 D->Diag(diag::err_drv_argument_not_allowed_with)
2944 << MSCVersion->getAsString(Args)
2945 << MSCompatibilityVersion->getAsString(Args);
2946 return VersionTuple();
2947 }
2948
2949 if (MSCompatibilityVersion) {
2950 VersionTuple MSVT;
2951 if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2952 D->Diag(diag::err_drv_invalid_value)
2953 << MSCompatibilityVersion->getAsString(Args)
2954 << MSCompatibilityVersion->getValue();
2955 return MSVT;
2956 }
2957
2958 if (MSCVersion) {
2959 unsigned Version = 0;
2960 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2961 D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2962 << MSCVersion->getValue();
2963 return getMSCompatibilityVersion(Version);
2964 }
2965
2966 unsigned Major, Minor, Micro;
2967 Triple.getEnvironmentVersion(Major, Minor, Micro);
2968 if (Major || Minor || Micro)
2969 return VersionTuple(Major, Minor, Micro);
2970
2971 return VersionTuple(18);
2972 }
2973 return VersionTuple();
2974}
2975
Diego Novilloa0545962015-07-10 18:00:07 +00002976static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
2977 const InputInfo &Output, const ArgList &Args,
2978 ArgStringList &CmdArgs) {
2979 auto *ProfileGenerateArg = Args.getLastArg(
2980 options::OPT_fprofile_instr_generate,
2981 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
Diego Novillo758f3f52015-08-05 21:49:51 +00002982 options::OPT_fprofile_generate_EQ,
2983 options::OPT_fno_profile_instr_generate);
2984 if (ProfileGenerateArg &&
2985 ProfileGenerateArg->getOption().matches(
2986 options::OPT_fno_profile_instr_generate))
2987 ProfileGenerateArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00002988
2989 auto *ProfileUseArg = Args.getLastArg(
2990 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
Diego Novillo758f3f52015-08-05 21:49:51 +00002991 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
2992 options::OPT_fno_profile_instr_use);
2993 if (ProfileUseArg &&
2994 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
2995 ProfileUseArg = nullptr;
Diego Novilloa0545962015-07-10 18:00:07 +00002996
2997 if (ProfileGenerateArg && ProfileUseArg)
2998 D.Diag(diag::err_drv_argument_not_allowed_with)
Renato Golin7c542b42015-07-27 23:44:45 +00002999 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
Diego Novilloa0545962015-07-10 18:00:07 +00003000
Diego Novillo758f3f52015-08-05 21:49:51 +00003001 if (ProfileGenerateArg) {
3002 if (ProfileGenerateArg->getOption().matches(
3003 options::OPT_fprofile_instr_generate_EQ))
3004 ProfileGenerateArg->render(Args, CmdArgs);
3005 else if (ProfileGenerateArg->getOption().matches(
3006 options::OPT_fprofile_generate_EQ)) {
3007 SmallString<128> Path(ProfileGenerateArg->getValue());
3008 llvm::sys::path::append(Path, "default.profraw");
3009 CmdArgs.push_back(
3010 Args.MakeArgString(Twine("-fprofile-instr-generate=") + Path));
3011 } else
3012 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3013 }
Diego Novilloa0545962015-07-10 18:00:07 +00003014
Diego Novillo758f3f52015-08-05 21:49:51 +00003015 if (ProfileUseArg) {
3016 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
3017 ProfileUseArg->render(Args, CmdArgs);
3018 else if ((ProfileUseArg->getOption().matches(
3019 options::OPT_fprofile_use_EQ) ||
3020 ProfileUseArg->getOption().matches(
3021 options::OPT_fprofile_instr_use))) {
3022 SmallString<128> Path(
3023 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
3024 if (Path.empty() || llvm::sys::fs::is_directory(Path))
3025 llvm::sys::path::append(Path, "default.profdata");
3026 CmdArgs.push_back(
3027 Args.MakeArgString(Twine("-fprofile-instr-use=") + Path));
3028 }
Diego Novilloa0545962015-07-10 18:00:07 +00003029 }
3030
3031 if (Args.hasArg(options::OPT_ftest_coverage) ||
3032 Args.hasArg(options::OPT_coverage))
3033 CmdArgs.push_back("-femit-coverage-notes");
3034 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3035 false) ||
3036 Args.hasArg(options::OPT_coverage))
3037 CmdArgs.push_back("-femit-coverage-data");
3038
Diego Novilloc4b94da2015-08-05 23:27:40 +00003039 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3040 options::OPT_fno_coverage_mapping, false) &&
3041 !ProfileGenerateArg)
Diego Novilloa0545962015-07-10 18:00:07 +00003042 D.Diag(diag::err_drv_argument_only_allowed_with)
3043 << "-fcoverage-mapping"
3044 << "-fprofile-instr-generate";
3045
Diego Novilloc4b94da2015-08-05 23:27:40 +00003046 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3047 options::OPT_fno_coverage_mapping, false))
Diego Novilloa0545962015-07-10 18:00:07 +00003048 CmdArgs.push_back("-fcoverage-mapping");
3049
3050 if (C.getArgs().hasArg(options::OPT_c) ||
3051 C.getArgs().hasArg(options::OPT_S)) {
3052 if (Output.isFilename()) {
3053 CmdArgs.push_back("-coverage-file");
3054 SmallString<128> CoverageFilename;
3055 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
3056 CoverageFilename = FinalOutput->getValue();
3057 } else {
3058 CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
3059 }
3060 if (llvm::sys::path::is_relative(CoverageFilename)) {
3061 SmallString<128> Pwd;
3062 if (!llvm::sys::fs::current_path(Pwd)) {
3063 llvm::sys::path::append(Pwd, CoverageFilename);
3064 CoverageFilename.swap(Pwd);
3065 }
3066 }
3067 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
3068 }
3069 }
3070}
3071
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003072/// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
3073/// smooshes them together with platform defaults, to decide whether
3074/// this compile should be using PIC mode or not. Returns a tuple of
3075/// (RelocationModel, PICLevel, IsPIE).
3076static std::tuple<llvm::Reloc::Model, unsigned, bool>
3077ParsePICArgs(const ToolChain &ToolChain, const llvm::Triple &Triple,
3078 const ArgList &Args) {
3079 // FIXME: why does this code...and so much everywhere else, use both
3080 // ToolChain.getTriple() and Triple?
3081 bool PIE = ToolChain.isPIEDefault();
3082 bool PIC = PIE || ToolChain.isPICDefault();
3083 bool IsPICLevelTwo = PIC;
3084
3085 bool KernelOrKext =
3086 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3087
3088 // Android-specific defaults for PIC/PIE
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00003089 if (ToolChain.getTriple().isAndroid()) {
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003090 switch (ToolChain.getArch()) {
3091 case llvm::Triple::arm:
3092 case llvm::Triple::armeb:
3093 case llvm::Triple::thumb:
3094 case llvm::Triple::thumbeb:
3095 case llvm::Triple::aarch64:
3096 case llvm::Triple::mips:
3097 case llvm::Triple::mipsel:
3098 case llvm::Triple::mips64:
3099 case llvm::Triple::mips64el:
3100 PIC = true; // "-fpic"
3101 break;
3102
3103 case llvm::Triple::x86:
3104 case llvm::Triple::x86_64:
3105 PIC = true; // "-fPIC"
3106 IsPICLevelTwo = true;
3107 break;
3108
3109 default:
3110 break;
3111 }
3112 }
3113
3114 // OpenBSD-specific defaults for PIE
3115 if (ToolChain.getTriple().getOS() == llvm::Triple::OpenBSD) {
3116 switch (ToolChain.getArch()) {
3117 case llvm::Triple::mips64:
3118 case llvm::Triple::mips64el:
3119 case llvm::Triple::sparcel:
3120 case llvm::Triple::x86:
3121 case llvm::Triple::x86_64:
3122 IsPICLevelTwo = false; // "-fpie"
3123 break;
3124
3125 case llvm::Triple::ppc:
3126 case llvm::Triple::sparc:
3127 case llvm::Triple::sparcv9:
3128 IsPICLevelTwo = true; // "-fPIE"
3129 break;
3130
3131 default:
3132 break;
3133 }
3134 }
3135
3136 // The last argument relating to either PIC or PIE wins, and no
3137 // other argument is used. If the last argument is any flavor of the
3138 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
3139 // option implicitly enables PIC at the same level.
3140 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3141 options::OPT_fpic, options::OPT_fno_pic,
3142 options::OPT_fPIE, options::OPT_fno_PIE,
3143 options::OPT_fpie, options::OPT_fno_pie);
3144 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3145 // is forced, then neither PIC nor PIE flags will have no effect.
3146 if (!ToolChain.isPICDefaultForced()) {
3147 if (LastPICArg) {
3148 Option O = LastPICArg->getOption();
3149 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3150 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3151 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3152 PIC =
3153 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3154 IsPICLevelTwo =
3155 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3156 } else {
3157 PIE = PIC = false;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003158 if (Triple.isPS4CPU()) {
3159 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
3160 StringRef Model = ModelArg ? ModelArg->getValue() : "";
3161 if (Model != "kernel") {
3162 PIC = true;
3163 ToolChain.getDriver().Diag(diag::warn_drv_ps4_force_pic)
3164 << LastPICArg->getSpelling();
3165 }
3166 }
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003167 }
3168 }
3169 }
3170
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003171 // Introduce a Darwin and PS4-specific hack. If the default is PIC, but the
3172 // PIC level would've been set to level 1, force it back to level 2 PIC
3173 // instead.
3174 if (PIC && (ToolChain.getTriple().isOSDarwin() || Triple.isPS4CPU()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003175 IsPICLevelTwo |= ToolChain.isPICDefault();
3176
James Y Knightc4015d32015-08-21 04:14:55 +00003177 // This kernel flags are a trump-card: they will disable PIC/PIE
3178 // generation, independent of the argument order.
Tim Northover6f3ff222015-10-30 16:30:27 +00003179 if (KernelOrKext && ((!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
3180 !Triple.isWatchOS()))
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003181 PIC = PIE = false;
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003182
3183 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3184 // This is a very special mode. It trumps the other modes, almost no one
3185 // uses it, and it isn't even valid on any OS but Darwin.
3186 if (!ToolChain.getTriple().isOSDarwin())
3187 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
3188 << A->getSpelling() << ToolChain.getTriple().str();
3189
3190 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3191
3192 // Only a forced PIC mode can cause the actual compile to have PIC defines
3193 // etc., no flags are sufficient. This behavior was selected to closely
3194 // match that of llvm-gcc and Apple GCC before that.
3195 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
3196
3197 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2 : 0, false);
3198 }
3199
3200 if (PIC)
3201 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2 : 1, PIE);
3202
3203 return std::make_tuple(llvm::Reloc::Static, 0, false);
3204}
3205
3206static const char *RelocationModelName(llvm::Reloc::Model Model) {
3207 switch (Model) {
3208 case llvm::Reloc::Default:
3209 return nullptr;
3210 case llvm::Reloc::Static:
3211 return "static";
3212 case llvm::Reloc::PIC_:
3213 return "pic";
3214 case llvm::Reloc::DynamicNoPIC:
3215 return "dynamic-no-pic";
3216 }
Aaron Ballman2ec49282015-08-20 13:31:16 +00003217 llvm_unreachable("Unknown Reloc::Model kind");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003218}
3219
3220static void AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
3221 ArgStringList &CmdArgs) {
3222 llvm::Reloc::Model RelocationModel;
3223 unsigned PICLevel;
3224 bool IsPIE;
3225 std::tie(RelocationModel, PICLevel, IsPIE) =
3226 ParsePICArgs(ToolChain, ToolChain.getTriple(), Args);
3227
3228 if (RelocationModel != llvm::Reloc::Static)
3229 CmdArgs.push_back("-KPIC");
3230}
3231
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003232void Clang::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003233 const InputInfo &Output, const InputInfoList &Inputs,
3234 const ArgList &Args, const char *LinkingOutput) const {
James Y Knight2db38f32015-08-15 03:45:25 +00003235 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3236 const llvm::Triple Triple(TripleStr);
3237
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003238 bool KernelOrKext =
3239 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
Daniel Dunbar083edf72009-12-21 18:54:17 +00003240 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00003241 ArgStringList CmdArgs;
3242
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003243 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
Nico Webere8e53112014-05-11 01:04:02 +00003244 bool IsWindowsCygnus =
3245 getToolChain().getTriple().isWindowsCygwinEnvironment();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003246 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003247 bool IsPS4CPU = getToolChain().getTriple().isPS4CPU();
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003248
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003249 // Check number of inputs for sanity. We need at least one input.
3250 assert(Inputs.size() >= 1 && "Must have at least one input.");
Artem Belevichba558952015-05-06 18:20:23 +00003251 const InputInfo &Input = Inputs[0];
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003252 // CUDA compilation may have multiple inputs (source file + results of
3253 // device-side compilations). All other jobs are expected to have exactly one
3254 // input.
3255 bool IsCuda = types::isCuda(Input.getType());
3256 assert((IsCuda || Inputs.size() == 1) && "Unable to handle multiple inputs.");
Daniel Dunbare521a892009-03-31 20:53:55 +00003257
Daniel Dunbar6c536aa2009-12-11 23:00:49 +00003258 // Invoke ourselves in -cc1 mode.
3259 //
3260 // FIXME: Implement custom jobs for internal actions.
3261 CmdArgs.push_back("-cc1");
3262
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003263 // Add the "effective" target triple.
Daniel Dunbard640be22009-03-31 17:35:15 +00003264 CmdArgs.push_back("-triple");
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003265 CmdArgs.push_back(Args.MakeArgString(TripleStr));
Daniel Dunbarfb58b0a2009-09-10 06:49:20 +00003266
James Y Knight2db38f32015-08-15 03:45:25 +00003267 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3268 Triple.getArch() == llvm::Triple::thumb)) {
3269 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003270 unsigned Version;
James Y Knight2db38f32015-08-15 03:45:25 +00003271 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003272 if (Version < 7)
James Y Knight2db38f32015-08-15 03:45:25 +00003273 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
Nico Webere8e53112014-05-11 01:04:02 +00003274 << TripleStr;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003275 }
3276
Tim Northover336f1892014-03-29 13:16:12 +00003277 // Push all default warning arguments that are specific to
3278 // the given target. These come before user provided warning options
3279 // are provided.
3280 getToolChain().addClangWarningOptions(CmdArgs);
3281
Daniel Dunbar624c21b2009-10-30 18:12:20 +00003282 // Select the appropriate action.
John McCall5fb5df92012-06-20 06:18:46 +00003283 RewriteKind rewriteKind = RK_None;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003284
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003285 if (isa<AnalyzeJobAction>(JA)) {
3286 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
3287 CmdArgs.push_back("-analyze");
Ted Kremenekf7639e12012-03-06 20:06:33 +00003288 } else if (isa<MigrateJobAction>(JA)) {
3289 CmdArgs.push_back("-migrate");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003290 } else if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003291 if (Output.getType() == types::TY_Dependencies)
3292 CmdArgs.push_back("-Eonly");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003293 else {
Daniel Dunbard67a3222009-03-30 06:36:42 +00003294 CmdArgs.push_back("-E");
Fariborz Jahaniane0a75d62013-03-18 19:41:18 +00003295 if (Args.hasArg(options::OPT_rewrite_objc) &&
3296 !Args.hasArg(options::OPT_g_Group))
3297 CmdArgs.push_back("-P");
3298 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00003299 } else if (isa<AssembleJobAction>(JA)) {
3300 CmdArgs.push_back("-emit-obj");
Daniel Dunbar06e2cc32010-05-27 06:18:05 +00003301
David Blaikie9260ed62013-07-25 21:19:01 +00003302 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
Daniel Dunbar7c874332010-11-19 16:23:35 +00003303
3304 // Also ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003305 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003306 } else if (isa<PrecompileJobAction>(JA)) {
Argyrios Kyrtzidis90bdfbb2010-08-11 23:27:58 +00003307 // Use PCH if the user requested it.
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003308 bool UsePCH = D.CCCUsePCH;
Daniel Dunbarcbc34b72009-10-15 20:02:44 +00003309
Aaron Ballman1f10cc52012-07-31 01:21:00 +00003310 if (JA.getType() == types::TY_Nothing)
3311 CmdArgs.push_back("-fsyntax-only");
3312 else if (UsePCH)
Douglas Gregor111af7d2009-04-18 00:34:01 +00003313 CmdArgs.push_back("-emit-pch");
3314 else
3315 CmdArgs.push_back("-emit-pth");
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003316 } else if (isa<VerifyPCHJobAction>(JA)) {
3317 CmdArgs.push_back("-verify-pch");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003318 } else {
Bob Wilson23a55f12014-12-21 07:00:00 +00003319 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3320 "Invalid action for clang tool.");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003321 if (JA.getType() == types::TY_Nothing) {
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00003322 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003323 } else if (JA.getType() == types::TY_LLVM_IR ||
3324 JA.getType() == types::TY_LTO_IR) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003325 CmdArgs.push_back("-emit-llvm");
Daniel Dunbar24e52992010-06-07 23:28:45 +00003326 } else if (JA.getType() == types::TY_LLVM_BC ||
3327 JA.getType() == types::TY_LTO_BC) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003328 CmdArgs.push_back("-emit-llvm-bc");
3329 } else if (JA.getType() == types::TY_PP_Asm) {
Daniel Dunbard112f102009-09-17 00:47:53 +00003330 CmdArgs.push_back("-S");
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00003331 } else if (JA.getType() == types::TY_AST) {
3332 CmdArgs.push_back("-emit-pch");
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00003333 } else if (JA.getType() == types::TY_ModuleFile) {
3334 CmdArgs.push_back("-module-file-info");
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003335 } else if (JA.getType() == types::TY_RewrittenObjC) {
3336 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003337 rewriteKind = RK_NonFragile;
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00003338 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
3339 CmdArgs.push_back("-rewrite-objc");
John McCall5fb5df92012-06-20 06:18:46 +00003340 rewriteKind = RK_Fragile;
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00003341 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003342 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003343 }
Duncan P. N. Exon Smithd863f6f2015-04-14 18:30:13 +00003344
3345 // Preserve use-list order by default when emitting bitcode, so that
3346 // loading the bitcode up in 'opt' or 'llc' and running passes gives the
3347 // same result as running passes here. For LTO, we don't need to preserve
3348 // the use-list order, since serialization to bitcode is part of the flow.
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +00003349 if (JA.getType() == types::TY_LLVM_BC)
3350 CmdArgs.push_back("-emit-llvm-uselists");
Teresa Johnson945bc502015-10-15 20:35:53 +00003351
3352 if (D.isUsingLTO())
3353 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
Daniel Dunbara3246a02009-03-18 08:07:30 +00003354 }
3355
Justin Bognera88f0122014-06-20 22:59:50 +00003356 // We normally speed up the clang process a bit by skipping destructors at
3357 // exit, but when we're generating diagnostics we can rely on some of the
3358 // cleanup.
3359 if (!C.isForDiagnostics())
3360 CmdArgs.push_back("-disable-free");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003361
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003362// Disable the verification pass in -asserts builds.
John McCallbb79b5f2010-02-13 03:50:24 +00003363#ifdef NDEBUG
3364 CmdArgs.push_back("-disable-llvm-verifier");
3365#endif
3366
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003367 // Set the main file name, so that debug info works even with
3368 // -save-temps.
3369 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00003370 CmdArgs.push_back(getBaseInputName(Args, Input));
Daniel Dunbar3b358a32009-04-08 05:11:16 +00003371
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003372 // Some flags which affect the language (via preprocessor
Bob Wilsondecc03e2012-11-23 06:14:39 +00003373 // defines).
Daniel Dunbar17ddaa62009-04-08 18:03:55 +00003374 if (Args.hasArg(options::OPT_static))
3375 CmdArgs.push_back("-static-define");
3376
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003377 if (isa<AnalyzeJobAction>(JA)) {
Ted Kremenek05e6f5b2009-09-25 05:55:59 +00003378 // Enable region store model by default.
3379 CmdArgs.push_back("-analyzer-store=region");
3380
Ted Kremenek7bea9a12009-12-07 22:26:14 +00003381 // Treat blocks as analysis entry points.
3382 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
3383
Ted Kremenek49c79792011-03-24 00:28:47 +00003384 CmdArgs.push_back("-analyzer-eagerly-assume");
3385
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003386 // Add default argument set.
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003387 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003388 CmdArgs.push_back("-analyzer-checker=core");
Ted Kremenek49c79792011-03-24 00:28:47 +00003389
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003390 if (!IsWindowsMSVC)
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003391 CmdArgs.push_back("-analyzer-checker=unix");
Ted Kremenek49c79792011-03-24 00:28:47 +00003392
Argyrios Kyrtzidisa6d04d52011-02-15 07:42:33 +00003393 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
Ted Kremenek49c79792011-03-24 00:28:47 +00003394 CmdArgs.push_back("-analyzer-checker=osx");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003395
Ted Kremenekb9ff6b22012-01-20 06:00:17 +00003396 CmdArgs.push_back("-analyzer-checker=deadcode");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003397
Artem Belevichba558952015-05-06 18:20:23 +00003398 if (types::isCXX(Input.getType()))
Jordan Rose10ad0812013-04-05 17:55:07 +00003399 CmdArgs.push_back("-analyzer-checker=cplusplus");
3400
Nico Webere8e53112014-05-11 01:04:02 +00003401 // Enable the following experimental checkers for testing.
3402 CmdArgs.push_back(
3403 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
Ted Kremenek37e96522012-01-26 02:27:38 +00003404 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
3405 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003406 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
Ted Kremenek37e96522012-01-26 02:27:38 +00003407 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
3408 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
Gabor Horvathe3085992015-09-14 20:34:06 +00003409
3410 // Default nullability checks.
3411 CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull");
3412 CmdArgs.push_back(
3413 "-analyzer-checker=nullability.NullReturnedFromNonnull");
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003414 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00003415
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003416 // Set the output format. The default is plist, for (lame) historical
3417 // reasons.
3418 CmdArgs.push_back("-analyzer-output");
3419 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
Richard Smithbd55daf2012-11-01 04:30:05 +00003420 CmdArgs.push_back(A->getValue());
Daniel Dunbar58f345ce2009-05-22 00:38:15 +00003421 else
3422 CmdArgs.push_back("plist");
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003423
Ted Kremenekfe449a22010-03-22 22:32:05 +00003424 // Disable the presentation of standard compiler warnings when
3425 // using --analyze. We only want to show static analyzer diagnostics
3426 // or frontend errors.
3427 CmdArgs.push_back("-w");
3428
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003429 // Add -Xanalyzer arguments when running as analyzer.
3430 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
Mike Stump11289f42009-09-09 15:08:12 +00003431 }
3432
Daniel Dunbar4eadb602009-09-10 01:21:12 +00003433 CheckCodeGenerationOptions(D, Args);
3434
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003435 llvm::Reloc::Model RelocationModel;
3436 unsigned PICLevel;
3437 bool IsPIE;
3438 std::tie(RelocationModel, PICLevel, IsPIE) =
3439 ParsePICArgs(getToolChain(), Triple, Args);
Peter Collingbourne54d770c2013-04-09 04:35:11 +00003440
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003441 const char *RMName = RelocationModelName(RelocationModel);
3442 if (RMName) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003443 CmdArgs.push_back("-mrelocation-model");
James Y Knight5bdf7ab2015-08-19 15:12:02 +00003444 CmdArgs.push_back(RMName);
3445 }
3446 if (PICLevel > 0) {
3447 CmdArgs.push_back("-pic-level");
3448 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
3449 if (IsPIE) {
3450 CmdArgs.push_back("-pie-level");
3451 CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
Chandler Carruth76a943b2012-11-19 03:52:03 +00003452 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003453 }
Chandler Carruthc0c04552012-04-08 16:40:35 +00003454
Renato Golin4854d802015-11-09 12:40:41 +00003455 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3456 CmdArgs.push_back("-meabi");
3457 CmdArgs.push_back(A->getValue());
3458 }
3459
Jonathan Roelofsb140a102014-10-03 21:57:44 +00003460 CmdArgs.push_back("-mthread-model");
3461 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3462 CmdArgs.push_back(A->getValue());
3463 else
3464 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3465
Michael Zolotukhinc888dd02015-03-17 20:03:11 +00003466 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3467
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00003468 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3469 options::OPT_fno_merge_all_constants))
Chris Lattner9242b332011-04-08 18:06:54 +00003470 CmdArgs.push_back("-fno-merge-all-constants");
Daniel Dunbar306945d2009-09-16 06:17:29 +00003471
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003472 // LLVM Code Generator Options.
3473
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003474 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3475 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
Sean Silva14facf32015-06-09 01:57:17 +00003476 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3477 options::OPT_frewrite_map_file_EQ)) {
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003478 CmdArgs.push_back("-frewrite-map-file");
Sean Silva14facf32015-06-09 01:57:17 +00003479 CmdArgs.push_back(A->getValue());
3480 A->claim();
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +00003481 }
3482 }
3483
Alp Tokerfb8d02b2014-06-05 22:10:59 +00003484 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3485 StringRef v = A->getValue();
3486 CmdArgs.push_back("-mllvm");
3487 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3488 A->claim();
3489 }
3490
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003491 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3492 CmdArgs.push_back("-mregparm");
Richard Smithbd55daf2012-11-01 04:30:05 +00003493 CmdArgs.push_back(A->getValue());
Daniel Dunbar0bb03312011-02-09 17:54:19 +00003494 }
3495
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00003496 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3497 options::OPT_freg_struct_return)) {
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003498 if (getToolChain().getArch() != llvm::Triple::x86) {
John McCall1fe2a8c2013-06-18 02:46:29 +00003499 D.Diag(diag::err_drv_unsupported_opt_for_target)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003500 << A->getSpelling() << getToolChain().getTriple().str();
John McCall1fe2a8c2013-06-18 02:46:29 +00003501 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3502 CmdArgs.push_back("-fpcc-struct-return");
3503 } else {
3504 assert(A->getOption().matches(options::OPT_freg_struct_return));
3505 CmdArgs.push_back("-freg-struct-return");
3506 }
3507 }
3508
Roman Divacky65b88cd2011-03-01 17:40:53 +00003509 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
3510 CmdArgs.push_back("-mrtd");
3511
Rafael Espindola224dd632011-12-14 21:02:23 +00003512 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003513 CmdArgs.push_back("-mdisable-fp-elim");
3514 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3515 options::OPT_fno_zero_initialized_in_bss))
3516 CmdArgs.push_back("-mno-zero-initialized-in-bss");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003517
3518 bool OFastEnabled = isOptimizationLevelFast(Args);
3519 // If -Ofast is the optimization level, then -fstrict-aliasing should be
3520 // enabled. This alias option is being used to simplify the hasFlag logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003521 OptSpecifier StrictAliasingAliasOption =
3522 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003523 // We turn strict aliasing off by default if we're in CL mode, since MSVC
3524 // doesn't do any TBAA.
3525 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003526 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
Reid Kleckner2a24e3a2014-04-09 20:07:39 +00003527 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
Dan Gohman10169b92010-10-14 22:36:56 +00003528 CmdArgs.push_back("-relaxed-aliasing");
Manman Renf5d9d342013-10-11 20:48:38 +00003529 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3530 options::OPT_fno_struct_path_tbaa))
3531 CmdArgs.push_back("-no-struct-path-tbaa");
Chandler Carruth8b4140d2012-03-27 23:58:37 +00003532 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3533 false))
3534 CmdArgs.push_back("-fstrict-enums");
Piotr Padlewski338c9d02015-09-15 21:46:47 +00003535 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3536 options::OPT_fno_strict_vtable_pointers,
3537 false))
3538 CmdArgs.push_back("-fstrict-vtable-pointers");
Nick Lewycky1c8c4362012-01-23 08:29:12 +00003539 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3540 options::OPT_fno_optimize_sibling_calls))
3541 CmdArgs.push_back("-mdisable-tail-calls");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003542
Eric Christopher006208c2013-04-04 06:29:47 +00003543 // Handle segmented stacks.
3544 if (Args.hasArg(options::OPT_fsplit_stack))
3545 CmdArgs.push_back("-split-stacks");
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003546
3547 // If -Ofast is the optimization level, then -ffast-math should be enabled.
3548 // This alias option is being used to simplify the getLastArg logic.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003549 OptSpecifier FastMathAliasOption =
3550 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
3551
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003552 // Handle various floating point optimization flags, mapping them to the
3553 // appropriate LLVM code generation flags. The pattern for all of these is to
3554 // default off the codegen optimizations, and if any flag enables them and no
3555 // flag disables them after the flag enabling them, enable the codegen
3556 // optimization. This is complicated by several "umbrella" flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003557 if (Arg *A = Args.getLastArg(
3558 options::OPT_ffast_math, FastMathAliasOption,
3559 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3560 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
3561 options::OPT_fno_honor_infinities))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003562 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3563 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003564 A->getOption().getID() != options::OPT_fhonor_infinities)
3565 CmdArgs.push_back("-menable-no-infs");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003566 if (Arg *A = Args.getLastArg(
3567 options::OPT_ffast_math, FastMathAliasOption,
3568 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3569 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
3570 options::OPT_fno_honor_nans))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003571 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3572 A->getOption().getID() != options::OPT_fno_finite_math_only &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003573 A->getOption().getID() != options::OPT_fhonor_nans)
3574 CmdArgs.push_back("-menable-no-nans");
3575
Benjamin Kramerc242ef22012-05-02 14:55:48 +00003576 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3577 bool MathErrno = getToolChain().IsMathErrnoDefault();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003578 if (Arg *A =
3579 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3580 options::OPT_fno_fast_math, options::OPT_fmath_errno,
3581 options::OPT_fno_math_errno)) {
Chandler Carruth0d4b9e62013-05-18 20:47:36 +00003582 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3583 // However, turning *off* -ffast_math merely restores the toolchain default
3584 // (which may be false).
3585 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3586 A->getOption().getID() == options::OPT_ffast_math ||
3587 A->getOption().getID() == options::OPT_Ofast)
3588 MathErrno = false;
3589 else if (A->getOption().getID() == options::OPT_fmath_errno)
3590 MathErrno = true;
3591 }
Chandler Carruth3634c662012-04-26 02:10:51 +00003592 if (MathErrno)
3593 CmdArgs.push_back("-fmath-errno");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003594
3595 // There are several flags which require disabling very specific
3596 // optimizations. Any of these being disabled forces us to turn off the
3597 // entire set of LLVM optimizations, so collect them through all the flag
3598 // madness.
3599 bool AssociativeMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003600 if (Arg *A = Args.getLastArg(
3601 options::OPT_ffast_math, FastMathAliasOption,
3602 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3603 options::OPT_fno_unsafe_math_optimizations,
3604 options::OPT_fassociative_math, options::OPT_fno_associative_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003605 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3606 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003607 A->getOption().getID() != options::OPT_fno_associative_math)
3608 AssociativeMath = true;
3609 bool ReciprocalMath = false;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003610 if (Arg *A = Args.getLastArg(
3611 options::OPT_ffast_math, FastMathAliasOption,
3612 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3613 options::OPT_fno_unsafe_math_optimizations,
3614 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003615 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3616 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003617 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3618 ReciprocalMath = true;
3619 bool SignedZeros = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003620 if (Arg *A = Args.getLastArg(
3621 options::OPT_ffast_math, FastMathAliasOption,
3622 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3623 options::OPT_fno_unsafe_math_optimizations,
3624 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003625 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3626 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003627 A->getOption().getID() != options::OPT_fsigned_zeros)
3628 SignedZeros = false;
3629 bool TrappingMath = true;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003630 if (Arg *A = Args.getLastArg(
3631 options::OPT_ffast_math, FastMathAliasOption,
3632 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3633 options::OPT_fno_unsafe_math_optimizations,
3634 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003635 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3636 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003637 A->getOption().getID() != options::OPT_ftrapping_math)
3638 TrappingMath = false;
3639 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3640 !TrappingMath)
3641 CmdArgs.push_back("-menable-unsafe-fp-math");
3642
Sanjay Patel76c9e092015-01-23 16:40:50 +00003643 if (!SignedZeros)
3644 CmdArgs.push_back("-fno-signed-zeros");
Lang Hamesaa53b932012-07-06 00:59:19 +00003645
Sanjay Patel359b1052015-04-09 15:03:23 +00003646 if (ReciprocalMath)
3647 CmdArgs.push_back("-freciprocal-math");
3648
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003649 // Validate and pass through -fp-contract option.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003650 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003651 options::OPT_fno_fast_math,
Lang Hamesaa53b932012-07-06 00:59:19 +00003652 options::OPT_ffp_contract)) {
3653 if (A->getOption().getID() == options::OPT_ffp_contract) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003654 StringRef Val = A->getValue();
Lang Hamesaa53b932012-07-06 00:59:19 +00003655 if (Val == "fast" || Val == "on" || Val == "off") {
3656 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3657 } else {
3658 D.Diag(diag::err_drv_unsupported_option_argument)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003659 << A->getOption().getName() << Val;
Lang Hamesaa53b932012-07-06 00:59:19 +00003660 }
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003661 } else if (A->getOption().matches(options::OPT_ffast_math) ||
3662 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
Lang Hamesaa53b932012-07-06 00:59:19 +00003663 // If fast-math is set then set the fp-contract mode to fast.
3664 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3665 }
3666 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003667
Sanjay Patel2987c292015-06-11 14:53:41 +00003668 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
Lang Hamesaa53b932012-07-06 00:59:19 +00003669
Bob Wilson6a039162012-07-19 03:52:53 +00003670 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3671 // and if we find them, tell the frontend to provide the appropriate
3672 // preprocessor macros. This is distinct from enabling any optimizations as
3673 // these options induce language changes which must survive serialization
3674 // and deserialization, etc.
Chad Rosierb71f6aa2013-04-24 18:09:54 +00003675 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3676 options::OPT_fno_fast_math))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003677 if (!A->getOption().matches(options::OPT_fno_fast_math))
3678 CmdArgs.push_back("-ffast-math");
Nico Webere8e53112014-05-11 01:04:02 +00003679 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3680 options::OPT_fno_fast_math))
Chad Rosierc30eb1c2012-09-25 22:03:25 +00003681 if (A->getOption().matches(options::OPT_ffinite_math_only))
3682 CmdArgs.push_back("-ffinite-math-only");
Chandler Carruth306bd2c2012-01-02 14:19:45 +00003683
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003684 // Decide whether to use verbose asm. Verbose assembly is the default on
3685 // toolchains which have the integrated assembler on by default.
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003686 bool IsIntegratedAssemblerDefault =
3687 getToolChain().IsIntegratedAssemblerDefault();
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003688 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003689 IsIntegratedAssemblerDefault) ||
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003690 Args.hasArg(options::OPT_dA))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003691 CmdArgs.push_back("-masm-verbose");
Daniel Dunbar0d8ca9e2010-05-14 22:00:22 +00003692
Rafael Espindolab8a12932015-05-22 20:44:03 +00003693 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3694 IsIntegratedAssemblerDefault))
Saleem Abdulrasool42e4b592014-02-22 23:37:58 +00003695 CmdArgs.push_back("-no-integrated-as");
3696
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003697 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3698 CmdArgs.push_back("-mdebug-pass");
3699 CmdArgs.push_back("Structure");
3700 }
3701 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3702 CmdArgs.push_back("-mdebug-pass");
3703 CmdArgs.push_back("Arguments");
3704 }
3705
John McCall8517abc2010-02-19 02:45:38 +00003706 // Enable -mconstructor-aliases except on darwin, where we have to
3707 // work around a linker bug; see <rdar://problem/7651567>.
Bob Wilson6524dd32011-10-14 05:03:44 +00003708 if (!getToolChain().getTriple().isOSDarwin())
John McCall8517abc2010-02-19 02:45:38 +00003709 CmdArgs.push_back("-mconstructor-aliases");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00003710
John McCall7ef5cb32011-03-18 02:56:14 +00003711 // Darwin's kernel doesn't support guard variables; just die if we
3712 // try to use them.
Bob Wilson6524dd32011-10-14 05:03:44 +00003713 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
John McCall7ef5cb32011-03-18 02:56:14 +00003714 CmdArgs.push_back("-fforbid-guard-variables");
3715
Akira Hatanaka02028482015-11-12 17:21:22 +00003716 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
3717 false)) {
Douglas Gregordbe39272011-02-01 15:15:22 +00003718 CmdArgs.push_back("-mms-bitfields");
3719 }
John McCall8517abc2010-02-19 02:45:38 +00003720
Daniel Dunbar306945d2009-09-16 06:17:29 +00003721 // This is a coarse approximation of what llvm-gcc actually does, both
3722 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3723 // complicated ways.
3724 bool AsynchronousUnwindTables =
Evgeniy Stepanov7429c592014-02-14 08:56:25 +00003725 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3726 options::OPT_fno_asynchronous_unwind_tables,
3727 (getToolChain().IsUnwindTablesDefault() ||
3728 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3729 !KernelOrKext);
Daniel Dunbar306945d2009-09-16 06:17:29 +00003730 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3731 AsynchronousUnwindTables))
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003732 CmdArgs.push_back("-munwind-tables");
3733
Chandler Carruth05fb5852012-11-21 23:40:23 +00003734 getToolChain().addClangTargetOptions(Args, CmdArgs);
Rafael Espindola66aa0452012-06-19 01:26:10 +00003735
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003736 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3737 CmdArgs.push_back("-mlimit-float-precision");
Richard Smithbd55daf2012-11-01 04:30:05 +00003738 CmdArgs.push_back(A->getValue());
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003739 }
Daniel Dunbar44e71222009-04-29 18:32:25 +00003740
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003741 // FIXME: Handle -mtune=.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003742 (void)Args.hasArg(options::OPT_mtune_EQ);
Daniel Dunbar44e71222009-04-29 18:32:25 +00003743
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003744 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
Daniel Dunbara1b02a22009-11-29 07:18:39 +00003745 CmdArgs.push_back("-mcode-model");
Richard Smithbd55daf2012-11-01 04:30:05 +00003746 CmdArgs.push_back(A->getValue());
Benjamin Kramercf4371a2009-08-05 14:30:52 +00003747 }
3748
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003749 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00003750 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003751 if (!CPU.empty()) {
3752 CmdArgs.push_back("-target-cpu");
3753 CmdArgs.push_back(Args.MakeArgString(CPU));
3754 }
3755
Rafael Espindolaeb265472013-08-21 21:59:03 +00003756 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3757 CmdArgs.push_back("-mfpmath");
3758 CmdArgs.push_back(A->getValue());
3759 }
3760
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003761 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00003762 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, false);
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00003763
Rafael Espindola22ce34a2013-08-20 22:12:08 +00003764 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003765 switch (getToolChain().getArch()) {
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003766 default:
3767 break;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003768
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003769 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003770 case llvm::Triple::armeb:
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003771 case llvm::Triple::thumb:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003772 case llvm::Triple::thumbeb:
Saleem Abdulrasoolce63ce92015-09-19 18:19:44 +00003773 // Use the effective triple, which takes into account the deployment target.
3774 AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
Daniel Dunbar0f5c5422009-09-10 04:57:17 +00003775 break;
3776
Tim Northover573cbee2014-05-24 12:52:07 +00003777 case llvm::Triple::aarch64:
3778 case llvm::Triple::aarch64_be:
Tim Northover573cbee2014-05-24 12:52:07 +00003779 AddAArch64TargetArgs(Args, CmdArgs);
Tim Northovera2ee4332014-03-29 15:09:45 +00003780 break;
3781
Eric Christopher0b26a612010-03-02 02:41:08 +00003782 case llvm::Triple::mips:
3783 case llvm::Triple::mipsel:
Akira Hatanaka94ab5542011-09-21 02:13:07 +00003784 case llvm::Triple::mips64:
3785 case llvm::Triple::mips64el:
Eric Christopher0b26a612010-03-02 02:41:08 +00003786 AddMIPSTargetArgs(Args, CmdArgs);
3787 break;
3788
Ulrich Weigand8afad612014-07-28 13:17:52 +00003789 case llvm::Triple::ppc:
3790 case llvm::Triple::ppc64:
3791 case llvm::Triple::ppc64le:
3792 AddPPCTargetArgs(Args, CmdArgs);
3793 break;
3794
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003795 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00003796 case llvm::Triple::sparcel:
Brad Smith10cd0f42014-07-11 20:12:08 +00003797 case llvm::Triple::sparcv9:
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003798 AddSparcTargetArgs(Args, CmdArgs);
3799 break;
3800
Daniel Dunbar3b3191f2009-09-09 22:33:08 +00003801 case llvm::Triple::x86:
3802 case llvm::Triple::x86_64:
3803 AddX86TargetArgs(Args, CmdArgs);
3804 break;
Tony Linthicum76329bf2011-12-12 21:14:55 +00003805
3806 case llvm::Triple::hexagon:
3807 AddHexagonTargetArgs(Args, CmdArgs);
3808 break;
Daniel Dunbar44e71222009-04-29 18:32:25 +00003809 }
3810
Douglas Katzman3459ce22015-10-08 04:24:12 +00003811 // The 'g' groups options involve a somewhat intricate sequence of decisions
3812 // about what to pass from the driver to the frontend, but by the time they
3813 // reach cc1 they've been factored into two well-defined orthogonal choices:
3814 // * what level of debug info to generate
3815 // * what dwarf version to write
3816 // This avoids having to monkey around further in cc1 other than to disable
3817 // codeview if not running in a Windows environment. Perhaps even that
3818 // decision should be made in the driver as well though.
3819 enum CodeGenOptions::DebugInfoKind DebugInfoKind =
3820 CodeGenOptions::NoDebugInfo;
3821 // These two are potentially updated by AddClangCLArgs.
3822 unsigned DwarfVersion = 0;
3823 bool EmitCodeView = false;
3824
Hans Wennborg75958c42013-08-08 00:17:41 +00003825 // Add clang-cl arguments.
3826 if (getToolChain().getDriver().IsCLMode())
Douglas Katzman3459ce22015-10-08 04:24:12 +00003827 AddClangCLArgs(Args, CmdArgs, &DebugInfoKind, &EmitCodeView);
Hans Wennborg75958c42013-08-08 00:17:41 +00003828
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003829 // Pass the linker version in use.
3830 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3831 CmdArgs.push_back("-target-linker-version");
Richard Smithbd55daf2012-11-01 04:30:05 +00003832 CmdArgs.push_back(A->getValue());
Daniel Dunbar976a2f52010-08-11 23:07:47 +00003833 }
3834
Eric Christopherb7d97e92013-04-03 01:58:53 +00003835 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
Daniel Dunbarbb7ac522010-07-01 01:31:45 +00003836 CmdArgs.push_back("-momit-leaf-frame-pointer");
3837
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003838 // Explicitly error on some things we know we don't support and can't just
3839 // ignore.
Artem Belevichba558952015-05-06 18:20:23 +00003840 types::ID InputType = Input.getType();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003841 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3842 Arg *Unsupported;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003843 if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00003844 getToolChain().getArch() == llvm::Triple::x86) {
Bob Wilson0d45f582011-08-13 23:48:55 +00003845 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3846 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003847 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003848 << Unsupported->getOption().getName();
Daniel Dunbar4ed214a2010-09-24 19:39:37 +00003849 }
Daniel Dunbarfcc49a82010-05-12 18:19:58 +00003850 }
3851
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003852 Args.AddAllArgs(CmdArgs, options::OPT_v);
Daniel Dunbard4352752010-08-24 22:44:13 +00003853 Args.AddLastArg(CmdArgs, options::OPT_H);
Chad Rosierbe10f982011-08-02 17:58:04 +00003854 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
Daniel Dunbarac540b32011-02-02 21:11:35 +00003855 CmdArgs.push_back("-header-include-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003856 CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
3857 : "-");
Daniel Dunbarac540b32011-02-02 21:11:35 +00003858 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003859 Args.AddLastArg(CmdArgs, options::OPT_P);
Mike Stump11289f42009-09-09 15:08:12 +00003860 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003861
Chad Rosierbe10f982011-08-02 17:58:04 +00003862 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003863 CmdArgs.push_back("-diagnostic-log-file");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003864 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
3865 : "-");
Daniel Dunbar529c03b2011-04-07 18:01:20 +00003866 }
3867
Rafael Espindola08a692a2010-03-07 04:46:18 +00003868 Args.ClaimAllArgs(options::OPT_g_Group);
David Blaikiece3e7a62015-07-30 21:42:22 +00003869 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003870 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00003871 // If you say "-gline-tables-only -gsplit-dwarf", split-dwarf wins,
3872 // which mandates turning on "-g". But -split-dwarf is not a g_group option,
3873 // hence it takes a nontrivial test to decide about line-tables-only.
Douglas Katzman9a2ef282015-09-30 15:55:59 +00003874 if (A->getOption().matches(options::OPT_gline_tables_only) &&
David Blaikiece3e7a62015-07-30 21:42:22 +00003875 (!SplitDwarfArg || A->getIndex() > SplitDwarfArg->getIndex())) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00003876 DebugInfoKind = CodeGenOptions::DebugLineTablesOnly;
David Blaikiece3e7a62015-07-30 21:42:22 +00003877 SplitDwarfArg = nullptr;
Douglas Katzman9a2ef282015-09-30 15:55:59 +00003878 } else if (!A->getOption().matches(options::OPT_g0)) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00003879 // Some 'g' group option other than one expressly disabling debug info
3880 // must have been the final (winning) one. They're all equivalent.
3881 DebugInfoKind = CodeGenOptions::LimitedDebugInfo;
Adrian Prantl549c5142014-02-17 17:40:52 +00003882 }
Alexey Samsonovdda3a7f2012-05-29 08:10:34 +00003883 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003884
Douglas Katzman3459ce22015-10-08 04:24:12 +00003885 // If a -gdwarf argument appeared, use it, unless DebugInfoKind is None
3886 // (because that would mean that "-g0" was the rightmost 'g' group option).
3887 // FIXME: specifying "-gdwarf-<N>" "-g1" in that order works,
3888 // but "-g1" "-gdwarf-<N>" does not. A deceptively simple (but wrong) "fix"
3889 // exists of removing the gdwarf options from the g_group.
3890 if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
3891 options::OPT_gdwarf_4))
3892 DwarfVersion = DwarfVersionNum(A->getSpelling());
3893
Reid Kleckner124955a2015-08-05 18:51:13 +00003894 // Forward -gcodeview.
Douglas Katzman3459ce22015-10-08 04:24:12 +00003895 // 'EmitCodeView might have been set by CL-compatibility argument parsing.
3896 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
3897 // DwarfVersion remains at 0 if no explicit choice was made.
3898 CmdArgs.push_back("-gcodeview");
3899 } else if (DwarfVersion == 0 &&
3900 DebugInfoKind != CodeGenOptions::NoDebugInfo) {
3901 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
3902 }
Reid Kleckner124955a2015-08-05 18:51:13 +00003903
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003904 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3905 Args.ClaimAllArgs(options::OPT_g_flags_Group);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003906
3907 // PS4 defaults to no column info
Diego Novillo94b276d2014-07-10 23:29:28 +00003908 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003909 /*Default=*/ !IsPS4CPU))
Eric Christophera2f7eb72012-10-18 21:52:18 +00003910 CmdArgs.push_back("-dwarf-column-info");
Alexey Samsonovf50a9ff2012-06-21 08:22:39 +00003911
Eric Christopher138c32b2013-09-13 22:37:55 +00003912 // FIXME: Move backend command line options to the module.
Adrian Prantl6b21ab22015-08-27 19:46:20 +00003913 if (Args.hasArg(options::OPT_gmodules)) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00003914 DebugInfoKind = CodeGenOptions::LimitedDebugInfo;
Adrian Prantl6b21ab22015-08-27 19:46:20 +00003915 CmdArgs.push_back("-dwarf-ext-refs");
3916 CmdArgs.push_back("-fmodule-format=obj");
3917 }
3918
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003919 // -gsplit-dwarf should turn on -g and enable the backend dwarf
3920 // splitting and extraction.
Eric Christopherd42fb732013-02-21 22:35:05 +00003921 // FIXME: Currently only works on Linux.
David Blaikiece3e7a62015-07-30 21:42:22 +00003922 if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00003923 DebugInfoKind = CodeGenOptions::LimitedDebugInfo;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00003924 CmdArgs.push_back("-backend-option");
3925 CmdArgs.push_back("-split-dwarf=Enable");
3926 }
3927
Douglas Katzman3459ce22015-10-08 04:24:12 +00003928 // After we've dealt with all combinations of things that could
3929 // make DebugInfoKind be other than None or DebugLineTablesOnly,
3930 // figure out if we need to "upgrade" it to standalone debug info.
3931 // We parse these two '-f' options whether or not they will be used,
3932 // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"
3933 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
3934 options::OPT_fno_standalone_debug,
3935 getToolChain().GetDefaultStandaloneDebug());
3936 if (DebugInfoKind == CodeGenOptions::LimitedDebugInfo && NeedFullDebug)
3937 DebugInfoKind = CodeGenOptions::FullDebugInfo;
3938 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion);
3939
Eric Christopher138c32b2013-09-13 22:37:55 +00003940 // -ggnu-pubnames turns on gnu style pubnames in the backend.
3941 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3942 CmdArgs.push_back("-backend-option");
3943 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3944 }
Eric Christophereec89c22013-06-18 00:03:50 +00003945
Eric Christopher0d403d22014-02-14 01:27:03 +00003946 // -gdwarf-aranges turns on the emission of the aranges section in the
3947 // backend.
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003948 // Always enabled on the PS4.
3949 if (Args.hasArg(options::OPT_gdwarf_aranges) || IsPS4CPU) {
Eric Christopher0d403d22014-02-14 01:27:03 +00003950 CmdArgs.push_back("-backend-option");
3951 CmdArgs.push_back("-generate-arange-section");
3952 }
3953
David Blaikief36d9ba2014-01-27 18:52:43 +00003954 if (Args.hasFlag(options::OPT_fdebug_types_section,
3955 options::OPT_fno_debug_types_section, false)) {
David Blaikied74be702014-01-18 02:02:06 +00003956 CmdArgs.push_back("-backend-option");
3957 CmdArgs.push_back("-generate-type-units");
3958 }
Eric Christophereec89c22013-06-18 00:03:50 +00003959
Ed Schouten6e576152015-03-26 17:50:28 +00003960 // CloudABI uses -ffunction-sections and -fdata-sections by default.
3961 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3962
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003963 if (Args.hasFlag(options::OPT_ffunction_sections,
Ed Schouten6e576152015-03-26 17:50:28 +00003964 options::OPT_fno_function_sections, UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003965 CmdArgs.push_back("-ffunction-sections");
3966 }
3967
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003968 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3969 UseSeparateSections)) {
Evgeniy Stepanov9e7cb332014-02-03 11:11:37 +00003970 CmdArgs.push_back("-fdata-sections");
3971 }
Rafael Espindola66bfb2752010-05-06 21:06:04 +00003972
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003973 if (!Args.hasFlag(options::OPT_funique_section_names,
Rafael Espindolab8a12932015-05-22 20:44:03 +00003974 options::OPT_fno_unique_section_names, true))
Rafael Espindola6b07a1c2015-02-20 18:08:57 +00003975 CmdArgs.push_back("-fno-unique-section-names");
3976
Chris Lattner3c77a352010-06-22 00:03:40 +00003977 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3978
Diego Novilloa0545962015-07-10 18:00:07 +00003979 addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
Nick Lewycky480cb992011-05-04 20:46:58 +00003980
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003981 // Pass options for controlling the default header search paths.
3982 if (Args.hasArg(options::OPT_nostdinc)) {
3983 CmdArgs.push_back("-nostdsysteminc");
3984 CmdArgs.push_back("-nobuiltininc");
3985 } else {
Daniel Dunbar0f41eee2011-10-11 18:20:16 +00003986 if (Args.hasArg(options::OPT_nostdlibinc))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003987 CmdArgs.push_back("-nostdsysteminc");
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00003988 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3989 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3990 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00003991
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003992 // Pass the path to compiler resource files.
Daniel Dunbar34e0b8c2009-12-15 01:02:52 +00003993 CmdArgs.push_back("-resource-dir");
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +00003994 CmdArgs.push_back(D.ResourceDir.c_str());
Daniel Dunbar9dc82a22009-04-07 21:42:00 +00003995
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00003996 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3997
Ted Kremenekf7639e12012-03-06 20:06:33 +00003998 bool ARCMTEnabled = false;
Argyrios Kyrtzidis85230d52013-09-17 19:14:29 +00003999 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004000 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004001 options::OPT_ccc_arcmt_modify,
4002 options::OPT_ccc_arcmt_migrate)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004003 ARCMTEnabled = true;
John McCalld70fb982011-06-15 23:25:17 +00004004 switch (A->getOption().getID()) {
4005 default:
4006 llvm_unreachable("missed a case");
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004007 case options::OPT_ccc_arcmt_check:
John McCalld70fb982011-06-15 23:25:17 +00004008 CmdArgs.push_back("-arcmt-check");
4009 break;
Argyrios Kyrtzidisc44b93d2011-07-07 04:00:39 +00004010 case options::OPT_ccc_arcmt_modify:
John McCalld70fb982011-06-15 23:25:17 +00004011 CmdArgs.push_back("-arcmt-modify");
4012 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004013 case options::OPT_ccc_arcmt_migrate:
4014 CmdArgs.push_back("-arcmt-migrate");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004015 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004016 CmdArgs.push_back(A->getValue());
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00004017
4018 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
4019 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00004020 break;
John McCalld70fb982011-06-15 23:25:17 +00004021 }
4022 }
Argyrios Kyrtzidisb11a1922013-06-24 19:01:18 +00004023 } else {
4024 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
4025 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
4026 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
John McCalld70fb982011-06-15 23:25:17 +00004027 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004028
Ted Kremenekf7639e12012-03-06 20:06:33 +00004029 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
4030 if (ARCMTEnabled) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004031 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4032 << "-ccc-arcmt-migrate";
Ted Kremenekf7639e12012-03-06 20:06:33 +00004033 }
4034 CmdArgs.push_back("-mt-migrate-directory");
Richard Smithbd55daf2012-11-01 04:30:05 +00004035 CmdArgs.push_back(A->getValue());
Ted Kremenekf7639e12012-03-06 20:06:33 +00004036
4037 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004038 options::OPT_objcmt_migrate_subscripting,
4039 options::OPT_objcmt_migrate_property)) {
Ted Kremenekf7639e12012-03-06 20:06:33 +00004040 // None specified, means enable them all.
4041 CmdArgs.push_back("-objcmt-migrate-literals");
4042 CmdArgs.push_back("-objcmt-migrate-subscripting");
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004043 CmdArgs.push_back("-objcmt-migrate-property");
Ted Kremenekf7639e12012-03-06 20:06:33 +00004044 } else {
4045 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4046 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00004047 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004048 }
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004049 } else {
4050 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4051 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4052 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4053 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4054 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4055 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
Fariborz Jahanian773fa2c2015-03-03 17:15:38 +00004056 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
Argyrios Kyrtzidis55ecf992013-11-13 23:38:20 +00004057 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4058 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4059 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4060 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4061 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4062 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4063 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
Argyrios Kyrtzidis74aa02562013-12-11 01:29:48 +00004064 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00004065 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
Ted Kremenekf7639e12012-03-06 20:06:33 +00004066 }
4067
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004068 // Add preprocessing options like -I, -D, etc. if we are using the
4069 // preprocessor.
4070 //
4071 // FIXME: Support -fpreprocessed
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004072 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
Chad Rosier633dcdc2013-01-24 19:14:47 +00004073 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004074
Rafael Espindolaa7431922011-07-21 23:40:37 +00004075 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
4076 // that "The compiler can only warn and ignore the option if not recognized".
4077 // When building with ccache, it will pass -D options to clang even on
4078 // preprocessed inputs and configure concludes that -fPIC is not supported.
4079 Args.ClaimAllArgs(options::OPT_D);
4080
Alp Toker7874bdc2013-11-15 20:40:58 +00004081 // Manually translate -O4 to -O3; let clang reject others.
Rafael Espindolaad70d962013-08-27 16:58:15 +00004082 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4083 if (A->getOption().matches(options::OPT_O4)) {
4084 CmdArgs.push_back("-O3");
4085 D.Diag(diag::warn_O4_is_O3);
4086 } else {
4087 A->render(Args, CmdArgs);
4088 }
4089 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004090
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004091 // Warn about ignored options to clang.
Sean Silva14facf32015-06-09 01:57:17 +00004092 for (const Arg *A :
4093 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4094 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
Douglas Katzman8b50e012015-08-05 18:03:47 +00004095 A->claim();
Sylvestre Ledru2fe501e2014-07-11 11:43:57 +00004096 }
4097
Rafael Espindola577637a2015-01-03 00:06:04 +00004098 claimNoWarnArgs(Args);
Chad Rosier86b82082012-12-12 20:06:31 +00004099
Richard Smith3be1cb22014-08-07 00:24:21 +00004100 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
Daniel Dunbar945577c2009-10-29 02:24:45 +00004101 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
Ted Kremenekb22ea2a2012-07-07 05:53:30 +00004102 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
4103 CmdArgs.push_back("-pedantic");
Daniel Dunbar945577c2009-10-29 02:24:45 +00004104 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004105 Args.AddLastArg(CmdArgs, options::OPT_w);
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004106
4107 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
Hans Wennborgec993822013-07-31 16:57:56 +00004108 // (-ansi is equivalent to -std=c89 or -std=c++98).
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004109 //
4110 // If a std is supplied, only add -trigraphs if it follows the
4111 // option.
David Majnemer8db91762015-05-18 04:49:30 +00004112 bool ImplyVCPPCXXVer = false;
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004113 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4114 if (Std->getOption().matches(options::OPT_ansi))
Nuno Lopes275225d2009-10-16 14:28:06 +00004115 if (types::isCXX(InputType))
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004116 CmdArgs.push_back("-std=c++98");
Nuno Lopes275225d2009-10-16 14:28:06 +00004117 else
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004118 CmdArgs.push_back("-std=c89");
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004119 else
4120 Std->render(Args, CmdArgs);
4121
Nico Weber00721502014-12-23 22:32:37 +00004122 // If -f(no-)trigraphs appears after the language standard flag, honor it.
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004123 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
Nico Weber00721502014-12-23 22:32:37 +00004124 options::OPT_ftrigraphs,
4125 options::OPT_fno_trigraphs))
Daniel Dunbar3f1a1ff2010-06-14 21:23:08 +00004126 if (A != Std)
Daniel Dunbarc44b4cc2009-04-07 22:13:21 +00004127 A->render(Args, CmdArgs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004128 } else {
4129 // Honor -std-default.
Daniel Dunbar12998192010-01-29 21:03:02 +00004130 //
4131 // FIXME: Clang doesn't correctly handle -std= when the input language
4132 // doesn't match. For the time being just ignore this for C++ inputs;
4133 // eventually we want to do all the standard defaulting here instead of
4134 // splitting it between the driver and clang -cc1.
4135 if (!types::isCXX(InputType))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004136 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
4137 /*Joined=*/true);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004138 else if (IsWindowsMSVC)
David Majnemer8db91762015-05-18 04:49:30 +00004139 ImplyVCPPCXXVer = true;
Nico Weber723b4f02012-08-30 02:08:31 +00004140
Nico Weber00721502014-12-23 22:32:37 +00004141 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4142 options::OPT_fno_trigraphs);
Daniel Dunbar72a60902009-04-26 01:10:38 +00004143 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004144
Richard Smith282b4492013-09-04 22:50:31 +00004145 // GCC's behavior for -Wwrite-strings is a bit strange:
4146 // * In C, this "warning flag" changes the types of string literals from
4147 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
4148 // for the discarded qualifier.
4149 // * In C++, this is just a normal warning flag.
4150 //
4151 // Implementing this warning correctly in C is hard, so we follow GCC's
4152 // behavior for now. FIXME: Directly diagnose uses of a string literal as
4153 // a non-const char* in C, rather than using this crude hack.
4154 if (!types::isCXX(InputType)) {
Argyrios Kyrtzidis25f2afde2014-02-07 08:33:28 +00004155 // FIXME: This should behave just like a warning flag, and thus should also
4156 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
4157 Arg *WriteStrings =
4158 Args.getLastArg(options::OPT_Wwrite_strings,
4159 options::OPT_Wno_write_strings, options::OPT_w);
4160 if (WriteStrings &&
4161 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
Richard Smith282b4492013-09-04 22:50:31 +00004162 CmdArgs.push_back("-fconst-strings");
Chandler Carruthb009b142011-04-23 06:30:43 +00004163 }
4164
Chandler Carruth61fbf622011-04-23 09:27:53 +00004165 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
Chandler Carruth30483fb2011-04-23 19:48:40 +00004166 // during C++ compilation, which it is by default. GCC keeps this define even
4167 // in the presence of '-w', match this behavior bug-for-bug.
4168 if (types::isCXX(InputType) &&
4169 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4170 true)) {
4171 CmdArgs.push_back("-fdeprecated-macro");
Chandler Carruth61fbf622011-04-23 09:27:53 +00004172 }
4173
Chandler Carruthe0391482010-05-22 02:21:53 +00004174 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
4175 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4176 if (Asm->getOption().matches(options::OPT_fasm))
4177 CmdArgs.push_back("-fgnu-keywords");
4178 else
4179 CmdArgs.push_back("-fno-gnu-keywords");
4180 }
4181
Nick Lewycky1d617ac2011-10-17 23:05:52 +00004182 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
4183 CmdArgs.push_back("-fno-dwarf-directory-asm");
4184
Daniel Dunbare246fbe2013-04-16 18:21:19 +00004185 if (ShouldDisableAutolink(Args, getToolChain()))
4186 CmdArgs.push_back("-fno-autolink");
4187
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00004188 // Add in -fdebug-compilation-dir if necessary.
4189 addDebugCompDirArg(Args, CmdArgs);
Nick Lewyckyba743b72011-10-21 02:32:14 +00004190
Saleem Abdulrasool436256a2015-10-12 20:21:08 +00004191 for (const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
4192 StringRef Map = A->getValue();
4193 if (Map.find('=') == StringRef::npos)
4194 D.Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map;
4195 else
4196 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
4197 A->claim();
4198 }
4199
Richard Smith9a568822011-11-21 19:36:32 +00004200 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4201 options::OPT_ftemplate_depth_EQ)) {
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004202 CmdArgs.push_back("-ftemplate-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004203 CmdArgs.push_back(A->getValue());
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004204 }
4205
Richard Smith79c927b2013-11-06 19:31:51 +00004206 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4207 CmdArgs.push_back("-foperator-arrow-depth");
4208 CmdArgs.push_back(A->getValue());
4209 }
4210
Richard Smith9a568822011-11-21 19:36:32 +00004211 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4212 CmdArgs.push_back("-fconstexpr-depth");
Richard Smithbd55daf2012-11-01 04:30:05 +00004213 CmdArgs.push_back(A->getValue());
Richard Smith9a568822011-11-21 19:36:32 +00004214 }
4215
Richard Smitha3d3bd22013-05-08 02:12:03 +00004216 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4217 CmdArgs.push_back("-fconstexpr-steps");
4218 CmdArgs.push_back(A->getValue());
4219 }
4220
Richard Smithb3a14522013-02-22 01:59:51 +00004221 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4222 CmdArgs.push_back("-fbracket-depth");
4223 CmdArgs.push_back(A->getValue());
4224 }
4225
Argyrios Kyrtzidisef6c8da2010-11-18 00:20:36 +00004226 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4227 options::OPT_Wlarge_by_value_copy_def)) {
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004228 if (A->getNumValues()) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004229 StringRef bytes = A->getValue();
Jean-Daniel Dupas73d801c2012-05-04 08:08:37 +00004230 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
4231 } else
4232 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
Argyrios Kyrtzidisaf84ec02010-11-17 23:11:54 +00004233 }
4234
Michael J. Spencer929fccd2012-10-22 22:13:48 +00004235 if (Args.hasArg(options::OPT_relocatable_pch))
Daniel Dunbar8bed86c2009-11-20 22:21:36 +00004236 CmdArgs.push_back("-relocatable-pch");
Mike Stump11289f42009-09-09 15:08:12 +00004237
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004238 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4239 CmdArgs.push_back("-fconstant-string-class");
Richard Smithbd55daf2012-11-01 04:30:05 +00004240 CmdArgs.push_back(A->getValue());
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00004241 }
David Chisnall5778fce2009-08-31 16:41:57 +00004242
Chris Lattnere23003d2010-01-09 21:54:33 +00004243 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4244 CmdArgs.push_back("-ftabstop");
Richard Smithbd55daf2012-11-01 04:30:05 +00004245 CmdArgs.push_back(A->getValue());
Chris Lattnere23003d2010-01-09 21:54:33 +00004246 }
4247
Chris Lattnerb35583d2010-04-07 20:49:23 +00004248 CmdArgs.push_back("-ferror-limit");
4249 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00004250 CmdArgs.push_back(A->getValue());
Chris Lattnerb35583d2010-04-07 20:49:23 +00004251 else
4252 CmdArgs.push_back("19");
Douglas Gregorffed1cb2010-04-20 07:18:24 +00004253
Chandler Carrutha77a7272010-05-06 04:55:18 +00004254 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4255 CmdArgs.push_back("-fmacro-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004256 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004257 }
4258
4259 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4260 CmdArgs.push_back("-ftemplate-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004261 CmdArgs.push_back(A->getValue());
Chandler Carrutha77a7272010-05-06 04:55:18 +00004262 }
4263
Richard Smithf6f003a2011-12-16 19:06:07 +00004264 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4265 CmdArgs.push_back("-fconstexpr-backtrace-limit");
Richard Smithbd55daf2012-11-01 04:30:05 +00004266 CmdArgs.push_back(A->getValue());
Richard Smithf6f003a2011-12-16 19:06:07 +00004267 }
4268
Nick Lewycky24653262014-12-16 21:39:02 +00004269 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4270 CmdArgs.push_back("-fspell-checking-limit");
4271 CmdArgs.push_back(A->getValue());
4272 }
4273
Daniel Dunbar2c978472009-11-04 06:24:47 +00004274 // Pass -fmessage-length=.
Daniel Dunbar84bb7932009-11-30 08:40:54 +00004275 CmdArgs.push_back("-fmessage-length");
Daniel Dunbar2c978472009-11-04 06:24:47 +00004276 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00004277 CmdArgs.push_back(A->getValue());
Daniel Dunbar2c978472009-11-04 06:24:47 +00004278 } else {
4279 // If -fmessage-length=N was not specified, determine whether this is a
4280 // terminal and, if so, implicitly define -fmessage-length appropriately.
4281 unsigned N = llvm::sys::Process::StandardErrColumns();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004282 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
Daniel Dunbar2c978472009-11-04 06:24:47 +00004283 }
4284
John McCallb4a99d32013-02-19 01:57:35 +00004285 // -fvisibility= and -fvisibility-ms-compat are of a piece.
4286 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4287 options::OPT_fvisibility_ms_compat)) {
4288 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4289 CmdArgs.push_back("-fvisibility");
4290 CmdArgs.push_back(A->getValue());
4291 } else {
4292 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4293 CmdArgs.push_back("-fvisibility");
4294 CmdArgs.push_back("hidden");
4295 CmdArgs.push_back("-ftype-visibility");
4296 CmdArgs.push_back("default");
4297 }
Daniel Dunbare357d562009-12-03 18:42:11 +00004298 }
4299
Douglas Gregor08329632010-06-15 17:05:35 +00004300 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004301
Hans Wennborgf60f6af2012-06-28 08:01:44 +00004302 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4303
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004304 // -fhosted is default.
Chad Rosier4fab82c2012-03-26 22:04:46 +00004305 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
4306 KernelOrKext)
Daniel Dunbare46b52a2010-03-20 04:52:14 +00004307 CmdArgs.push_back("-ffreestanding");
4308
Daniel Dunbare357d562009-12-03 18:42:11 +00004309 // Forward -f (flag) options which we can pass directly.
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004310 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004311 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
Eric Christopher86050822011-10-25 07:13:06 +00004312 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004313 // Emulated TLS is enabled by default on Android, and can be enabled manually
4314 // with -femulated-tls.
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00004315 bool EmulatedTLSDefault = Triple.isAndroid();
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +00004316 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
4317 EmulatedTLSDefault))
4318 CmdArgs.push_back("-femulated-tls");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004319 // AltiVec-like language extensions aren't relevant for assembling.
4320 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) {
Bill Schmidtb3b804e2013-07-03 15:36:02 +00004321 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004322 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4323 }
Richard Trieu91844232012-06-26 18:18:47 +00004324 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4325 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
Chad Rosier864dfe12012-03-13 23:45:51 +00004326
Alexey Bataevdb390212015-05-20 04:24:19 +00004327 // Forward flags for OpenMP
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004328 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4329 options::OPT_fno_openmp, false))
4330 switch (getOpenMPRuntime(getToolChain(), Args)) {
4331 case OMPRT_OMP:
4332 case OMPRT_IOMP5:
4333 // Clang can generate useful OpenMP code for these two runtime libraries.
4334 CmdArgs.push_back("-fopenmp");
Samuel Antaof8b50122015-07-13 22:54:53 +00004335
4336 // If no option regarding the use of TLS in OpenMP codegeneration is
4337 // given, decide a default based on the target. Otherwise rely on the
4338 // options and pass the right information to the frontend.
4339 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
Alexey Bataev6a43c002015-09-10 12:06:58 +00004340 options::OPT_fnoopenmp_use_tls, /*Default=*/true))
Samuel Antaof8b50122015-07-13 22:54:53 +00004341 CmdArgs.push_back("-fnoopenmp-use-tls");
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00004342 break;
4343 default:
4344 // By default, if Clang doesn't know how to generate useful OpenMP code
4345 // for a specific runtime library, we just don't pass the '-fopenmp' flag
4346 // down to the actual compilation.
4347 // FIXME: It would be better to have a mode which *only* omits IR
4348 // generation based on the OpenMP support so that we get consistent
4349 // semantic analysis, etc.
4350 break;
4351 }
Alexey Bataevdb390212015-05-20 04:24:19 +00004352
Peter Collingbourne32701642013-11-01 18:16:25 +00004353 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
Peter Collingbourne581f4382015-07-02 01:48:12 +00004354 Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
Richard Smith52be6192012-11-05 22:04:41 +00004355
Eric Christopher459d2712013-02-19 06:16:53 +00004356 // Report an error for -faltivec on anything other than PowerPC.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004357 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4358 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4359 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4360 Arch == llvm::Triple::ppc64le))
4361 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4362 << "ppc/ppc64/ppc64le";
4363 }
Chad Rosier864dfe12012-03-13 23:45:51 +00004364
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00004365 // -fzvector is incompatible with -faltivec.
4366 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4367 if (Args.hasArg(options::OPT_faltivec))
4368 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4369 << "-faltivec";
4370
Daniel Dunbar733b0f82011-03-01 18:49:30 +00004371 if (getToolChain().SupportsProfiling())
4372 Args.AddLastArg(CmdArgs, options::OPT_pg);
Daniel Dunbar35621a92010-03-16 16:57:46 +00004373
4374 // -flax-vector-conversions is default.
4375 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4376 options::OPT_fno_lax_vector_conversions))
4377 CmdArgs.push_back("-fno-lax-vector-conversions");
4378
John Brawna7b4ec02015-08-10 11:11:28 +00004379 if (Args.getLastArg(options::OPT_fapple_kext) ||
4380 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
Fariborz Jahaniana4cfff82011-01-07 01:05:02 +00004381 CmdArgs.push_back("-fapple-kext");
4382
Fariborz Jahaniana4404f22009-05-22 20:17:16 +00004383 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
Chris Lattner69686412009-04-21 05:34:31 +00004384 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00004385 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004386 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4387 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
David Chisnalldd84ef12010-09-17 18:29:54 +00004388
4389 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4390 CmdArgs.push_back("-ftrapv-handler");
Richard Smithbd55daf2012-11-01 04:30:05 +00004391 CmdArgs.push_back(A->getValue());
David Chisnalldd84ef12010-09-17 18:29:54 +00004392 }
4393
Bob Wilson14adb362012-02-03 06:27:22 +00004394 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
Evan Cheng04c94292011-04-08 21:37:45 +00004395
Chandler Carruth6e501032011-03-27 00:04:55 +00004396 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4397 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004398 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
Chandler Carruth6e501032011-03-27 00:04:55 +00004399 if (A->getOption().matches(options::OPT_fwrapv))
4400 CmdArgs.push_back("-fwrapv");
4401 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4402 options::OPT_fno_strict_overflow)) {
4403 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4404 CmdArgs.push_back("-fwrapv");
4405 }
Hal Finkelce0697f2013-11-17 16:03:29 +00004406
4407 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4408 options::OPT_fno_reroll_loops))
4409 if (A->getOption().matches(options::OPT_freroll_loops))
4410 CmdArgs.push_back("-freroll-loops");
4411
Daniel Dunbar3a148f22009-04-07 21:51:40 +00004412 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
Chandler Carruth54c29102013-08-08 08:34:35 +00004413 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4414 options::OPT_fno_unroll_loops);
Daniel Dunbara2aedc62009-03-18 10:01:51 +00004415
Daniel Dunbara77eaeb2009-09-03 04:54:28 +00004416 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4417
Daniel Dunbar4930e332009-11-17 08:07:36 +00004418 // -stack-protector=0 is default.
4419 unsigned StackProtectorLevel = 0;
Peter Collingbournec4122c12015-06-15 21:08:13 +00004420 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4421 Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4422 Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4423 Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4424 Args.ClaimAllArgs(options::OPT_fstack_protector);
4425 } else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004426 options::OPT_fstack_protector_all,
4427 options::OPT_fstack_protector_strong,
4428 options::OPT_fstack_protector)) {
Rafael Espindolace5c6092014-05-22 22:57:39 +00004429 if (A->getOption().matches(options::OPT_fstack_protector)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004430 StackProtectorLevel = std::max<unsigned>(
4431 LangOptions::SSPOn,
4432 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
Rafael Espindolace5c6092014-05-22 22:57:39 +00004433 } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004434 StackProtectorLevel = LangOptions::SSPStrong;
Daniel Dunbar4930e332009-11-17 08:07:36 +00004435 else if (A->getOption().matches(options::OPT_fstack_protector_all))
Josh Mageee0fc1a82014-02-11 01:35:14 +00004436 StackProtectorLevel = LangOptions::SSPReq;
Nico Weberdd473632011-08-23 07:38:27 +00004437 } else {
4438 StackProtectorLevel =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004439 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
Nico Weberdd473632011-08-23 07:38:27 +00004440 }
Daniel Dunbar4930e332009-11-17 08:07:36 +00004441 if (StackProtectorLevel) {
4442 CmdArgs.push_back("-stack-protector");
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004443 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004444 }
Chad Rosierdb3da832012-08-21 16:16:06 +00004445
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004446 // --param ssp-buffer-size=
Sean Silva14facf32015-06-09 01:57:17 +00004447 for (const Arg *A : Args.filtered(options::OPT__param)) {
4448 StringRef Str(A->getValue());
Joerg Sonnenberger85e2bbc2012-09-12 13:51:14 +00004449 if (Str.startswith("ssp-buffer-size=")) {
4450 if (StackProtectorLevel) {
Chad Rosierdb3da832012-08-21 16:16:06 +00004451 CmdArgs.push_back("-stack-protector-buffer-size");
4452 // FIXME: Verify the argument is a valid integer.
4453 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
Chad Rosierdb3da832012-08-21 16:16:06 +00004454 }
Sean Silva14facf32015-06-09 01:57:17 +00004455 A->claim();
Chad Rosierdb3da832012-08-21 16:16:06 +00004456 }
Bill Wendlingd63bbad2009-06-28 07:36:13 +00004457 }
4458
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004459 // Translate -mstackrealign
4460 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
Akira Hatanakaaecca042015-09-11 18:55:09 +00004461 false))
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004462 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +00004463
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +00004464 if (Args.hasArg(options::OPT_mstack_alignment)) {
4465 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4466 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
Eric Christopherd5c45f62011-05-02 21:18:22 +00004467 }
Eric Christopher84fbdb42011-08-19 00:30:14 +00004468
Hans Wennborg77dc2362015-01-20 19:45:50 +00004469 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4470 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4471
4472 if (!Size.empty())
4473 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4474 else
4475 CmdArgs.push_back("-mstack-probe-size=0");
4476 }
4477
Oliver Stannarddc2854c2015-09-03 12:40:58 +00004478 switch (getToolChain().getArch()) {
4479 case llvm::Triple::aarch64:
4480 case llvm::Triple::aarch64_be:
4481 case llvm::Triple::arm:
4482 case llvm::Triple::armeb:
4483 case llvm::Triple::thumb:
4484 case llvm::Triple::thumbeb:
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004485 CmdArgs.push_back("-fallow-half-arguments-and-returns");
Oliver Stannarddc2854c2015-09-03 12:40:58 +00004486 break;
4487
4488 default:
4489 break;
4490 }
Oliver Stannarded8ecc82014-08-27 16:31:57 +00004491
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004492 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4493 options::OPT_mno_restrict_it)) {
4494 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4495 CmdArgs.push_back("-backend-option");
4496 CmdArgs.push_back("-arm-restrict-it");
4497 } else {
4498 CmdArgs.push_back("-backend-option");
4499 CmdArgs.push_back("-arm-no-restrict-it");
4500 }
James Y Knight2db38f32015-08-15 03:45:25 +00004501 } else if (Triple.isOSWindows() &&
4502 (Triple.getArch() == llvm::Triple::arm ||
4503 Triple.getArch() == llvm::Triple::thumb)) {
Saleem Abdulrasool6deb8162014-05-18 06:42:02 +00004504 // Windows on ARM expects restricted IT blocks
4505 CmdArgs.push_back("-backend-option");
4506 CmdArgs.push_back("-arm-restrict-it");
Weiming Zhao580dcfb2013-11-13 18:31:23 +00004507 }
4508
Daniel Dunbard18049a2009-04-07 21:16:11 +00004509 // Forward -f options with positive and negative forms; we translate
4510 // these by hand.
Diego Novillo5c297052013-11-13 12:22:39 +00004511 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4512 StringRef fname = A->getValue();
4513 if (!llvm::sys::fs::exists(fname))
4514 D.Diag(diag::err_drv_no_such_file) << fname;
4515 else
4516 A->render(Args, CmdArgs);
4517 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004518
John Brawna7b4ec02015-08-10 11:11:28 +00004519 // -fbuiltin is default unless -mkernel is used
4520 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
4521 !Args.hasArg(options::OPT_mkernel)))
Daniel Dunbar484afa22009-11-19 04:55:23 +00004522 CmdArgs.push_back("-fno-builtin");
Daniel Dunbard18049a2009-04-07 21:16:11 +00004523
Nuno Lopes13c88c72009-12-16 16:59:22 +00004524 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4525 options::OPT_fno_assume_sane_operator_new))
4526 CmdArgs.push_back("-fno-assume-sane-operator-new");
4527
Daniel Dunbar4930e332009-11-17 08:07:36 +00004528 // -fblocks=0 is default.
4529 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
David Chisnallda209912011-02-28 17:11:43 +00004530 getToolChain().IsBlocksDefault()) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004531 (Args.hasArg(options::OPT_fgnu_runtime) &&
4532 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4533 !Args.hasArg(options::OPT_fno_blocks))) {
Daniel Dunbar4930e332009-11-17 08:07:36 +00004534 CmdArgs.push_back("-fblocks");
John McCall7959fee2011-09-09 20:41:01 +00004535
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004536 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
John McCall7959fee2011-09-09 20:41:01 +00004537 !getToolChain().hasBlocksRuntime())
4538 CmdArgs.push_back("-fblocks-runtime-optional");
David Chisnall950a9512009-11-17 19:33:30 +00004539 }
Daniel Dunbard18049a2009-04-07 21:16:11 +00004540
Richard Smith47972af2015-06-16 00:08:24 +00004541 // -fmodules enables the use of precompiled modules (off by default).
Richard Smithffb65082014-09-30 23:10:19 +00004542 // Users can pass -fno-cxx-modules to turn off modules support for
Richard Smith47972af2015-06-16 00:08:24 +00004543 // C++/Objective-C++ programs.
Douglas Gregorc60437f2013-01-16 01:23:41 +00004544 bool HaveModules = false;
Douglas Gregor226173a2012-01-18 15:19:58 +00004545 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004546 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4547 options::OPT_fno_cxx_modules, true);
Douglas Gregorc60437f2013-01-16 01:23:41 +00004548 if (AllowedInCXX || !types::isCXX(InputType)) {
Douglas Gregor226173a2012-01-18 15:19:58 +00004549 CmdArgs.push_back("-fmodules");
Douglas Gregorc60437f2013-01-16 01:23:41 +00004550 HaveModules = true;
4551 }
4552 }
4553
Richard Smith47972af2015-06-16 00:08:24 +00004554 // -fmodule-maps enables implicit reading of module map files. By default,
4555 // this is enabled if we are using precompiled modules.
Richard Smithcf18b792015-06-16 00:20:23 +00004556 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4557 options::OPT_fno_implicit_module_maps, HaveModules)) {
Richard Smith47972af2015-06-16 00:08:24 +00004558 CmdArgs.push_back("-fimplicit-module-maps");
Daniel Jasper07e6c402013-08-05 20:26:17 +00004559 }
4560
Daniel Jasperac42b752013-10-21 06:34:34 +00004561 // -fmodules-decluse checks that modules used are declared so (off by
4562 // default).
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004563 if (Args.hasFlag(options::OPT_fmodules_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004564 options::OPT_fno_modules_decluse, false)) {
Daniel Jasper6e16d542013-09-29 12:40:54 +00004565 CmdArgs.push_back("-fmodules-decluse");
Daniel Jasperba7f2f72013-09-24 09:14:14 +00004566 }
4567
Daniel Jasper962b38e2014-04-11 11:47:45 +00004568 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4569 // all #included headers are part of modules.
4570 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004571 options::OPT_fno_modules_strict_decluse, false)) {
Daniel Jasper962b38e2014-04-11 11:47:45 +00004572 CmdArgs.push_back("-fmodules-strict-decluse");
4573 }
4574
Manuel Klimekd2e8b042015-02-20 11:44:41 +00004575 // -fno-implicit-modules turns off implicitly compiling modules on demand.
4576 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4577 options::OPT_fno_implicit_modules)) {
4578 CmdArgs.push_back("-fno-implicit-modules");
4579 }
4580
Daniel Jasperac42b752013-10-21 06:34:34 +00004581 // -fmodule-name specifies the module that is currently being built (or
4582 // used for header checking by -fmodule-maps).
Richard Smith9887d792014-10-17 01:42:53 +00004583 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
Daniel Jasperac42b752013-10-21 06:34:34 +00004584
Richard Smith9887d792014-10-17 01:42:53 +00004585 // -fmodule-map-file can be used to specify files containing module
Daniel Jasperac42b752013-10-21 06:34:34 +00004586 // definitions.
Richard Smith9887d792014-10-17 01:42:53 +00004587 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
Daniel Jasperac42b752013-10-21 06:34:34 +00004588
Richard Smithe842a472014-10-22 02:05:46 +00004589 // -fmodule-file can be used to specify files containing precompiled modules.
Richard Smith7acebe42015-09-11 03:58:07 +00004590 if (HaveModules)
4591 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4592 else
4593 Args.ClaimAllArgs(options::OPT_fmodule_file);
Richard Smithe842a472014-10-22 02:05:46 +00004594
4595 // -fmodule-cache-path specifies where our implicitly-built module files
4596 // should be written.
Diego Novilloa0545962015-07-10 18:00:07 +00004597 SmallString<128> Path;
Justin Bognera88f0122014-06-20 22:59:50 +00004598 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
Daniel Jasper7450f912015-07-10 08:25:54 +00004599 Path = A->getValue();
Justin Bognera88f0122014-06-20 22:59:50 +00004600 if (HaveModules) {
4601 if (C.isForDiagnostics()) {
4602 // When generating crash reports, we want to emit the modules along with
4603 // the reproduction sources, so we ignore any provided module path.
Daniel Jasper7450f912015-07-10 08:25:54 +00004604 Path = Output.getFilename();
4605 llvm::sys::path::replace_extension(Path, ".cache");
4606 llvm::sys::path::append(Path, "modules");
4607 } else if (Path.empty()) {
Justin Bognera88f0122014-06-20 22:59:50 +00004608 // No module path was provided: use the default.
Renato Golin7c542b42015-07-27 23:44:45 +00004609 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Path);
Daniel Jasper7450f912015-07-10 08:25:54 +00004610 llvm::sys::path::append(Path, "org.llvm.clang.");
4611 appendUserToPath(Path);
4612 llvm::sys::path::append(Path, "ModuleCache");
Justin Bognera88f0122014-06-20 22:59:50 +00004613 }
Douglas Gregor4bedb492013-02-07 22:59:12 +00004614 const char Arg[] = "-fmodules-cache-path=";
Daniel Jasper7450f912015-07-10 08:25:54 +00004615 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
4616 CmdArgs.push_back(Args.MakeArgString(Path));
Justin Bognera88f0122014-06-20 22:59:50 +00004617 }
4618
4619 // When building modules and generating crashdumps, we need to dump a module
4620 // dependency VFS alongside the output.
4621 if (HaveModules && C.isForDiagnostics()) {
4622 SmallString<128> VFSDir(Output.getFilename());
4623 llvm::sys::path::replace_extension(VFSDir, ".cache");
Justin Bogner659ecc32014-10-20 22:47:23 +00004624 // Add the cache directory as a temp so the crash diagnostics pick it up.
4625 C.addTempFile(Args.MakeArgString(VFSDir));
4626
Justin Bognera88f0122014-06-20 22:59:50 +00004627 llvm::sys::path::append(VFSDir, "vfs");
4628 CmdArgs.push_back("-module-dependency-dir");
4629 CmdArgs.push_back(Args.MakeArgString(VFSDir));
Douglas Gregor35b04d62013-02-07 19:01:24 +00004630 }
4631
Richard Smith9887d792014-10-17 01:42:53 +00004632 if (HaveModules)
4633 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004634
Douglas Gregor35b04d62013-02-07 19:01:24 +00004635 // Pass through all -fmodules-ignore-macro arguments.
4636 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
Douglas Gregor527b1c92013-03-25 21:19:16 +00004637 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4638 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
Douglas Gregor35b04d62013-02-07 19:01:24 +00004639
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004640 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4641
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004642 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4643 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4644 D.Diag(diag::err_drv_argument_not_allowed_with)
4645 << A->getAsString(Args) << "-fbuild-session-timestamp";
4646
4647 llvm::sys::fs::file_status Status;
4648 if (llvm::sys::fs::status(A->getValue(), Status))
4649 D.Diag(diag::err_drv_no_such_file) << A->getValue();
Benjamin Kramer320fc262015-02-14 18:19:55 +00004650 CmdArgs.push_back(Args.MakeArgString(
4651 "-fbuild-session-timestamp=" +
4652 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004653 }
4654
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004655 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
Ben Langmuir19e6acb2014-08-01 22:12:21 +00004656 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4657 options::OPT_fbuild_session_file))
Dmitri Gribenkof430da42014-02-12 10:33:14 +00004658 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4659
4660 Args.AddLastArg(CmdArgs,
4661 options::OPT_fmodules_validate_once_per_build_session);
4662 }
4663
Ben Langmuirdcf73862014-03-12 00:06:17 +00004664 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4665
John McCalldfea9982010-04-09 19:12:06 +00004666 // -faccess-control is default.
John McCall3155f572010-04-09 19:03:51 +00004667 if (Args.hasFlag(options::OPT_fno_access_control,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004668 options::OPT_faccess_control, false))
John McCall3155f572010-04-09 19:03:51 +00004669 CmdArgs.push_back("-fno-access-control");
John McCall59bb1d42010-03-17 01:32:13 +00004670
Anders Carlssond470fef2010-11-21 00:09:52 +00004671 // -felide-constructors is the default.
4672 if (Args.hasFlag(options::OPT_fno_elide_constructors,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004673 options::OPT_felide_constructors, false))
Anders Carlssond470fef2010-11-21 00:09:52 +00004674 CmdArgs.push_back("-fno-elide-constructors");
4675
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004676 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
Filipe Cabecinhas28f353c2015-01-29 23:56:43 +00004677
Filipe Cabecinhasc4732552015-03-20 23:51:15 +00004678 if (KernelOrKext || (types::isCXX(InputType) &&
4679 (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4680 RTTIMode == ToolChain::RM_DisabledImplicitly)))
Filipe Cabecinhasec5d0e62015-02-19 01:04:49 +00004681 CmdArgs.push_back("-fno-rtti");
Richard Smith52be6192012-11-05 22:04:41 +00004682
Tony Linthicum76329bf2011-12-12 21:14:55 +00004683 // -fshort-enums=0 is default for all architectures except Hexagon.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004684 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4685 getToolChain().getArch() == llvm::Triple::hexagon))
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00004686 CmdArgs.push_back("-fshort-enums");
4687
Daniel Dunbard609b7b2009-11-17 06:37:03 +00004688 // -fsigned-char is default.
David Majnemerc3658d22015-05-23 18:48:37 +00004689 if (Arg *A = Args.getLastArg(
4690 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4691 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4692 if (A->getOption().matches(options::OPT_funsigned_char) ||
4693 A->getOption().matches(options::OPT_fno_signed_char)) {
4694 CmdArgs.push_back("-fno-signed-char");
4695 }
4696 } else if (!isSignedCharDefault(getToolChain().getTriple())) {
Daniel Dunbar5fe08662009-11-29 02:39:08 +00004697 CmdArgs.push_back("-fno-signed-char");
David Majnemerc3658d22015-05-23 18:48:37 +00004698 }
Eli Friedman327f0b52009-06-05 07:21:14 +00004699
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004700 // -fuse-cxa-atexit is default.
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00004701 if (!Args.hasFlag(
4702 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
4703 !IsWindowsCygnus && !IsWindowsGNU &&
4704 getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
4705 getToolChain().getArch() != llvm::Triple::hexagon &&
4706 getToolChain().getArch() != llvm::Triple::xcore &&
4707 ((getToolChain().getTriple().getVendor() !=
4708 llvm::Triple::MipsTechnologies) ||
4709 getToolChain().getTriple().hasEnvironment())) ||
Chad Rosier4fab82c2012-03-26 22:04:46 +00004710 KernelOrKext)
Daniel Dunbarfe06df42010-03-20 04:15:41 +00004711 CmdArgs.push_back("-fno-use-cxa-atexit");
4712
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004713 // -fms-extensions=0 is default.
Daniel Dunbar5bdd2992009-11-25 10:14:30 +00004714 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004715 IsWindowsMSVC))
Daniel Dunbar0730e4f2009-11-17 07:06:20 +00004716 CmdArgs.push_back("-fms-extensions");
4717
Reid Kleckner1df0fea2015-02-26 00:17:25 +00004718 // -fno-use-line-directives is default.
4719 if (Args.hasFlag(options::OPT_fuse_line_directives,
4720 options::OPT_fno_use_line_directives, false))
4721 CmdArgs.push_back("-fuse-line-directives");
4722
Francois Pichet1b4f1632011-09-17 04:32:15 +00004723 // -fms-compatibility=0 is default.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004724 if (Args.hasFlag(options::OPT_fms_compatibility,
Douglas Gregor2b4907e2011-10-24 15:49:38 +00004725 options::OPT_fno_ms_compatibility,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004726 (IsWindowsMSVC &&
4727 Args.hasFlag(options::OPT_fms_extensions,
4728 options::OPT_fno_ms_extensions, true))))
Francois Pichet1b4f1632011-09-17 04:32:15 +00004729 CmdArgs.push_back("-fms-compatibility");
4730
David Majnemerc371ff02015-03-22 08:39:22 +00004731 // -fms-compatibility-version=18.00 is default.
David Majnemere11d3732015-06-08 00:22:46 +00004732 VersionTuple MSVT = visualstudio::getMSVCVersion(
4733 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4734 if (!MSVT.empty())
David Majnemerc371ff02015-03-22 08:39:22 +00004735 CmdArgs.push_back(
4736 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004737
David Majnemer8db91762015-05-18 04:49:30 +00004738 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4739 if (ImplyVCPPCXXVer) {
4740 if (IsMSVC2015Compatible)
4741 CmdArgs.push_back("-std=c++14");
4742 else
4743 CmdArgs.push_back("-std=c++11");
4744 }
4745
Eric Christopher5ecce122013-02-18 00:38:31 +00004746 // -fno-borland-extensions is default.
Dawn Perchik68bb1b42010-09-02 23:59:25 +00004747 if (Args.hasFlag(options::OPT_fborland_extensions,
4748 options::OPT_fno_borland_extensions, false))
4749 CmdArgs.push_back("-fborland-extensions");
4750
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00004751 // -fno-declspec is default, except for PS4.
4752 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
4753 getToolChain().getTriple().isPS4()))
4754 CmdArgs.push_back("-fdeclspec");
4755 else if (Args.hasArg(options::OPT_fno_declspec))
4756 CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec.
4757
David Majnemerc371ff02015-03-22 08:39:22 +00004758 // -fthreadsafe-static is default, except for MSVC compatibility versions less
4759 // than 19.
4760 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4761 options::OPT_fno_threadsafe_statics,
David Majnemer8db91762015-05-18 04:49:30 +00004762 !IsWindowsMSVC || IsMSVC2015Compatible))
David Majnemerc371ff02015-03-22 08:39:22 +00004763 CmdArgs.push_back("-fno-threadsafe-statics");
4764
Francois Pichet02744872011-09-01 16:38:08 +00004765 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4766 // needs it.
Francois Pichet1c229c02011-04-22 22:18:13 +00004767 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00004768 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
Francois Pichet35bc5de2011-08-26 00:22:34 +00004769 CmdArgs.push_back("-fdelayed-template-parsing");
Francois Pichet1c229c02011-04-22 22:18:13 +00004770
Chandler Carruthe03aa552010-04-17 20:17:31 +00004771 // -fgnu-keywords default varies depending on language; only pass if
4772 // specified.
4773 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
Daniel Dunbardb059592010-04-24 17:56:39 +00004774 options::OPT_fno_gnu_keywords))
4775 A->render(Args, CmdArgs);
Chandler Carruthe03aa552010-04-17 20:17:31 +00004776
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004777 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
Rafael Espindola922a6242011-06-02 17:30:53 +00004778 false))
Rafael Espindolafb2af642011-06-02 16:13:27 +00004779 CmdArgs.push_back("-fgnu89-inline");
4780
Chad Rosier9c76d242012-03-15 22:31:42 +00004781 if (Args.hasArg(options::OPT_fno_inline))
4782 CmdArgs.push_back("-fno-inline");
4783
Chad Rosier64d6be92012-03-06 21:17:19 +00004784 if (Args.hasArg(options::OPT_fno_inline_functions))
4785 CmdArgs.push_back("-fno-inline-functions");
Chad Rosier80603182012-03-06 18:49:20 +00004786
John McCall5fb5df92012-06-20 06:18:46 +00004787 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
John McCall24fc0de2011-07-06 00:26:06 +00004788
John McCall5fb5df92012-06-20 06:18:46 +00004789 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
Fariborz Jahanian15f60cb2014-01-20 19:32:33 +00004790 // legacy is the default. Except for deployment taget of 10.5,
4791 // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4792 // gets ignored silently.
4793 if (objcRuntime.isNonFragile()) {
David Chisnall3154e682011-09-30 13:32:35 +00004794 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4795 options::OPT_fno_objc_legacy_dispatch,
David Chisnallda225352012-07-04 11:52:24 +00004796 objcRuntime.isLegacyDispatchDefaultForArch(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004797 getToolChain().getArch()))) {
David Chisnall3154e682011-09-30 13:32:35 +00004798 if (getToolChain().UseObjCMixedDispatch())
4799 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4800 else
4801 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4802 }
4803 }
Rafael Espindolab44676c2013-11-12 04:33:56 +00004804
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004805 // When ObjectiveC legacy runtime is in effect on MacOSX,
4806 // turn on the option to do Array/Dictionary subscripting
4807 // by default.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00004808 if (getToolChain().getArch() == llvm::Triple::x86 &&
Fariborz Jahanianff6c97c2013-11-12 20:50:26 +00004809 getToolChain().getTriple().isMacOSX() &&
4810 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4811 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
Fariborz Jahanianfd4ce192013-11-12 17:08:46 +00004812 objcRuntime.isNeXTFamily())
4813 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004814
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004815 // -fencode-extended-block-signature=1 is default.
4816 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4817 CmdArgs.push_back("-fencode-extended-block-signature");
4818 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004819
John McCall24fc0de2011-07-06 00:26:06 +00004820 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4821 // NOTE: This logic is duplicated in ToolChains.cpp.
4822 bool ARC = isObjCAutoRefCount(Args);
4823 if (ARC) {
John McCall3deb1ad2012-08-21 02:47:43 +00004824 getToolChain().CheckObjCARC();
Argyrios Kyrtzidis3dbeb552012-02-29 03:43:52 +00004825
John McCall24fc0de2011-07-06 00:26:06 +00004826 CmdArgs.push_back("-fobjc-arc");
4827
Chandler Carruth491db322011-11-04 07:34:47 +00004828 // FIXME: It seems like this entire block, and several around it should be
4829 // wrapped in isObjC, but for now we just use it here as this is where it
4830 // was being used previously.
4831 if (types::isCXX(InputType) && types::isObjC(InputType)) {
4832 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4833 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4834 else
4835 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4836 }
4837
John McCall24fc0de2011-07-06 00:26:06 +00004838 // Allow the user to enable full exceptions code emission.
4839 // We define off for Objective-CC, on for Objective-C++.
4840 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4841 options::OPT_fno_objc_arc_exceptions,
4842 /*default*/ types::isCXX(InputType)))
4843 CmdArgs.push_back("-fobjc-arc-exceptions");
John McCall460ce582015-10-22 18:38:17 +00004844
John McCall24fc0de2011-07-06 00:26:06 +00004845 }
4846
4847 // -fobjc-infer-related-result-type is the default, except in the Objective-C
4848 // rewriter.
John McCall5fb5df92012-06-20 06:18:46 +00004849 if (rewriteKind != RK_None)
John McCall24fc0de2011-07-06 00:26:06 +00004850 CmdArgs.push_back("-fno-objc-infer-related-result-type");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004851
John McCall24fc0de2011-07-06 00:26:06 +00004852 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4853 // takes precedence.
4854 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4855 if (!GCArg)
4856 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4857 if (GCArg) {
4858 if (ARC) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004859 D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00004860 } else if (getToolChain().SupportsObjCGC()) {
4861 GCArg->render(Args, CmdArgs);
4862 } else {
4863 // FIXME: We should move this to a hard error.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004864 D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
John McCall24fc0de2011-07-06 00:26:06 +00004865 }
4866 }
4867
John McCallfbe5ed72015-11-05 19:19:56 +00004868 // Pass down -fobjc-weak or -fno-objc-weak if present.
4869 if (types::isObjC(InputType)) {
4870 auto WeakArg = Args.getLastArg(options::OPT_fobjc_weak,
4871 options::OPT_fno_objc_weak);
4872 if (!WeakArg) {
4873 // nothing to do
4874 } else if (GCArg) {
4875 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4876 D.Diag(diag::err_objc_weak_with_gc);
4877 } else if (!objcRuntime.allowsWeak()) {
4878 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
4879 D.Diag(diag::err_objc_weak_unsupported);
4880 } else {
4881 WeakArg->render(Args, CmdArgs);
4882 }
4883 }
4884
Bob Wilsonb111ec92015-03-02 19:01:14 +00004885 if (Args.hasFlag(options::OPT_fapplication_extension,
4886 options::OPT_fno_application_extension, false))
4887 CmdArgs.push_back("-fapplication-extension");
4888
Reid Klecknerc542d372014-06-27 17:02:02 +00004889 // Handle GCC-style exception args.
4890 if (!C.getDriver().IsCLMode())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004891 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
4892 CmdArgs);
John McCallb5f652e2011-06-22 00:53:57 +00004893
Tim Northovere931f9f2015-10-30 16:30:41 +00004894 if (getToolChain().UseSjLjExceptions(Args))
John McCallb5f652e2011-06-22 00:53:57 +00004895 CmdArgs.push_back("-fsjlj-exceptions");
4896
4897 // C++ "sane" operator new.
Daniel Dunbar2e3f2c82010-02-01 21:07:25 +00004898 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4899 options::OPT_fno_assume_sane_operator_new))
4900 CmdArgs.push_back("-fno-assume-sane-operator-new");
4901
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00004902 // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4903 // most platforms.
4904 if (Args.hasFlag(options::OPT_fsized_deallocation,
4905 options::OPT_fno_sized_deallocation, false))
4906 CmdArgs.push_back("-fsized-deallocation");
4907
Daniel Dunbar34d7a992010-04-27 15:34:57 +00004908 // -fconstant-cfstrings is default, and may be subject to argument translation
4909 // on Darwin.
4910 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4911 options::OPT_fno_constant_cfstrings) ||
4912 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4913 options::OPT_mno_constant_cfstrings))
4914 CmdArgs.push_back("-fno-constant-cfstrings");
4915
John Thompsoned4e2952009-11-05 20:14:16 +00004916 // -fshort-wchar default varies depending on platform; only
4917 // pass if specified.
Richard Bartonc9b5f352014-02-24 18:43:28 +00004918 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4919 options::OPT_fno_short_wchar))
Daniel Dunbar2cb4e7a2010-04-27 15:35:03 +00004920 A->render(Args, CmdArgs);
John Thompsoned4e2952009-11-05 20:14:16 +00004921
Hans Wennborg28c96312013-07-31 23:39:13 +00004922 // -fno-pascal-strings is default, only pass non-default.
Daniel Dunbard067f7f2009-04-08 23:54:23 +00004923 if (Args.hasFlag(options::OPT_fpascal_strings,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004924 options::OPT_fno_pascal_strings, false))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004925 CmdArgs.push_back("-fpascal-strings");
NAKAMURA Takumi029d74b2011-02-17 08:50:50 +00004926
Daniel Dunbar096ed292011-10-05 21:04:55 +00004927 // Honor -fpack-struct= and -fpack-struct, if given. Note that
4928 // -fno-pack-struct doesn't apply to -fpack-struct=.
4929 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
James Molloycebf75e2012-05-02 07:56:14 +00004930 std::string PackStructStr = "-fpack-struct=";
Richard Smithbd55daf2012-11-01 04:30:05 +00004931 PackStructStr += A->getValue();
James Molloycebf75e2012-05-02 07:56:14 +00004932 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
Daniel Dunbar096ed292011-10-05 21:04:55 +00004933 } else if (Args.hasFlag(options::OPT_fpack_struct,
4934 options::OPT_fno_pack_struct, false)) {
James Molloycebf75e2012-05-02 07:56:14 +00004935 CmdArgs.push_back("-fpack-struct=1");
Daniel Dunbar096ed292011-10-05 21:04:55 +00004936 }
4937
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00004938 // Handle -fmax-type-align=N and -fno-type-align
4939 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4940 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4941 if (!SkipMaxTypeAlign) {
4942 std::string MaxTypeAlignStr = "-fmax-type-align=";
4943 MaxTypeAlignStr += A->getValue();
4944 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4945 }
4946 } else if (getToolChain().getTriple().isOSDarwin()) {
4947 if (!SkipMaxTypeAlign) {
4948 std::string MaxTypeAlignStr = "-fmax-type-align=16";
4949 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4950 }
4951 }
4952
John Brawna7b4ec02015-08-10 11:11:28 +00004953 // -fcommon is the default unless compiling kernel code or the target says so
4954 bool NoCommonDefault =
4955 KernelOrKext || isNoCommonDefault(getToolChain().getTriple());
4956 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
4957 !NoCommonDefault))
Daniel Dunbard18049a2009-04-07 21:16:11 +00004958 CmdArgs.push_back("-fno-common");
4959
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004960 // -fsigned-bitfields is default, and clang doesn't yet support
Daniel Dunbar6358d682010-10-15 22:30:42 +00004961 // -funsigned-bitfields.
Mike Stump11289f42009-09-09 15:08:12 +00004962 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004963 options::OPT_funsigned_bitfields))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004964 D.Diag(diag::warn_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004965 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
Daniel Dunbar2edd9232009-04-15 02:37:43 +00004966
Daniel Dunbar6358d682010-10-15 22:30:42 +00004967 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004968 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004969 D.Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004970 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
Daniel Dunbar6358d682010-10-15 22:30:42 +00004971
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004972 // -finput_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004973 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4974 StringRef value = inputCharset->getValue();
4975 if (value != "UTF-8")
4976 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4977 << value;
Sylvestre Ledru91f380a2014-07-01 17:24:27 +00004978 }
4979
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004980 // -fexec_charset=UTF-8 is default. Reject others
Douglas Katzmana67e50c2015-06-26 15:47:46 +00004981 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4982 StringRef value = execCharset->getValue();
4983 if (value != "UTF-8")
4984 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4985 << value;
Sylvestre Ledrub8198f0222014-08-11 18:09:03 +00004986 }
4987
Jeffrey Yasskin460aa542010-06-08 04:56:20 +00004988 // -fcaret-diagnostics is default.
4989 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4990 options::OPT_fno_caret_diagnostics, true))
4991 CmdArgs.push_back("-fno-caret-diagnostics");
4992
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004993 // -fdiagnostics-fixit-info is default, only pass non-default.
Mike Stump11289f42009-09-09 15:08:12 +00004994 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
Daniel Dunbar8281bde2009-04-19 21:09:34 +00004995 options::OPT_fno_diagnostics_fixit_info))
4996 CmdArgs.push_back("-fno-diagnostics-fixit-info");
Eric Christopher84fbdb42011-08-19 00:30:14 +00004997
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00004998 // Enable -fdiagnostics-show-option by default.
Mike Stump11289f42009-09-09 15:08:12 +00004999 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005000 options::OPT_fno_diagnostics_show_option))
5001 CmdArgs.push_back("-fdiagnostics-show-option");
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005002
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005003 if (const Arg *A =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005004 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005005 CmdArgs.push_back("-fdiagnostics-show-category");
Richard Smithbd55daf2012-11-01 04:30:05 +00005006 CmdArgs.push_back(A->getValue());
Chris Lattnerbf6fac82010-05-04 21:55:25 +00005007 }
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005008
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005009 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
Douglas Gregor643c9222011-05-21 17:07:29 +00005010 CmdArgs.push_back("-fdiagnostics-format");
Richard Smithbd55daf2012-11-01 04:30:05 +00005011 CmdArgs.push_back(A->getValue());
Douglas Gregor643c9222011-05-21 17:07:29 +00005012 }
5013
Chandler Carruthb6766f02011-03-27 01:50:55 +00005014 if (Arg *A = Args.getLastArg(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005015 options::OPT_fdiagnostics_show_note_include_stack,
5016 options::OPT_fno_diagnostics_show_note_include_stack)) {
Chandler Carruthb6766f02011-03-27 01:50:55 +00005017 if (A->getOption().matches(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005018 options::OPT_fdiagnostics_show_note_include_stack))
Chandler Carruthb6766f02011-03-27 01:50:55 +00005019 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
5020 else
5021 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
5022 }
5023
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005024 // Color diagnostics are the default, unless the terminal doesn't support
5025 // them.
Nico Weber7e2da792013-04-17 21:52:44 +00005026 // Support both clang's -f[no-]color-diagnostics and gcc's
5027 // -f[no-]diagnostics-colors[=never|always|auto].
5028 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005029 for (const auto &Arg : Args) {
5030 const Option &O = Arg->getOption();
Nico Weber7e2da792013-04-17 21:52:44 +00005031 if (!O.matches(options::OPT_fcolor_diagnostics) &&
5032 !O.matches(options::OPT_fdiagnostics_color) &&
5033 !O.matches(options::OPT_fno_color_diagnostics) &&
5034 !O.matches(options::OPT_fno_diagnostics_color) &&
5035 !O.matches(options::OPT_fdiagnostics_color_EQ))
5036 continue;
5037
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005038 Arg->claim();
Nico Weber7e2da792013-04-17 21:52:44 +00005039 if (O.matches(options::OPT_fcolor_diagnostics) ||
5040 O.matches(options::OPT_fdiagnostics_color)) {
5041 ShowColors = Colors_On;
5042 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
5043 O.matches(options::OPT_fno_diagnostics_color)) {
5044 ShowColors = Colors_Off;
5045 } else {
5046 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005047 StringRef value(Arg->getValue());
Nico Weber7e2da792013-04-17 21:52:44 +00005048 if (value == "always")
5049 ShowColors = Colors_On;
5050 else if (value == "never")
5051 ShowColors = Colors_Off;
5052 else if (value == "auto")
5053 ShowColors = Colors_Auto;
5054 else
5055 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005056 << ("-fdiagnostics-color=" + value).str();
Nico Weber7e2da792013-04-17 21:52:44 +00005057 }
5058 }
5059 if (ShowColors == Colors_On ||
5060 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
Daniel Dunbar5ec95022009-11-04 06:24:57 +00005061 CmdArgs.push_back("-fcolor-diagnostics");
5062
Nico Rieck7857d462013-09-11 00:38:02 +00005063 if (Args.hasArg(options::OPT_fansi_escape_codes))
5064 CmdArgs.push_back("-fansi-escape-codes");
5065
Daniel Dunbardb097022009-06-08 21:13:54 +00005066 if (!Args.hasFlag(options::OPT_fshow_source_location,
5067 options::OPT_fno_show_source_location))
5068 CmdArgs.push_back("-fno-show-source-location");
Daniel Dunbar092f0cc2009-04-16 06:32:38 +00005069
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005070 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
Douglas Gregor643c9222011-05-21 17:07:29 +00005071 true))
5072 CmdArgs.push_back("-fno-show-column");
5073
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00005074 if (!Args.hasFlag(options::OPT_fspell_checking,
5075 options::OPT_fno_spell_checking))
5076 CmdArgs.push_back("-fno-spell-checking");
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005077
Chad Rosierc8e56e82012-12-05 21:08:21 +00005078 // -fno-asm-blocks is default.
5079 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5080 false))
5081 CmdArgs.push_back("-fasm-blocks");
Daniel Dunbar473f8a62010-10-18 22:49:46 +00005082
Steven Wucb0d13f2015-01-16 23:05:28 +00005083 // -fgnu-inline-asm is default.
5084 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5085 options::OPT_fno_gnu_inline_asm, true))
5086 CmdArgs.push_back("-fno-gnu-inline-asm");
5087
Arnold Schwaighofer7f994ce2013-08-13 15:46:23 +00005088 // Enable vectorization per default according to the optimization level
5089 // selected. For optimization levels that want vectorization we use the alias
5090 // option to simplify the hasFlag logic.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005091 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005092 OptSpecifier VectorizeAliasOption =
5093 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
Chad Rosier679b0752013-04-24 18:29:59 +00005094 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
Hal Finkel108c46a2013-08-28 05:21:45 +00005095 options::OPT_fno_vectorize, EnableVec))
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005096 CmdArgs.push_back("-vectorize-loops");
Chad Rosier0d3ed6f2012-12-11 17:12:28 +00005097
Chad Rosier136d67d2014-04-28 19:30:57 +00005098 // -fslp-vectorize is enabled based on the optimization level selected.
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005099 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005100 OptSpecifier SLPVectAliasOption =
5101 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
Chad Rosier136d67d2014-04-28 19:30:57 +00005102 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
Chad Rosier3ba81bd2014-05-02 18:41:57 +00005103 options::OPT_fno_slp_vectorize, EnableSLPVec))
Nadav Rotem0a2604d2013-04-15 04:57:18 +00005104 CmdArgs.push_back("-vectorize-slp");
Hal Finkel061f1652012-12-11 19:59:32 +00005105
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005106 // -fno-slp-vectorize-aggressive is default.
5107 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +00005108 options::OPT_fno_slp_vectorize_aggressive, false))
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005109 CmdArgs.push_back("-vectorize-slp-aggressive");
Nadav Rotem6a0dd6b2013-04-15 05:38:41 +00005110
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00005111 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
5112 A->render(Args, CmdArgs);
5113
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005114 // -fdollars-in-identifiers default varies depending on platform and
5115 // language; only pass if specified.
Mike Stump11289f42009-09-09 15:08:12 +00005116 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005117 options::OPT_fno_dollars_in_identifiers)) {
5118 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005119 CmdArgs.push_back("-fdollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005120 else
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00005121 CmdArgs.push_back("-fno-dollars-in-identifiers");
Daniel Dunbarf5e9b1f2009-04-19 21:20:32 +00005122 }
5123
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005124 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
5125 // practical purposes.
Mike Stump11289f42009-09-09 15:08:12 +00005126 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005127 options::OPT_fno_unit_at_a_time)) {
5128 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005129 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbaradeeb052009-05-22 19:02:20 +00005130 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005131
Eli Friedman055c9702011-11-02 01:53:16 +00005132 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5133 options::OPT_fno_apple_pragma_pack, false))
5134 CmdArgs.push_back("-fapple-pragma-pack");
5135
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005136 // le32-specific flags:
Eli Benderskyc95cfe82013-07-24 18:20:14 +00005137 // -fno-math-builtin: clang should not convert math builtins to intrinsics
5138 // by default.
5139 if (getToolChain().getArch() == llvm::Triple::le32) {
5140 CmdArgs.push_back("-fno-math-builtin");
5141 }
5142
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005143// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
5144//
5145// FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005146#if 0
Bob Wilson6524dd32011-10-14 05:03:44 +00005147 if (getToolChain().getTriple().isOSDarwin() &&
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00005148 (getToolChain().getArch() == llvm::Triple::arm ||
5149 getToolChain().getArch() == llvm::Triple::thumb)) {
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005150 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
5151 CmdArgs.push_back("-fno-builtin-strcat");
5152 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
5153 CmdArgs.push_back("-fno-builtin-strcpy");
5154 }
Daniel Dunbar4fa08112009-09-10 04:57:27 +00005155#endif
Daniel Dunbar2ffe0292009-09-10 03:37:02 +00005156
Justin Bognera88f0122014-06-20 22:59:50 +00005157 // Enable rewrite includes if the user's asked for it or if we're generating
5158 // diagnostics.
5159 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
5160 // nice to enable this when doing a crashdump for modules as well.
Justin Bogner332a5e52014-06-20 22:16:00 +00005161 if (Args.hasFlag(options::OPT_frewrite_includes,
5162 options::OPT_fno_rewrite_includes, false) ||
Justin Bognera88f0122014-06-20 22:59:50 +00005163 (C.isForDiagnostics() && !HaveModules))
Justin Bogner332a5e52014-06-20 22:16:00 +00005164 CmdArgs.push_back("-frewrite-includes");
5165
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005166 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
Mike Stump11289f42009-09-09 15:08:12 +00005167 if (Arg *A = Args.getLastArg(options::OPT_traditional,
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005168 options::OPT_traditional_cpp)) {
5169 if (isa<PreprocessJobAction>(JA))
5170 CmdArgs.push_back("-traditional-cpp");
Eric Christopher84fbdb42011-08-19 00:30:14 +00005171 else
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005172 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
Daniel Dunbar8c3d7352011-03-18 21:23:40 +00005173 }
Eli Friedmanbb0d9a52009-07-14 21:58:17 +00005174
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005175 Args.AddLastArg(CmdArgs, options::OPT_dM);
Chris Lattnercac63f32009-04-12 01:56:53 +00005176 Args.AddLastArg(CmdArgs, options::OPT_dD);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005177
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005178 // Handle serialized diagnostics.
5179 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5180 CmdArgs.push_back("-serialize-diagnostic-file");
Richard Smithbd55daf2012-11-01 04:30:05 +00005181 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
Ted Kremeneke73d9ed2011-11-11 00:07:43 +00005182 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005183
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00005184 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5185 CmdArgs.push_back("-fretain-comments-from-system-headers");
5186
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005187 // Forward -fcomment-block-commands to -cc1.
5188 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00005189 // Forward -fparse-all-comments to -cc1.
5190 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00005191
John Brawnad31ace2015-09-23 13:55:40 +00005192 // Turn -fplugin=name.so into -load name.so
5193 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5194 CmdArgs.push_back("-load");
5195 CmdArgs.push_back(A->getValue());
5196 A->claim();
5197 }
5198
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005199 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
5200 // parser.
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005201 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
Sean Silva14facf32015-06-09 01:57:17 +00005202 for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
5203 A->claim();
Daniel Dunbar88534f42010-04-17 06:10:00 +00005204
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005205 // We translate this by hand to the -cc1 argument, since nightly test uses
5206 // it and developers have been trained to spell it with -mllvm.
Sean Silva14facf32015-06-09 01:57:17 +00005207 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005208 CmdArgs.push_back("-disable-llvm-optzns");
Bob Wilson23a55f12014-12-21 07:00:00 +00005209 } else
Sean Silva14facf32015-06-09 01:57:17 +00005210 A->render(Args, CmdArgs);
Daniel Dunbar76fa8402010-04-15 06:09:03 +00005211 }
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005212
Bob Wilson23a55f12014-12-21 07:00:00 +00005213 // With -save-temps, we want to save the unoptimized bitcode output from the
Steven Wu546a1962015-07-17 20:09:56 +00005214 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated
5215 // by the frontend.
5216 if (C.getDriver().isSaveTempsEnabled() && isa<CompileJobAction>(JA))
5217 CmdArgs.push_back("-disable-llvm-passes");
Bob Wilson23a55f12014-12-21 07:00:00 +00005218
Daniel Dunbard67a3222009-03-30 06:36:42 +00005219 if (Output.getType() == types::TY_Dependencies) {
5220 // Handled with other dependency code.
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005221 } else if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005222 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005223 CmdArgs.push_back(Output.getFilename());
5224 } else {
5225 assert(Output.isNothing() && "Invalid output.");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005226 }
5227
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005228 addDashXForInput(Args, Input, CmdArgs);
Ben Langmuir2cb4a782014-02-05 22:21:15 +00005229
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005230 if (Input.isFilename())
5231 CmdArgs.push_back(Input.getFilename());
5232 else
5233 Input.getInputArg().renderAsInput(Args, CmdArgs);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005234
Chris Lattnere9d7d782009-11-03 19:50:27 +00005235 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5236
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005237 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005238
5239 // Optionally embed the -cc1 level arguments into the debug info, for build
5240 // analysis.
5241 if (getToolChain().UseDwarfDebugFlags()) {
Daniel Dunbar7f3d9502010-06-04 18:47:06 +00005242 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005243 for (const auto &Arg : Args)
5244 Arg->render(Args, OriginalArgs);
Daniel Dunbarfe6c97b2010-08-24 16:47:49 +00005245
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005246 SmallString<256> Flags;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005247 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005248 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005249 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005250 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005251 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005252 Flags += EscapedArg;
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005253 }
5254 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005255 CmdArgs.push_back(Args.MakeArgString(Flags));
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +00005256 }
5257
Eric Christopherd3804002013-02-22 20:12:52 +00005258 // Add the split debug info name to the command lines here so we
5259 // can propagate it to the backend.
David Blaikiece3e7a62015-07-30 21:42:22 +00005260 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005261 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5262 isa<BackendJobAction>(JA));
Eric Christopherd3804002013-02-22 20:12:52 +00005263 const char *SplitDwarfOut;
5264 if (SplitDwarf) {
5265 CmdArgs.push_back("-split-dwarf-file");
Artem Belevichba558952015-05-06 18:20:23 +00005266 SplitDwarfOut = SplitDebugName(Args, Input);
Eric Christopherd3804002013-02-22 20:12:52 +00005267 CmdArgs.push_back(SplitDwarfOut);
5268 }
5269
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005270 // Host-side cuda compilation receives device-side outputs as Inputs[1...].
5271 // Include them with -fcuda-include-gpubinary.
5272 if (IsCuda && Inputs.size() > 1)
Artem Belevich5bde4e02015-07-20 20:02:54 +00005273 for (auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005274 CmdArgs.push_back("-fcuda-include-gpubinary");
Artem Belevich5bde4e02015-07-20 20:02:54 +00005275 CmdArgs.push_back(I->getFilename());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00005276 }
5277
Eric Christopherd3804002013-02-22 20:12:52 +00005278 // Finally add the compile command to the compilation.
Hans Wennborg859422a2014-01-13 22:24:42 +00005279 if (Args.hasArg(options::OPT__SLASH_fallback) &&
Hans Wennborg26a44302014-04-25 16:44:17 +00005280 Output.getType() == types::TY_Object &&
5281 (InputType == types::TY_C || InputType == types::TY_CXX)) {
David Blaikiec11bf802014-09-04 16:04:28 +00005282 auto CLCommand =
5283 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
Justin Bognerd3371d82015-07-17 03:35:54 +00005284 C.addCommand(llvm::make_unique<FallbackCommand>(
5285 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005286 } else {
Justin Bognerd3371d82015-07-17 03:35:54 +00005287 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Hans Wennborg87cfa712013-09-19 20:32:16 +00005288 }
5289
Eric Christopherf1545832013-02-22 23:50:16 +00005290 // Handle the debug info splitting at object creation time if we're
5291 // creating an object.
Eric Christopher248357f2013-02-21 22:35:01 +00005292 // TODO: Currently only works on linux with newer objcopy.
Bob Wilson23a55f12014-12-21 07:00:00 +00005293 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Eric Christopherd3804002013-02-22 20:12:52 +00005294 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
Eric Christopher248357f2013-02-21 22:35:01 +00005295
Roman Divacky178e01602011-02-10 16:52:03 +00005296 if (Arg *A = Args.getLastArg(options::OPT_pg))
5297 if (Args.hasArg(options::OPT_fomit_frame_pointer))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005298 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
5299 << A->getAsString(Args);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005300
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005301 // Claim some arguments which clang supports automatically.
5302
Daniel Dunbar3e0cac62010-04-15 06:18:42 +00005303 // -fpch-preprocess is used with gcc to add a special marker in the output to
5304 // include the PCH file. Clang's PTH solution is completely transparent, so we
5305 // do not need to deal with it at all.
Daniel Dunbarc2a71892009-04-03 20:51:31 +00005306 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005307
Daniel Dunbar17731772009-03-23 19:03:36 +00005308 // Claim some arguments which clang doesn't support, but we don't
5309 // care to warn the user about.
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00005310 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5311 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
Rafael Espindola22f603032011-02-28 23:29:45 +00005312
Rafael Espindolab0092d72013-09-04 19:37:35 +00005313 // Disable warnings for clang -E -emit-llvm foo.c
Rafael Espindolad95a8122011-03-01 05:25:27 +00005314 Args.ClaimAllArgs(options::OPT_emit_llvm);
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005315}
5316
John McCall5fb5df92012-06-20 06:18:46 +00005317/// Add options related to the Objective-C runtime/ABI.
5318///
5319/// Returns true if the runtime is non-fragile.
5320ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
5321 ArgStringList &cmdArgs,
5322 RewriteKind rewriteKind) const {
5323 // Look for the controlling runtime option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005324 Arg *runtimeArg =
5325 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5326 options::OPT_fobjc_runtime_EQ);
John McCall5fb5df92012-06-20 06:18:46 +00005327
5328 // Just forward -fobjc-runtime= to the frontend. This supercedes
5329 // options about fragility.
5330 if (runtimeArg &&
5331 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5332 ObjCRuntime runtime;
Richard Smithbd55daf2012-11-01 04:30:05 +00005333 StringRef value = runtimeArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005334 if (runtime.tryParse(value)) {
5335 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005336 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005337 }
5338
5339 runtimeArg->render(args, cmdArgs);
5340 return runtime;
5341 }
5342
5343 // Otherwise, we'll need the ABI "version". Version numbers are
5344 // slightly confusing for historical reasons:
5345 // 1 - Traditional "fragile" ABI
5346 // 2 - Non-fragile ABI, version 1
5347 // 3 - Non-fragile ABI, version 2
5348 unsigned objcABIVersion = 1;
5349 // If -fobjc-abi-version= is present, use that to set the version.
5350 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005351 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005352 if (value == "1")
5353 objcABIVersion = 1;
5354 else if (value == "2")
5355 objcABIVersion = 2;
5356 else if (value == "3")
5357 objcABIVersion = 3;
5358 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005359 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
John McCall5fb5df92012-06-20 06:18:46 +00005360 } else {
5361 // Otherwise, determine if we are using the non-fragile ABI.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005362 bool nonFragileABIIsDefault =
5363 (rewriteKind == RK_NonFragile ||
5364 (rewriteKind == RK_None &&
5365 getToolChain().IsObjCNonFragileABIDefault()));
John McCall5fb5df92012-06-20 06:18:46 +00005366 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5367 options::OPT_fno_objc_nonfragile_abi,
5368 nonFragileABIIsDefault)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005369// Determine the non-fragile ABI version to use.
John McCall5fb5df92012-06-20 06:18:46 +00005370#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5371 unsigned nonFragileABIVersion = 1;
5372#else
5373 unsigned nonFragileABIVersion = 2;
5374#endif
5375
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005376 if (Arg *abiArg =
5377 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00005378 StringRef value = abiArg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00005379 if (value == "1")
5380 nonFragileABIVersion = 1;
5381 else if (value == "2")
5382 nonFragileABIVersion = 2;
5383 else
5384 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005385 << value;
John McCall5fb5df92012-06-20 06:18:46 +00005386 }
5387
5388 objcABIVersion = 1 + nonFragileABIVersion;
5389 } else {
5390 objcABIVersion = 1;
5391 }
5392 }
5393
5394 // We don't actually care about the ABI version other than whether
5395 // it's non-fragile.
5396 bool isNonFragile = objcABIVersion != 1;
5397
5398 // If we have no runtime argument, ask the toolchain for its default runtime.
5399 // However, the rewriter only really supports the Mac runtime, so assume that.
5400 ObjCRuntime runtime;
5401 if (!runtimeArg) {
5402 switch (rewriteKind) {
5403 case RK_None:
5404 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5405 break;
5406 case RK_Fragile:
5407 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5408 break;
5409 case RK_NonFragile:
5410 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5411 break;
5412 }
5413
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005414 // -fnext-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005415 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5416 // On Darwin, make this use the default behavior for the toolchain.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005417 if (getToolChain().getTriple().isOSDarwin()) {
John McCall5fb5df92012-06-20 06:18:46 +00005418 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5419
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005420 // Otherwise, build for a generic macosx port.
John McCall5fb5df92012-06-20 06:18:46 +00005421 } else {
5422 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5423 }
5424
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005425 // -fgnu-runtime
John McCall5fb5df92012-06-20 06:18:46 +00005426 } else {
5427 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
David Chisnall314896c2012-07-04 10:37:03 +00005428 // Legacy behaviour is to target the gnustep runtime if we are i
5429 // non-fragile mode or the GCC runtime in fragile mode.
5430 if (isNonFragile)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005431 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6));
David Chisnall314896c2012-07-04 10:37:03 +00005432 else
5433 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
John McCall5fb5df92012-06-20 06:18:46 +00005434 }
5435
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005436 cmdArgs.push_back(
5437 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
John McCall5fb5df92012-06-20 06:18:46 +00005438 return runtime;
5439}
5440
Reid Klecknerc542d372014-06-27 17:02:02 +00005441static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5442 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5443 I += HaveDash;
5444 return !HaveDash;
Chandler Carruth095b6962014-06-29 22:42:51 +00005445}
Reid Klecknerc542d372014-06-27 17:02:02 +00005446
Benjamin Kramere003ca22015-10-28 13:54:16 +00005447namespace {
Reid Klecknerc542d372014-06-27 17:02:02 +00005448struct EHFlags {
5449 EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
5450 bool Synch;
5451 bool Asynch;
5452 bool NoExceptC;
5453};
Benjamin Kramere003ca22015-10-28 13:54:16 +00005454} // end anonymous namespace
Reid Klecknerc542d372014-06-27 17:02:02 +00005455
5456/// /EH controls whether to run destructor cleanups when exceptions are
5457/// thrown. There are three modifiers:
5458/// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5459/// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5460/// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
5461/// - c: Assume that extern "C" functions are implicitly noexcept. This
5462/// modifier is an optimization, so we ignore it for now.
5463/// The default is /EHs-c-, meaning cleanups are disabled.
5464static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5465 EHFlags EH;
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005466
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005467 std::vector<std::string> EHArgs =
5468 Args.getAllArgValues(options::OPT__SLASH_EH);
Reid Klecknerc542d372014-06-27 17:02:02 +00005469 for (auto EHVal : EHArgs) {
5470 for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
5471 switch (EHVal[I]) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005472 case 'a':
5473 EH.Asynch = maybeConsumeDash(EHVal, I);
5474 continue;
5475 case 'c':
5476 EH.NoExceptC = maybeConsumeDash(EHVal, I);
5477 continue;
5478 case 's':
5479 EH.Synch = maybeConsumeDash(EHVal, I);
5480 continue;
5481 default:
5482 break;
Reid Klecknerc542d372014-06-27 17:02:02 +00005483 }
5484 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
5485 break;
5486 }
5487 }
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00005488
Reid Klecknerc542d372014-06-27 17:02:02 +00005489 return EH;
5490}
5491
Douglas Katzman3459ce22015-10-08 04:24:12 +00005492void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs,
5493 enum CodeGenOptions::DebugInfoKind *DebugInfoKind,
5494 bool *EmitCodeView) const {
Hans Wennborg75958c42013-08-08 00:17:41 +00005495 unsigned RTOptionID = options::OPT__SLASH_MT;
5496
Hans Wennborgf1a74252013-09-10 20:18:04 +00005497 if (Args.hasArg(options::OPT__SLASH_LDd))
5498 // The /LDd option implies /MTd. The dependent lib part can be overridden,
5499 // but defining _DEBUG is sticky.
5500 RTOptionID = options::OPT__SLASH_MTd;
5501
Hans Wennborg9cb7d9ba2013-09-18 22:26:39 +00005502 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
Hans Wennborg75958c42013-08-08 00:17:41 +00005503 RTOptionID = A->getOption().getID();
Hans Wennborgd9ad0682013-09-11 16:38:41 +00005504
David Majnemere2afb472015-07-24 06:49:13 +00005505 StringRef FlagForCRT;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005506 switch (RTOptionID) {
5507 case options::OPT__SLASH_MD:
5508 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00005509 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005510 CmdArgs.push_back("-D_MT");
5511 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00005512 FlagForCRT = "--dependent-lib=msvcrt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005513 break;
5514 case options::OPT__SLASH_MDd:
5515 CmdArgs.push_back("-D_DEBUG");
5516 CmdArgs.push_back("-D_MT");
5517 CmdArgs.push_back("-D_DLL");
David Majnemere2afb472015-07-24 06:49:13 +00005518 FlagForCRT = "--dependent-lib=msvcrtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005519 break;
5520 case options::OPT__SLASH_MT:
5521 if (Args.hasArg(options::OPT__SLASH_LDd))
Hans Wennborg75958c42013-08-08 00:17:41 +00005522 CmdArgs.push_back("-D_DEBUG");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005523 CmdArgs.push_back("-D_MT");
David Majnemere2afb472015-07-24 06:49:13 +00005524 FlagForCRT = "--dependent-lib=libcmt";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005525 break;
5526 case options::OPT__SLASH_MTd:
5527 CmdArgs.push_back("-D_DEBUG");
5528 CmdArgs.push_back("-D_MT");
David Majnemere2afb472015-07-24 06:49:13 +00005529 FlagForCRT = "--dependent-lib=libcmtd";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005530 break;
5531 default:
5532 llvm_unreachable("Unexpected option ID.");
Hans Wennborg75958c42013-08-08 00:17:41 +00005533 }
5534
David Majnemere2afb472015-07-24 06:49:13 +00005535 if (Args.hasArg(options::OPT__SLASH_Zl)) {
5536 CmdArgs.push_back("-D_VC_NODEFAULTLIB");
5537 } else {
5538 CmdArgs.push_back(FlagForCRT.data());
5539
5540 // This provides POSIX compatibility (maps 'open' to '_open'), which most
5541 // users want. The /Za flag to cl.exe turns this off, but it's not
5542 // implemented in clang.
5543 CmdArgs.push_back("--dependent-lib=oldnames");
5544 }
Hans Wennborg614f7072013-08-08 19:54:30 +00005545
Hans Wennborg8858a032014-07-21 23:42:07 +00005546 // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
5547 // would produce interleaved output, so ignore /showIncludes in such cases.
5548 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5549 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5550 A->render(Args, CmdArgs);
Hans Wennborg81f74482013-09-10 01:07:07 +00005551
David Majnemerf6072342014-07-01 22:24:56 +00005552 // This controls whether or not we emit RTTI data for polymorphic types.
5553 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5554 /*default=*/false))
5555 CmdArgs.push_back("-fno-rtti-data");
Hans Wennborg7b0dcef2014-02-25 18:36:22 +00005556
Reid Kleckner124955a2015-08-05 18:51:13 +00005557 // Emit CodeView if -Z7 is present.
Douglas Katzman3459ce22015-10-08 04:24:12 +00005558 *EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
Reid Kleckner124955a2015-08-05 18:51:13 +00005559 bool EmitDwarf = Args.hasArg(options::OPT_gdwarf);
5560 // If we are emitting CV but not DWARF, don't build information that LLVM
5561 // can't yet process.
Douglas Katzman3459ce22015-10-08 04:24:12 +00005562 if (*EmitCodeView && !EmitDwarf)
5563 *DebugInfoKind = CodeGenOptions::DebugLineTablesOnly;
5564 if (*EmitCodeView)
Reid Kleckner124955a2015-08-05 18:51:13 +00005565 CmdArgs.push_back("-gcodeview");
5566
Reid Klecknerc542d372014-06-27 17:02:02 +00005567 const Driver &D = getToolChain().getDriver();
5568 EHFlags EH = parseClangCLEHFlags(D, Args);
5569 // FIXME: Do something with NoExceptC.
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005570 if (EH.Synch || EH.Asynch) {
Reid Klecknerc542d372014-06-27 17:02:02 +00005571 CmdArgs.push_back("-fcxx-exceptions");
Reid Klecknerdeeddec2015-02-05 18:56:03 +00005572 CmdArgs.push_back("-fexceptions");
5573 }
Reid Klecknerc542d372014-06-27 17:02:02 +00005574
Hans Wennborge50cec32014-06-13 20:59:54 +00005575 // /EP should expand to -E -P.
5576 if (Args.hasArg(options::OPT__SLASH_EP)) {
5577 CmdArgs.push_back("-E");
5578 CmdArgs.push_back("-P");
5579 }
5580
David Majnemera5b195a2015-02-14 01:35:12 +00005581 unsigned VolatileOptionID;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00005582 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5583 getToolChain().getArch() == llvm::Triple::x86)
David Majnemera5b195a2015-02-14 01:35:12 +00005584 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5585 else
5586 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5587
5588 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5589 VolatileOptionID = A->getOption().getID();
5590
5591 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5592 CmdArgs.push_back("-fms-volatile");
5593
David Majnemer86c318f2014-02-11 21:05:00 +00005594 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5595 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5596 if (MostGeneralArg && BestCaseArg)
5597 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5598 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5599
5600 if (MostGeneralArg) {
5601 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5602 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5603 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5604
5605 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5606 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5607 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5608 D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5609 << FirstConflict->getAsString(Args)
5610 << SecondConflict->getAsString(Args);
5611
5612 if (SingleArg)
5613 CmdArgs.push_back("-fms-memptr-rep=single");
5614 else if (MultipleArg)
5615 CmdArgs.push_back("-fms-memptr-rep=multiple");
5616 else
5617 CmdArgs.push_back("-fms-memptr-rep=virtual");
5618 }
5619
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00005620 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5621 A->render(Args, CmdArgs);
5622
Hans Wennborg81f74482013-09-10 01:07:07 +00005623 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5624 CmdArgs.push_back("-fdiagnostics-format");
Hans Wennborgf4aee182013-09-24 00:08:55 +00005625 if (Args.hasArg(options::OPT__SLASH_fallback))
5626 CmdArgs.push_back("msvc-fallback");
5627 else
5628 CmdArgs.push_back("msvc");
Hans Wennborg81f74482013-09-10 01:07:07 +00005629 }
Hans Wennborg75958c42013-08-08 00:17:41 +00005630}
5631
Douglas Katzman95354292015-06-23 20:42:09 +00005632visualstudio::Compiler *Clang::getCLFallback() const {
Hans Wennborg1da044a2014-06-26 19:59:02 +00005633 if (!CLFallback)
Douglas Katzman95354292015-06-23 20:42:09 +00005634 CLFallback.reset(new visualstudio::Compiler(getToolChain()));
Hans Wennborg1da044a2014-06-26 19:59:02 +00005635 return CLFallback.get();
5636}
5637
Daniel Sanders7f933f42015-01-30 17:35:23 +00005638void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5639 ArgStringList &CmdArgs) const {
5640 StringRef CPUName;
5641 StringRef ABIName;
5642 const llvm::Triple &Triple = getToolChain().getTriple();
5643 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5644
5645 CmdArgs.push_back("-target-abi");
5646 CmdArgs.push_back(ABIName.data());
5647}
5648
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005649void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005650 const InputInfo &Output, const InputInfoList &Inputs,
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005651 const ArgList &Args,
5652 const char *LinkingOutput) const {
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005653 ArgStringList CmdArgs;
5654
5655 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5656 const InputInfo &Input = Inputs[0];
5657
James Y Knight2db38f32015-08-15 03:45:25 +00005658 std::string TripleStr =
5659 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
5660 const llvm::Triple Triple(TripleStr);
5661
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005662 // Don't warn about "clang -w -c foo.s"
5663 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad95a8122011-03-01 05:25:27 +00005664 // and "clang -emit-llvm -c foo.s"
5665 Args.ClaimAllArgs(options::OPT_emit_llvm);
Rafael Espindolacfaadda2010-11-17 22:13:25 +00005666
Rafael Espindola577637a2015-01-03 00:06:04 +00005667 claimNoWarnArgs(Args);
Rafael Espindola16042fc2015-01-02 23:23:52 +00005668
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005669 // Invoke ourselves in -cc1as mode.
5670 //
5671 // FIXME: Implement custom jobs for internal actions.
5672 CmdArgs.push_back("-cc1as");
5673
5674 // Add the "effective" target triple.
5675 CmdArgs.push_back("-triple");
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005676 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5677
5678 // Set the output mode, we currently only expect to be used as a real
5679 // assembler.
5680 CmdArgs.push_back("-filetype");
5681 CmdArgs.push_back("obj");
5682
Eric Christopher45f2e712012-12-18 00:31:10 +00005683 // Set the main file name, so that debug info works even with
5684 // -save-temps or preprocessed assembly.
5685 CmdArgs.push_back("-main-file-name");
Artem Belevichba558952015-05-06 18:20:23 +00005686 CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
Eric Christopher45f2e712012-12-18 00:31:10 +00005687
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005688 // Add the target cpu
Renato Golin7c542b42015-07-27 23:44:45 +00005689 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
Rafael Espindola22ce34a2013-08-20 22:12:08 +00005690 if (!CPU.empty()) {
5691 CmdArgs.push_back("-target-cpu");
5692 CmdArgs.push_back(Args.MakeArgString(CPU));
5693 }
5694
Rafael Espindola28e1f4b2013-08-21 16:39:20 +00005695 // Add the target features
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00005696 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true);
Jim Grosbach576452b2012-02-10 20:37:10 +00005697
Daniel Dunbar1d733e22011-03-17 17:37:29 +00005698 // Ignore explicit -force_cpusubtype_ALL option.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005699 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005700
Jim Grosbachc78c2bc2015-06-23 18:20:13 +00005701 // Pass along any -I options so we get proper .include search paths.
5702 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5703
Eric Christopherfc3ee562012-01-10 00:38:01 +00005704 // Determine the original source input.
5705 const Action *SourceAction = &JA;
5706 while (SourceAction->getKind() != Action::InputClass) {
5707 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5708 SourceAction = SourceAction->getInputs()[0];
5709 }
5710
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005711 // Forward -g and handle debug info related flags, assuming we are dealing
5712 // with an actual assembly file.
Eric Christopherfc3ee562012-01-10 00:38:01 +00005713 if (SourceAction->getType() == types::TY_Asm ||
5714 SourceAction->getType() == types::TY_PP_Asm) {
Douglas Katzman3459ce22015-10-08 04:24:12 +00005715 bool WantDebug = false;
5716 unsigned DwarfVersion = 0;
Eric Christopherfc3ee562012-01-10 00:38:01 +00005717 Args.ClaimAllArgs(options::OPT_g_Group);
Douglas Katzman3459ce22015-10-08 04:24:12 +00005718 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5719 WantDebug = !A->getOption().matches(options::OPT_g0);
Douglas Katzman64071ad2015-10-15 04:10:40 +00005720 if (WantDebug)
Douglas Katzman722bcb02015-10-13 16:22:51 +00005721 DwarfVersion = DwarfVersionNum(A->getSpelling());
Douglas Katzman3459ce22015-10-08 04:24:12 +00005722 }
Douglas Katzman722bcb02015-10-13 16:22:51 +00005723 if (DwarfVersion == 0)
5724 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
Douglas Katzman3459ce22015-10-08 04:24:12 +00005725 RenderDebugEnablingArgs(Args, CmdArgs,
5726 (WantDebug ? CodeGenOptions::LimitedDebugInfo
5727 : CodeGenOptions::NoDebugInfo),
5728 DwarfVersion);
Oliver Stannard9b2a7d42014-05-19 13:39:13 +00005729
Chandler Carruth4d5e1a92012-12-17 21:40:04 +00005730 // Add the -fdebug-compilation-dir flag if needed.
5731 addDebugCompDirArg(Args, CmdArgs);
Kevin Enderbyae2ec472013-01-17 21:38:06 +00005732
5733 // Set the AT_producer to the clang version when using the integrated
5734 // assembler on assembly source files.
5735 CmdArgs.push_back("-dwarf-debug-producer");
5736 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
Renato Golina74bbc72015-07-22 15:32:36 +00005737
5738 // And pass along -I options
5739 Args.AddAllArgs(CmdArgs, options::OPT_I);
Eric Christopherfc3ee562012-01-10 00:38:01 +00005740 }
Kevin Enderby292dc082011-12-22 19:31:58 +00005741
James Y Knight5bdf7ab2015-08-19 15:12:02 +00005742 // Handle -fPIC et al -- the relocation-model affects the assembler
5743 // for some targets.
5744 llvm::Reloc::Model RelocationModel;
5745 unsigned PICLevel;
5746 bool IsPIE;
5747 std::tie(RelocationModel, PICLevel, IsPIE) =
5748 ParsePICArgs(getToolChain(), Triple, Args);
5749
5750 const char *RMName = RelocationModelName(RelocationModel);
5751 if (RMName) {
5752 CmdArgs.push_back("-mrelocation-model");
5753 CmdArgs.push_back(RMName);
5754 }
5755
Kevin Enderby292dc082011-12-22 19:31:58 +00005756 // Optionally embed the -cc1as level arguments into the debug info, for build
5757 // analysis.
5758 if (getToolChain().UseDwarfDebugFlags()) {
5759 ArgStringList OriginalArgs;
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005760 for (const auto &Arg : Args)
5761 Arg->render(Args, OriginalArgs);
Kevin Enderby292dc082011-12-22 19:31:58 +00005762
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00005763 SmallString<256> Flags;
Kevin Enderby292dc082011-12-22 19:31:58 +00005764 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5765 Flags += Exec;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005766 for (const char *OriginalArg : OriginalArgs) {
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005767 SmallString<128> EscapedArg;
Douglas Katzman6bbffc42015-06-25 18:51:37 +00005768 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
Kevin Enderby292dc082011-12-22 19:31:58 +00005769 Flags += " ";
Bob Wilsond5aad2a2014-11-04 22:28:48 +00005770 Flags += EscapedArg;
Kevin Enderby292dc082011-12-22 19:31:58 +00005771 }
5772 CmdArgs.push_back("-dwarf-debug-flags");
Yaron Keren92e1b622015-03-18 10:17:07 +00005773 CmdArgs.push_back(Args.MakeArgString(Flags));
Kevin Enderby292dc082011-12-22 19:31:58 +00005774 }
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005775
5776 // FIXME: Add -static support, once we have it.
5777
Daniel Sanders7f933f42015-01-30 17:35:23 +00005778 // Add target specific flags.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005779 switch (getToolChain().getArch()) {
Daniel Sanders7f933f42015-01-30 17:35:23 +00005780 default:
5781 break;
5782
5783 case llvm::Triple::mips:
5784 case llvm::Triple::mipsel:
5785 case llvm::Triple::mips64:
5786 case llvm::Triple::mips64el:
5787 AddMIPSTargetArgs(Args, CmdArgs);
5788 break;
5789 }
5790
David Blaikie372d9502014-01-17 03:17:40 +00005791 // Consume all the warning flags. Usually this would be handled more
5792 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5793 // doesn't handle that so rather than warning about unused flags that are
5794 // actually used, we'll lie by omission instead.
5795 // FIXME: Stop lying and consume only the appropriate driver flags
Sean Silva14facf32015-06-09 01:57:17 +00005796 for (const Arg *A : Args.filtered(options::OPT_W_Group))
5797 A->claim();
David Blaikie372d9502014-01-17 03:17:40 +00005798
David Blaikie9260ed62013-07-25 21:19:01 +00005799 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5800 getToolChain().getDriver());
5801
Daniel Dunbar252e8f92011-04-29 17:53:18 +00005802 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005803
5804 assert(Output.isFilename() && "Unexpected lipo output.");
5805 CmdArgs.push_back("-o");
5806 CmdArgs.push_back(Output.getFilename());
5807
Daniel Dunbarb440f562010-08-02 02:38:21 +00005808 assert(Input.isFilename() && "Invalid input.");
5809 CmdArgs.push_back(Input.getFilename());
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005810
Daniel Dunbarb31b76f2010-07-18 21:16:15 +00005811 const char *Exec = getToolChain().getDriver().getClangProgramPath();
Justin Bognerd3371d82015-07-17 03:35:54 +00005812 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christophera75018a2013-04-10 21:30:40 +00005813
5814 // Handle the debug info splitting at object creation time if we're
5815 // creating an object.
5816 // TODO: Currently only works on linux with newer objcopy.
5817 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00005818 getToolChain().getTriple().isOSLinux())
Eric Christophera75018a2013-04-10 21:30:40 +00005819 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00005820 SplitDebugName(Args, Input));
Daniel Dunbar4f5e79c2010-05-20 21:30:13 +00005821}
5822
Reid Kleckner0290c9c2014-09-15 17:45:39 +00005823void GnuTool::anchor() {}
5824
Daniel Dunbara3246a02009-03-18 08:07:30 +00005825void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005826 const InputInfo &Output,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005827 const InputInfoList &Inputs, const ArgList &Args,
Daniel Dunbara3246a02009-03-18 08:07:30 +00005828 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00005829 const Driver &D = getToolChain().getDriver();
Daniel Dunbara3246a02009-03-18 08:07:30 +00005830 ArgStringList CmdArgs;
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005831
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005832 for (const auto &A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00005833 if (forwardToGCC(A->getOption())) {
Daniel Dunbar939c1212010-08-03 16:14:14 +00005834 // Don't forward any -g arguments to assembly steps.
5835 if (isa<AssembleJobAction>(JA) &&
5836 A->getOption().matches(options::OPT_g_Group))
5837 continue;
5838
NAKAMURA Takumi053704f2013-08-19 11:51:51 +00005839 // Don't forward any -W arguments to assembly and link steps.
5840 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5841 A->getOption().matches(options::OPT_W_Group))
5842 continue;
5843
Daniel Dunbar2da02722009-03-19 07:55:12 +00005844 // It is unfortunate that we have to claim here, as this means
5845 // we will basically never report anything interesting for
Daniel Dunbar5716d872009-05-02 21:41:52 +00005846 // platforms using a generic gcc, even if we are just using gcc
5847 // to get to the assembler.
Daniel Dunbar2da02722009-03-19 07:55:12 +00005848 A->claim();
Daniel Dunbara2aedc62009-03-18 10:01:51 +00005849 A->render(Args, CmdArgs);
Daniel Dunbar2da02722009-03-19 07:55:12 +00005850 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005851 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00005852
Daniel Dunbar4e295052010-01-25 22:35:08 +00005853 RenderExtraToolArgs(JA, CmdArgs);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005854
5855 // If using a driver driver, force the arch.
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00005856 if (getToolChain().getTriple().isOSDarwin()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005857 CmdArgs.push_back("-arch");
Rafael Espindolaed1233e2014-08-28 21:23:05 +00005858 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005859 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
Daniel Dunbara3246a02009-03-18 08:07:30 +00005860 }
5861
Daniel Dunbar5716d872009-05-02 21:41:52 +00005862 // Try to force gcc to match the tool chain we want, if we recognize
5863 // the arch.
Daniel Dunbar5bbebfe2009-05-22 02:21:04 +00005864 //
5865 // FIXME: The triple class should directly provide the information we want
5866 // here.
Douglas Katzman38857552015-08-20 18:32:26 +00005867 switch (getToolChain().getArch()) {
5868 default:
5869 break;
5870 case llvm::Triple::x86:
5871 case llvm::Triple::ppc:
Daniel Dunbar5716d872009-05-02 21:41:52 +00005872 CmdArgs.push_back("-m32");
Douglas Katzman38857552015-08-20 18:32:26 +00005873 break;
5874 case llvm::Triple::x86_64:
5875 case llvm::Triple::ppc64:
5876 case llvm::Triple::ppc64le:
Daniel Dunbar5716d872009-05-02 21:41:52 +00005877 CmdArgs.push_back("-m64");
Douglas Katzman38857552015-08-20 18:32:26 +00005878 break;
5879 case llvm::Triple::sparcel:
5880 CmdArgs.push_back("-EL");
5881 break;
5882 }
Daniel Dunbar5716d872009-05-02 21:41:52 +00005883
Daniel Dunbarb440f562010-08-02 02:38:21 +00005884 if (Output.isFilename()) {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005885 CmdArgs.push_back("-o");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005886 CmdArgs.push_back(Output.getFilename());
5887 } else {
5888 assert(Output.isNothing() && "Unexpected output");
Daniel Dunbara3246a02009-03-18 08:07:30 +00005889 CmdArgs.push_back("-fsyntax-only");
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005890 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005891
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005892 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbara3246a02009-03-18 08:07:30 +00005893
5894 // Only pass -x if gcc will understand it; otherwise hope gcc
5895 // understands the suffix correctly. The main use case this would go
5896 // wrong in is for linker inputs if they happened to have an odd
5897 // suffix; really the only way to get this to happen is a command
5898 // like '-x foobar a.c' which will treat a.c like a linker input.
5899 //
5900 // FIXME: For the linker case specifically, can we safely convert
5901 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00005902 for (const auto &II : Inputs) {
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005903 // Don't try to pass LLVM or AST inputs to a generic gcc.
Daniel Dunbar24e52992010-06-07 23:28:45 +00005904 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5905 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005906 D.Diag(diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005907 << getToolChain().getTripleString();
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00005908 else if (II.getType() == types::TY_AST)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005909 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00005910 else if (II.getType() == types::TY_ModuleFile)
5911 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005912 << getToolChain().getTripleString();
Daniel Dunbare3e263f2009-05-02 20:14:53 +00005913
Daniel Dunbara3246a02009-03-18 08:07:30 +00005914 if (types::canTypeBeUserSpecified(II.getType())) {
5915 CmdArgs.push_back("-x");
5916 CmdArgs.push_back(types::getTypeName(II.getType()));
5917 }
5918
Daniel Dunbarb440f562010-08-02 02:38:21 +00005919 if (II.isFilename())
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005920 CmdArgs.push_back(II.getFilename());
Daniel Dunbarf2476752010-09-25 18:10:05 +00005921 else {
5922 const Arg &A = II.getInputArg();
5923
5924 // Reverse translate some rewritten options.
5925 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5926 CmdArgs.push_back("-lstdc++");
5927 continue;
5928 }
5929
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00005930 // Don't render as input, we need gcc to do the translations.
Daniel Dunbarf2476752010-09-25 18:10:05 +00005931 A.render(Args, CmdArgs);
5932 }
Daniel Dunbara3246a02009-03-18 08:07:30 +00005933 }
5934
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005935 const std::string customGCCName = D.getCCCGenericGCCName();
5936 const char *GCCName;
5937 if (!customGCCName.empty())
5938 GCCName = customGCCName.c_str();
Hans Wennborg70850d82013-07-18 20:29:38 +00005939 else if (D.CCCIsCXX()) {
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005940 GCCName = "g++";
Dylan Noblesmith70e73a32011-04-09 13:31:59 +00005941 } else
5942 GCCName = "gcc";
5943
Douglas Katzmana67e50c2015-06-26 15:47:46 +00005944 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00005945 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005946}
5947
Douglas Katzman95354292015-06-23 20:42:09 +00005948void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
5949 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005950 CmdArgs.push_back("-E");
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005951}
5952
Douglas Katzman95354292015-06-23 20:42:09 +00005953void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
5954 ArgStringList &CmdArgs) const {
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005955 const Driver &D = getToolChain().getDriver();
5956
Eric Christophercc7ff502015-01-29 00:56:17 +00005957 switch (JA.getType()) {
Daniel Dunbar4e295052010-01-25 22:35:08 +00005958 // If -flto, etc. are present then make sure not to force assembly output.
Eric Christophercc7ff502015-01-29 00:56:17 +00005959 case types::TY_LLVM_IR:
5960 case types::TY_LTO_IR:
5961 case types::TY_LLVM_BC:
5962 case types::TY_LTO_BC:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005963 CmdArgs.push_back("-c");
Eric Christophercc7ff502015-01-29 00:56:17 +00005964 break;
5965 case types::TY_PP_Asm:
Daniel Dunbar4e295052010-01-25 22:35:08 +00005966 CmdArgs.push_back("-S");
Eric Christopher58c21992015-01-30 18:22:23 +00005967 break;
Eric Christophercc7ff502015-01-29 00:56:17 +00005968 case types::TY_Nothing:
5969 CmdArgs.push_back("-fsyntax-only");
5970 break;
5971 default:
5972 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00005973 }
Daniel Dunbar1a093d22009-03-18 06:00:36 +00005974}
5975
Douglas Katzman95354292015-06-23 20:42:09 +00005976void gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
5977 ArgStringList &CmdArgs) const {
Daniel Dunbara3246a02009-03-18 08:07:30 +00005978 // The types are (hopefully) good enough.
5979}
5980
Tony Linthicum76329bf2011-12-12 21:14:55 +00005981// Hexagon tools start.
Douglas Katzman95354292015-06-23 20:42:09 +00005982void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
5983 ArgStringList &CmdArgs) const {}
5984void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
5985 const InputInfo &Output,
5986 const InputInfoList &Inputs,
5987 const ArgList &Args,
5988 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00005989 claimNoWarnArgs(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005990
5991 const Driver &D = getToolChain().getDriver();
5992 ArgStringList CmdArgs;
5993
5994 std::string MarchString = "-march=";
Douglas Katzman54366072015-07-27 16:53:08 +00005995 MarchString += toolchains::HexagonToolChain::GetTargetCPU(Args);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005996 CmdArgs.push_back(Args.MakeArgString(MarchString));
5997
5998 RenderExtraToolArgs(JA, CmdArgs);
5999
6000 if (Output.isFilename()) {
6001 CmdArgs.push_back("-o");
6002 CmdArgs.push_back(Output.getFilename());
6003 } else {
6004 assert(Output.isNothing() && "Unexpected output");
6005 CmdArgs.push_back("-fsyntax-only");
6006 }
6007
Douglas Katzman54366072015-07-27 16:53:08 +00006008 if (const char *v = toolchains::HexagonToolChain::GetSmallDataThreshold(Args))
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00006009 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006010
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006011 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Matthew Curtise5df3812012-12-07 17:23:04 +00006012
Tony Linthicum76329bf2011-12-12 21:14:55 +00006013 // Only pass -x if gcc will understand it; otherwise hope gcc
6014 // understands the suffix correctly. The main use case this would go
6015 // wrong in is for linker inputs if they happened to have an odd
6016 // suffix; really the only way to get this to happen is a command
6017 // like '-x foobar a.c' which will treat a.c like a linker input.
6018 //
6019 // FIXME: For the linker case specifically, can we safely convert
6020 // inputs into '-Wl,' options?
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006021 for (const auto &II : Inputs) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006022 // Don't try to pass LLVM or AST inputs to a generic gcc.
6023 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
6024 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
6025 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006026 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006027 else if (II.getType() == types::TY_AST)
6028 D.Diag(clang::diag::err_drv_no_ast_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006029 << getToolChain().getTripleString();
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00006030 else if (II.getType() == types::TY_ModuleFile)
6031 D.Diag(diag::err_drv_no_module_support)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006032 << getToolChain().getTripleString();
Tony Linthicum76329bf2011-12-12 21:14:55 +00006033
6034 if (II.isFilename())
6035 CmdArgs.push_back(II.getFilename());
6036 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006037 // Don't render as input, we need gcc to do the translations.
6038 // FIXME: Pranav: What is this ?
Tony Linthicum76329bf2011-12-12 21:14:55 +00006039 II.getInputArg().render(Args, CmdArgs);
6040 }
6041
6042 const char *GCCName = "hexagon-as";
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006043 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
Justin Bognerd3371d82015-07-17 03:35:54 +00006044 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006045}
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006046
Douglas Katzman95354292015-06-23 20:42:09 +00006047void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
6048 ArgStringList &CmdArgs) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006049 // The types are (hopefully) good enough.
6050}
6051
Douglas Katzman54366072015-07-27 16:53:08 +00006052static void
6053constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
6054 const toolchains::HexagonToolChain &ToolChain,
6055 const InputInfo &Output, const InputInfoList &Inputs,
6056 const ArgList &Args, ArgStringList &CmdArgs,
6057 const char *LinkingOutput) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006058
Matthew Curtise689b052012-12-06 15:46:07 +00006059 const Driver &D = ToolChain.getDriver();
6060
Matthew Curtise689b052012-12-06 15:46:07 +00006061 //----------------------------------------------------------------------------
6062 //
6063 //----------------------------------------------------------------------------
6064 bool hasStaticArg = Args.hasArg(options::OPT_static);
6065 bool buildingLib = Args.hasArg(options::OPT_shared);
Matthew Curtise8f80a12012-12-06 17:49:03 +00006066 bool buildPIE = Args.hasArg(options::OPT_pie);
Matthew Curtise689b052012-12-06 15:46:07 +00006067 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
6068 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
6069 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00006070 bool useG0 = false;
Matthew Curtise689b052012-12-06 15:46:07 +00006071 bool useShared = buildingLib && !hasStaticArg;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006072
Matthew Curtise689b052012-12-06 15:46:07 +00006073 //----------------------------------------------------------------------------
6074 // Silence warnings for various options
6075 //----------------------------------------------------------------------------
Tony Linthicum76329bf2011-12-12 21:14:55 +00006076
Matthew Curtise689b052012-12-06 15:46:07 +00006077 Args.ClaimAllArgs(options::OPT_g_Group);
6078 Args.ClaimAllArgs(options::OPT_emit_llvm);
6079 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
6080 // handled somewhere else.
6081 Args.ClaimAllArgs(options::OPT_static_libgcc);
6082
6083 //----------------------------------------------------------------------------
6084 //
6085 //----------------------------------------------------------------------------
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006086 for (const auto &Opt : ToolChain.ExtraOpts)
6087 CmdArgs.push_back(Opt.c_str());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006088
Douglas Katzman54366072015-07-27 16:53:08 +00006089 std::string MarchString = toolchains::HexagonToolChain::GetTargetCPU(Args);
Matthew Curtisf10a5952012-12-06 14:16:43 +00006090 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
Sebastian Pop86500282012-01-13 20:37:10 +00006091
Matthew Curtise689b052012-12-06 15:46:07 +00006092 if (buildingLib) {
6093 CmdArgs.push_back("-shared");
6094 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
6095 // hexagon-gcc does
Tony Linthicum76329bf2011-12-12 21:14:55 +00006096 }
6097
Matthew Curtise689b052012-12-06 15:46:07 +00006098 if (hasStaticArg)
6099 CmdArgs.push_back("-static");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006100
Matthew Curtise8f80a12012-12-06 17:49:03 +00006101 if (buildPIE && !buildingLib)
6102 CmdArgs.push_back("-pie");
6103
Douglas Katzman54366072015-07-27 16:53:08 +00006104 if (const char *v =
6105 toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) {
Ikhlas Ajbar522e6192015-05-14 13:52:08 +00006106 CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
Douglas Katzman54366072015-07-27 16:53:08 +00006107 useG0 = toolchains::HexagonToolChain::UsesG0(v);
Matthew Curtise8f80a12012-12-06 17:49:03 +00006108 }
6109
Matthew Curtise689b052012-12-06 15:46:07 +00006110 //----------------------------------------------------------------------------
6111 //
6112 //----------------------------------------------------------------------------
6113 CmdArgs.push_back("-o");
6114 CmdArgs.push_back(Output.getFilename());
Tony Linthicum76329bf2011-12-12 21:14:55 +00006115
Matthew Curtise689b052012-12-06 15:46:07 +00006116 const std::string MarchSuffix = "/" + MarchString;
6117 const std::string G0Suffix = "/G0";
6118 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
Benjamin Kramerd45b2052015-10-07 15:48:01 +00006119 const std::string RootDir = ToolChain.GetGnuDir(D.InstalledDir, Args) + "/";
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006120 const std::string StartFilesDir =
6121 RootDir + "hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix);
Matthew Curtise689b052012-12-06 15:46:07 +00006122
6123 //----------------------------------------------------------------------------
6124 // moslib
6125 //----------------------------------------------------------------------------
6126 std::vector<std::string> oslibs;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006127 bool hasStandalone = false;
Matthew Curtise689b052012-12-06 15:46:07 +00006128
Sean Silva14facf32015-06-09 01:57:17 +00006129 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
6130 A->claim();
6131 oslibs.emplace_back(A->getValue());
Matthew Curtise689b052012-12-06 15:46:07 +00006132 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006133 }
Matthew Curtise689b052012-12-06 15:46:07 +00006134 if (oslibs.empty()) {
6135 oslibs.push_back("standalone");
6136 hasStandalone = true;
6137 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006138
Matthew Curtise689b052012-12-06 15:46:07 +00006139 //----------------------------------------------------------------------------
6140 // Start Files
6141 //----------------------------------------------------------------------------
6142 if (incStdLib && incStartFiles) {
6143
6144 if (!buildingLib) {
6145 if (hasStandalone) {
6146 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006147 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
Matthew Curtise689b052012-12-06 15:46:07 +00006148 }
6149 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
6150 }
6151 std::string initObj = useShared ? "/initS.o" : "/init.o";
6152 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
6153 }
6154
6155 //----------------------------------------------------------------------------
6156 // Library Search Paths
6157 //----------------------------------------------------------------------------
6158 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006159 for (const auto &LibPath : LibPaths)
6160 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
Matthew Curtise689b052012-12-06 15:46:07 +00006161
6162 //----------------------------------------------------------------------------
6163 //
6164 //----------------------------------------------------------------------------
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006165 Args.AddAllArgs(CmdArgs,
6166 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6167 options::OPT_t, options::OPT_u_Group});
Matthew Curtise689b052012-12-06 15:46:07 +00006168
6169 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6170
6171 //----------------------------------------------------------------------------
6172 // Libraries
6173 //----------------------------------------------------------------------------
6174 if (incStdLib && incDefLibs) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006175 if (D.CCCIsCXX()) {
Matthew Curtise689b052012-12-06 15:46:07 +00006176 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6177 CmdArgs.push_back("-lm");
6178 }
6179
6180 CmdArgs.push_back("--start-group");
6181
6182 if (!buildingLib) {
Douglas Katzman2675d012015-06-29 19:12:56 +00006183 for (const std::string &Lib : oslibs)
6184 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
Matthew Curtise689b052012-12-06 15:46:07 +00006185 CmdArgs.push_back("-lc");
6186 }
6187 CmdArgs.push_back("-lgcc");
6188
6189 CmdArgs.push_back("--end-group");
6190 }
6191
6192 //----------------------------------------------------------------------------
6193 // End files
6194 //----------------------------------------------------------------------------
6195 if (incStdLib && incStartFiles) {
6196 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
6197 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
6198 }
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006199}
6200
Douglas Katzman95354292015-06-23 20:42:09 +00006201void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6202 const InputInfo &Output,
6203 const InputInfoList &Inputs,
6204 const ArgList &Args,
6205 const char *LinkingOutput) const {
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006206
Douglas Katzman54366072015-07-27 16:53:08 +00006207 const toolchains::HexagonToolChain &ToolChain =
6208 static_cast<const toolchains::HexagonToolChain &>(getToolChain());
Ikhlas Ajbar71d19f32015-05-09 02:13:25 +00006209
6210 ArgStringList CmdArgs;
6211 constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
6212 LinkingOutput);
Matthew Curtise689b052012-12-06 15:46:07 +00006213
6214 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
David Blaikiec11bf802014-09-04 16:04:28 +00006215 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
Justin Bognerd3371d82015-07-17 03:35:54 +00006216 CmdArgs, Inputs));
Tony Linthicum76329bf2011-12-12 21:14:55 +00006217}
6218// Hexagon tools end.
6219
Tom Stellard8fa33092015-07-18 01:49:05 +00006220void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6221 const InputInfo &Output,
6222 const InputInfoList &Inputs,
6223 const ArgList &Args,
6224 const char *LinkingOutput) const {
6225
6226 std::string Linker = getToolChain().GetProgramPath(getShortName());
6227 ArgStringList CmdArgs;
6228 CmdArgs.push_back("-flavor");
6229 CmdArgs.push_back("gnu");
6230 CmdArgs.push_back("-target");
Tom Stellard1de69e82015-07-18 02:11:07 +00006231 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
Tom Stellard8fa33092015-07-18 01:49:05 +00006232 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6233 CmdArgs.push_back("-o");
6234 CmdArgs.push_back(Output.getFilename());
6235 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
6236 CmdArgs, Inputs));
6237}
6238// AMDGPU tools end.
6239
Renato Golin7c542b42015-07-27 23:44:45 +00006240const std::string arm::getARMArch(StringRef Arch, const llvm::Triple &Triple) {
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00006241 std::string MArch;
Renato Goline17c5802015-07-27 23:44:42 +00006242 if (!Arch.empty())
6243 MArch = Arch;
6244 else
Bernard Ogden31561762013-12-12 13:27:11 +00006245 MArch = Triple.getArchName();
Gabor Ballabascebcb3b2015-06-11 12:29:56 +00006246 MArch = StringRef(MArch).lower();
John Brawn94fd9632015-05-21 12:19:49 +00006247
6248 // Handle -march=native.
6249 if (MArch == "native") {
6250 std::string CPU = llvm::sys::getHostCPUName();
6251 if (CPU != "generic") {
6252 // Translate the native cpu into the architecture suffix for that CPU.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006253 StringRef Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006254 // If there is no valid architecture suffix for this CPU we don't know how
6255 // to handle it, so return no architecture.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006256 if (Suffix.empty())
John Brawn94fd9632015-05-21 12:19:49 +00006257 MArch = "";
6258 else
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006259 MArch = std::string("arm") + Suffix.str();
John Brawn94fd9632015-05-21 12:19:49 +00006260 }
6261 }
6262
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006263 return MArch;
6264}
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006265
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006266/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006267StringRef arm::getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple) {
Renato Goline17c5802015-07-27 23:44:42 +00006268 std::string MArch = getARMArch(Arch, Triple);
John Brawn94fd9632015-05-21 12:19:49 +00006269 // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
6270 // here means an -march=native that we can't handle, so instead return no CPU.
6271 if (MArch.empty())
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006272 return StringRef();
Bernard Ogden31561762013-12-12 13:27:11 +00006273
John Brawna95c1a82015-05-08 12:52:18 +00006274 // We need to return an empty string here on invalid MArch values as the
6275 // various places that call this function can't cope with a null result.
Chandler Carruthd96f37a2015-08-30 07:51:18 +00006276 return Triple.getARMCPUForArch(MArch);
Bernard Ogden31561762013-12-12 13:27:11 +00006277}
6278
6279/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
Renato Golin7c542b42015-07-27 23:44:45 +00006280std::string arm::getARMTargetCPU(StringRef CPU, StringRef Arch,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006281 const llvm::Triple &Triple) {
Bernard Ogden31561762013-12-12 13:27:11 +00006282 // FIXME: Warn on inconsistent use of -mcpu and -march.
6283 // If we have -mcpu=, use that.
Renato Goline17c5802015-07-27 23:44:42 +00006284 if (!CPU.empty()) {
6285 std::string MCPU = StringRef(CPU).lower();
Bernard Ogden31561762013-12-12 13:27:11 +00006286 // Handle -mcpu=native.
6287 if (MCPU == "native")
Rafael Espindola9c5ef122013-12-12 15:39:05 +00006288 return llvm::sys::getHostCPUName();
Bernard Ogden31561762013-12-12 13:27:11 +00006289 else
Rafael Espindola80d333b2013-12-12 15:48:19 +00006290 return MCPU;
Bernard Ogden31561762013-12-12 13:27:11 +00006291 }
6292
Renato Goline17c5802015-07-27 23:44:42 +00006293 return getARMCPUForMArch(Arch, Triple);
Bernard Ogden31561762013-12-12 13:27:11 +00006294}
6295
6296/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006297/// CPU (or Arch, if CPU is generic).
Bernard Ogden31561762013-12-12 13:27:11 +00006298// FIXME: This is redundant with -mcpu, why does LLVM use this.
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006299StringRef arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch,
6300 const llvm::Triple &Triple) {
6301 unsigned ArchKind;
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006302 if (CPU == "generic") {
Vladimir Sukhareva317dfb2015-09-24 10:06:44 +00006303 std::string ARMArch = tools::arm::getARMArch(Arch, Triple);
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00006304 ArchKind = llvm::ARM::parseArch(ARMArch);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006305 if (ArchKind == llvm::ARM::AK_INVALID)
6306 // In case of generic Arch, i.e. "arm",
6307 // extract arch from default cpu of the Triple
Vladimir Sukharev2eef4b52015-09-24 09:55:08 +00006308 ArchKind = llvm::ARM::parseCPUArch(Triple.getARMCPUForArch(ARMArch));
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006309 } else {
Tim Northover6f3ff222015-10-30 16:30:27 +00006310 // FIXME: horrible hack to get around the fact that Cortex-A7 is only an
6311 // armv7k triple if it's actually been specified via "-arch armv7k".
6312 ArchKind = (Arch == "armv7k" || Arch == "thumbv7k")
Aaron Ballman43059102015-11-04 14:43:43 +00006313 ? (unsigned)llvm::ARM::AK_ARMV7K
Tim Northover6f3ff222015-10-30 16:30:27 +00006314 : llvm::ARM::parseCPUArch(CPU);
Vladimir Sukharev64f68242015-09-23 09:29:32 +00006315 }
Renato Golin3c007252015-05-28 15:05:53 +00006316 if (ArchKind == llvm::ARM::AK_INVALID)
6317 return "";
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00006318 return llvm::ARM::getSubArch(ArchKind);
Bernard Ogden31561762013-12-12 13:27:11 +00006319}
6320
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006321void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
Vladimir Sukharevc6dab752015-05-14 08:25:18 +00006322 const llvm::Triple &Triple) {
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006323 if (Args.hasArg(options::OPT_r))
6324 return;
6325
John Brawn94fd9632015-05-21 12:19:49 +00006326 // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
6327 // to generate BE-8 executables.
6328 if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
6329 CmdArgs.push_back("--be8");
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00006330}
6331
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006332mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
Daniel Sanderse0395a72015-09-24 10:22:17 +00006333 // Strictly speaking, mips32r2 and mips64r2 are NanLegacy-only since Nan2008
6334 // was first introduced in Release 3. However, other compilers have
6335 // traditionally allowed it for Release 2 so we should do the same.
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006336 return (NanEncoding)llvm::StringSwitch<int>(CPU)
6337 .Case("mips1", NanLegacy)
6338 .Case("mips2", NanLegacy)
6339 .Case("mips3", NanLegacy)
6340 .Case("mips4", NanLegacy)
6341 .Case("mips5", NanLegacy)
6342 .Case("mips32", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00006343 .Case("mips32r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006344 .Case("mips32r3", NanLegacy | Nan2008)
6345 .Case("mips32r5", NanLegacy | Nan2008)
6346 .Case("mips32r6", Nan2008)
6347 .Case("mips64", NanLegacy)
Daniel Sanderse0395a72015-09-24 10:22:17 +00006348 .Case("mips64r2", NanLegacy | Nan2008)
Petar Jovanovic1dbc3172015-04-14 12:49:08 +00006349 .Case("mips64r3", NanLegacy | Nan2008)
6350 .Case("mips64r5", NanLegacy | Nan2008)
6351 .Case("mips64r6", Nan2008)
6352 .Default(NanLegacy);
6353}
6354
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00006355bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
6356 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6357 return A && (A->getValue() == StringRef(Value));
6358}
6359
Simon Atanasyand95c67d2014-08-13 14:34:14 +00006360bool mips::isUCLibc(const ArgList &Args) {
6361 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
Rafael Espindolad3d657c2014-08-13 17:15:42 +00006362 return A && A->getOption().matches(options::OPT_muclibc);
Simon Atanasyand95c67d2014-08-13 14:34:14 +00006363}
6364
Daniel Sanders2bf13662014-07-10 14:40:57 +00006365bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006366 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
6367 return llvm::StringSwitch<bool>(NaNArg->getValue())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006368 .Case("2008", true)
6369 .Case("legacy", false)
6370 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006371
6372 // NaN2008 is the default for MIPS32r6/MIPS64r6.
Daniel Sanders2bf13662014-07-10 14:40:57 +00006373 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006374 .Cases("mips32r6", "mips64r6", true)
6375 .Default(false);
Daniel Sanders3b92c5b2014-06-24 15:04:16 +00006376
6377 return false;
6378}
6379
Daniel Sanders379d44b2014-07-16 11:52:23 +00006380bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00006381 StringRef ABIName, mips::FloatABI FloatABI) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00006382 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
Daniel Sanders492beb12014-07-18 15:05:38 +00006383 Triple.getVendor() != llvm::Triple::MipsTechnologies)
Daniel Sanders379d44b2014-07-16 11:52:23 +00006384 return false;
6385
6386 if (ABIName != "32")
6387 return false;
6388
Toma Tabacu94ea6862015-06-16 13:54:13 +00006389 // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is
6390 // present.
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00006391 if (FloatABI == mips::FloatABI::Soft)
Toma Tabacu94ea6862015-06-16 13:54:13 +00006392 return false;
6393
Daniel Sanders379d44b2014-07-16 11:52:23 +00006394 return llvm::StringSwitch<bool>(CPUName)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006395 .Cases("mips2", "mips3", "mips4", "mips5", true)
6396 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
6397 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
6398 .Default(false);
Daniel Sanders379d44b2014-07-16 11:52:23 +00006399}
6400
Toma Tabacu94ea6862015-06-16 13:54:13 +00006401bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple,
6402 StringRef CPUName, StringRef ABIName,
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00006403 mips::FloatABI FloatABI) {
Toma Tabacu94ea6862015-06-16 13:54:13 +00006404 bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
6405
6406 // FPXX shouldn't be used if -msingle-float is present.
6407 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
6408 options::OPT_mdouble_float))
6409 if (A->getOption().matches(options::OPT_msingle_float))
6410 UseFPXX = false;
6411
6412 return UseFPXX;
6413}
6414
Tim Northover157d9112014-01-16 08:48:16 +00006415llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
Rafael Espindoladcbf6982012-10-31 18:51:07 +00006416 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
6417 // archs which Darwin doesn't use.
6418
6419 // The matching this routine does is fairly pointless, since it is neither the
6420 // complete architecture list, nor a reasonable subset. The problem is that
6421 // historically the driver driver accepts this and also ties its -march=
6422 // handling to the architecture name, so we need to be careful before removing
6423 // support for it.
6424
6425 // This code must be kept in sync with Clang's Darwin specific argument
6426 // translation.
6427
6428 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006429 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
6430 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
6431 .Case("ppc64", llvm::Triple::ppc64)
6432 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
6433 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
6434 llvm::Triple::x86)
6435 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
6436 // This is derived from the driver driver.
6437 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
6438 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
6439 .Cases("armv7s", "xscale", llvm::Triple::arm)
6440 .Case("arm64", llvm::Triple::aarch64)
6441 .Case("r600", llvm::Triple::r600)
6442 .Case("amdgcn", llvm::Triple::amdgcn)
6443 .Case("nvptx", llvm::Triple::nvptx)
6444 .Case("nvptx64", llvm::Triple::nvptx64)
6445 .Case("amdil", llvm::Triple::amdil)
6446 .Case("spir", llvm::Triple::spir)
6447 .Default(llvm::Triple::UnknownArch);
Rafael Espindoladcbf6982012-10-31 18:51:07 +00006448}
Tony Linthicum76329bf2011-12-12 21:14:55 +00006449
Tim Northover157d9112014-01-16 08:48:16 +00006450void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00006451 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
Tim Northover157d9112014-01-16 08:48:16 +00006452 T.setArch(Arch);
6453
6454 if (Str == "x86_64h")
6455 T.setArchName(Str);
6456 else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
6457 T.setOS(llvm::Triple::UnknownOS);
Saleem Abdulrasool29b82b62014-03-06 20:47:19 +00006458 T.setObjectFormat(llvm::Triple::MachO);
Tim Northover157d9112014-01-16 08:48:16 +00006459 }
6460}
6461
Bob Wilsondecc03e2012-11-23 06:14:39 +00006462const char *Clang::getBaseInputName(const ArgList &Args,
Artem Belevichba558952015-05-06 18:20:23 +00006463 const InputInfo &Input) {
6464 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006465}
6466
Bob Wilsondecc03e2012-11-23 06:14:39 +00006467const char *Clang::getBaseInputStem(const ArgList &Args,
6468 const InputInfoList &Inputs) {
Artem Belevichba558952015-05-06 18:20:23 +00006469 const char *Str = getBaseInputName(Args, Inputs[0]);
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006470
Chris Lattner906bb902011-01-16 08:14:11 +00006471 if (const char *End = strrchr(Str, '.'))
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00006472 return Args.MakeArgString(std::string(Str, End));
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006473
6474 return Str;
6475}
6476
Bob Wilsondecc03e2012-11-23 06:14:39 +00006477const char *Clang::getDependencyFileName(const ArgList &Args,
6478 const InputInfoList &Inputs) {
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006479 // FIXME: Think about this more.
6480 std::string Res;
6481
6482 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00006483 std::string Str(OutputOpt->getValue());
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006484 Res = Str.substr(0, Str.rfind('.'));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00006485 } else {
Bob Wilsondecc03e2012-11-23 06:14:39 +00006486 Res = getBaseInputStem(Args, Inputs);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00006487 }
Daniel Dunbar1c28f1e2009-09-09 22:32:48 +00006488 return Args.MakeArgString(Res + ".d");
Daniel Dunbarafec1f52009-03-29 18:40:18 +00006489}
6490
Douglas Katzman95354292015-06-23 20:42:09 +00006491void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6492 const InputInfo &Output,
6493 const InputInfoList &Inputs,
6494 const ArgList &Args,
6495 const char *LinkingOutput) const {
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006496 const ToolChain &ToolChain = getToolChain();
6497 const Driver &D = ToolChain.getDriver();
6498 ArgStringList CmdArgs;
6499
6500 // Silence warning for "clang -g foo.o -o foo"
6501 Args.ClaimAllArgs(options::OPT_g_Group);
6502 // and "clang -emit-llvm foo.o -o foo"
6503 Args.ClaimAllArgs(options::OPT_emit_llvm);
6504 // and for "clang -w foo.o -o foo". Other warning options are already
6505 // handled somewhere else.
6506 Args.ClaimAllArgs(options::OPT_w);
6507
6508 if (!D.SysRoot.empty())
6509 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6510
6511 // CloudABI only supports static linkage.
6512 CmdArgs.push_back("-Bstatic");
6513 CmdArgs.push_back("--eh-frame-hdr");
6514 CmdArgs.push_back("--gc-sections");
6515
6516 if (Output.isFilename()) {
6517 CmdArgs.push_back("-o");
6518 CmdArgs.push_back(Output.getFilename());
6519 } else {
6520 assert(Output.isNothing() && "Invalid output.");
6521 }
6522
6523 if (!Args.hasArg(options::OPT_nostdlib) &&
6524 !Args.hasArg(options::OPT_nostartfiles)) {
6525 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
6526 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
6527 }
6528
6529 Args.AddAllArgs(CmdArgs, options::OPT_L);
6530 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
6531 for (const auto &Path : Paths)
6532 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006533 Args.AddAllArgs(CmdArgs,
6534 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6535 options::OPT_t, options::OPT_Z_Flag, options::OPT_r});
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006536
Teresa Johnson945bc502015-10-15 20:35:53 +00006537 if (D.isUsingLTO())
6538 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006539
6540 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6541
6542 if (!Args.hasArg(options::OPT_nostdlib) &&
6543 !Args.hasArg(options::OPT_nodefaultlibs)) {
6544 if (D.CCCIsCXX())
6545 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6546 CmdArgs.push_back("-lc");
6547 CmdArgs.push_back("-lcompiler_rt");
6548 }
6549
6550 if (!Args.hasArg(options::OPT_nostdlib) &&
6551 !Args.hasArg(options::OPT_nostartfiles))
6552 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6553
6554 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00006555 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Ed Schouten3c3e58c2015-03-26 11:13:44 +00006556}
6557
Douglas Katzman95354292015-06-23 20:42:09 +00006558void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6559 const InputInfo &Output,
6560 const InputInfoList &Inputs,
6561 const ArgList &Args,
6562 const char *LinkingOutput) const {
Daniel Dunbarbe220842009-03-20 16:06:39 +00006563 ArgStringList CmdArgs;
6564
6565 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6566 const InputInfo &Input = Inputs[0];
6567
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006568 // Determine the original source input.
6569 const Action *SourceAction = &JA;
6570 while (SourceAction->getKind() != Action::InputClass) {
6571 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6572 SourceAction = SourceAction->getInputs()[0];
6573 }
6574
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006575 // If -fno_integrated_as is used add -Q to the darwin assember driver to make
Kevin Enderby319baa42013-11-18 23:30:29 +00006576 // sure it runs its system assembler not clang's integrated assembler.
David Fang073a7c92013-12-10 22:51:25 +00006577 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
6578 // FIXME: at run-time detect assembler capabilities or rely on version
6579 // information forwarded by -target-assembler-version (future)
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +00006580 if (Args.hasArg(options::OPT_fno_integrated_as)) {
David Fangadcdde02013-12-10 23:13:11 +00006581 const llvm::Triple &T(getToolChain().getTriple());
6582 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
David Fang073a7c92013-12-10 22:51:25 +00006583 CmdArgs.push_back("-Q");
6584 }
Kevin Enderby319baa42013-11-18 23:30:29 +00006585
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006586 // Forward -g, assuming we are dealing with an actual assembly file.
Eric Christopher84fbdb42011-08-19 00:30:14 +00006587 if (SourceAction->getType() == types::TY_Asm ||
Daniel Dunbardc8355e2011-04-12 23:59:20 +00006588 SourceAction->getType() == types::TY_PP_Asm) {
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006589 if (Args.hasArg(options::OPT_gstabs))
6590 CmdArgs.push_back("--gstabs");
6591 else if (Args.hasArg(options::OPT_g_Group))
Bob Wilson126c4912011-11-02 05:10:45 +00006592 CmdArgs.push_back("-g");
Daniel Dunbar5c9c1182009-04-01 00:27:44 +00006593 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006594
Daniel Dunbarbe220842009-03-20 16:06:39 +00006595 // Derived from asm spec.
Tim Northover157d9112014-01-16 08:48:16 +00006596 AddMachOArch(Args, CmdArgs);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006597
Daniel Dunbar6d484762010-07-22 01:47:22 +00006598 // Use -force_cpusubtype_ALL on x86 by default.
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006599 if (getToolChain().getArch() == llvm::Triple::x86 ||
6600 getToolChain().getArch() == llvm::Triple::x86_64 ||
Daniel Dunbar3571dd92009-09-09 18:36:27 +00006601 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6602 CmdArgs.push_back("-force_cpusubtype_ALL");
6603
Eli Benderskyd4a6aec2013-07-24 22:20:49 +00006604 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006605 (((Args.hasArg(options::OPT_mkernel) ||
Eric Christopher248357f2013-02-21 22:35:01 +00006606 Args.hasArg(options::OPT_fapple_kext)) &&
Tim Northover157d9112014-01-16 08:48:16 +00006607 getMachOToolChain().isKernelStatic()) ||
Daniel Dunbarbd847cc2012-10-15 22:23:53 +00006608 Args.hasArg(options::OPT_static)))
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006609 CmdArgs.push_back("-static");
6610
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006611 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarbe220842009-03-20 16:06:39 +00006612
6613 assert(Output.isFilename() && "Unexpected lipo output.");
6614 CmdArgs.push_back("-o");
6615 CmdArgs.push_back(Output.getFilename());
6616
Daniel Dunbarb440f562010-08-02 02:38:21 +00006617 assert(Input.isFilename() && "Invalid input.");
6618 CmdArgs.push_back(Input.getFilename());
Daniel Dunbarbe220842009-03-20 16:06:39 +00006619
6620 // asm_final spec is empty.
6621
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006622 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00006623 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarbe220842009-03-20 16:06:39 +00006624}
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006625
Tim Northover157d9112014-01-16 08:48:16 +00006626void darwin::MachOTool::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00006627
Tim Northover157d9112014-01-16 08:48:16 +00006628void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6629 ArgStringList &CmdArgs) const {
6630 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006631
Daniel Dunbarc1964212009-03-26 16:23:12 +00006632 // Derived from darwin_arch spec.
6633 CmdArgs.push_back("-arch");
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006634 CmdArgs.push_back(Args.MakeArgString(ArchName));
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006635
Daniel Dunbardcc3b652010-01-22 02:04:58 +00006636 // FIXME: Is this needed anymore?
6637 if (ArchName == "arm")
Daniel Dunbar91dbfd62009-09-04 18:35:31 +00006638 CmdArgs.push_back("-force_cpusubtype_ALL");
Daniel Dunbarc1964212009-03-26 16:23:12 +00006639}
6640
Douglas Katzman95354292015-06-23 20:42:09 +00006641bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
Bill Wendling3b2000f2012-10-02 18:02:50 +00006642 // We only need to generate a temp path for LTO if we aren't compiling object
6643 // files. When compiling source files, we run 'dsymutil' after linking. We
6644 // don't run 'dsymutil' when compiling object files.
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006645 for (const auto &Input : Inputs)
6646 if (Input.getType() != types::TY_Object)
Bill Wendling3b2000f2012-10-02 18:02:50 +00006647 return true;
6648
6649 return false;
6650}
6651
Douglas Katzman95354292015-06-23 20:42:09 +00006652void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
6653 ArgStringList &CmdArgs,
6654 const InputInfoList &Inputs) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00006655 const Driver &D = getToolChain().getDriver();
Tim Northover157d9112014-01-16 08:48:16 +00006656 const toolchains::MachO &MachOTC = getMachOToolChain();
Daniel Dunbarc1964212009-03-26 16:23:12 +00006657
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006658 unsigned Version[3] = {0, 0, 0};
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006659 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6660 bool HadExtra;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006661 if (!Driver::GetReleaseVersion(A->getValue(), Version[0], Version[1],
6662 Version[2], HadExtra) ||
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006663 HadExtra)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006664 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006665 }
6666
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006667 // Newer linkers support -demangle. Pass it if supported and not disabled by
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006668 // the user.
Bob Wilson5a4f3ea2014-01-14 01:56:31 +00006669 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6670 CmdArgs.push_back("-demangle");
Daniel Dunbarcacb0e22010-08-11 23:07:50 +00006671
Bob Wilson3d27dad2013-08-02 22:25:34 +00006672 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6673 CmdArgs.push_back("-export_dynamic");
6674
Bob Wilsonb111ec92015-03-02 19:01:14 +00006675 // If we are using App Extension restrictions, pass a flag to the linker
6676 // telling it that the compiled code has been audited.
6677 if (Args.hasFlag(options::OPT_fapplication_extension,
6678 options::OPT_fno_application_extension, false))
6679 CmdArgs.push_back("-application_extension");
6680
Teresa Johnson945bc502015-10-15 20:35:53 +00006681 if (D.isUsingLTO()) {
Bruno Cardoso Lopesa5efe3a2015-10-02 15:10:33 +00006682 // If we are using LTO, then automatically create a temporary file path for
6683 // the linker to use, so that it's lifetime will extend past a possible
6684 // dsymutil step.
6685 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
6686 const char *TmpPath = C.getArgs().MakeArgString(
6687 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
6688 C.addTempFile(TmpPath);
6689 CmdArgs.push_back("-object_path_lto");
6690 CmdArgs.push_back(TmpPath);
6691 }
6692
6693 // Use -lto_library option to specify the libLTO.dylib path. Try to find
6694 // it in clang installed libraries. If not found, the option is not used
6695 // and 'ld' will use its default mechanism to search for libLTO.dylib.
6696 if (Version[0] >= 133) {
6697 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
6698 StringRef P = llvm::sys::path::parent_path(D.getInstalledDir());
6699 SmallString<128> LibLTOPath(P);
6700 llvm::sys::path::append(LibLTOPath, "lib");
6701 llvm::sys::path::append(LibLTOPath, "libLTO.dylib");
6702 if (llvm::sys::fs::exists(LibLTOPath)) {
6703 CmdArgs.push_back("-lto_library");
6704 CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));
6705 } else {
6706 D.Diag(diag::warn_drv_lto_libpath);
6707 }
6708 }
Daniel Dunbaref889c72011-06-21 20:55:11 +00006709 }
6710
Daniel Dunbarc1964212009-03-26 16:23:12 +00006711 // Derived from the "link" spec.
6712 Args.AddAllArgs(CmdArgs, options::OPT_static);
6713 if (!Args.hasArg(options::OPT_static))
6714 CmdArgs.push_back("-dynamic");
6715 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6716 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6717 // here. How do we wish to handle such things?
6718 }
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006719
Daniel Dunbarc1964212009-03-26 16:23:12 +00006720 if (!Args.hasArg(options::OPT_dynamiclib)) {
Tim Northover157d9112014-01-16 08:48:16 +00006721 AddMachOArch(Args, CmdArgs);
Daniel Dunbara48823f2010-01-22 02:04:52 +00006722 // FIXME: Why do this only on this path?
Daniel Dunbar93d7acf2010-01-22 03:37:33 +00006723 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006724
6725 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6726 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6727 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6728
6729 Arg *A;
6730 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6731 (A = Args.getLastArg(options::OPT_current__version)) ||
6732 (A = Args.getLastArg(options::OPT_install__name)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006733 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
6734 << "-dynamiclib";
Daniel Dunbarc1964212009-03-26 16:23:12 +00006735
6736 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6737 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6738 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6739 } else {
6740 CmdArgs.push_back("-dylib");
6741
6742 Arg *A;
6743 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6744 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6745 (A = Args.getLastArg(options::OPT_client__name)) ||
6746 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6747 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6748 (A = Args.getLastArg(options::OPT_private__bundle)))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006749 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
6750 << "-dynamiclib";
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006751
Daniel Dunbarc1964212009-03-26 16:23:12 +00006752 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6753 "-dylib_compatibility_version");
6754 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6755 "-dylib_current_version");
6756
Tim Northover157d9112014-01-16 08:48:16 +00006757 AddMachOArch(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006758
6759 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6760 "-dylib_install_name");
6761 }
6762
6763 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6764 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6765 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
Tim Northover157d9112014-01-16 08:48:16 +00006766 if (MachOTC.isTargetIOSBased())
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006767 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006768 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6769 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6770 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6771 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6772 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6773 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
Daniel Dunbar044a3902011-06-28 20:16:02 +00006774 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006775 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6776 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6777 Args.AddAllArgs(CmdArgs, options::OPT_init);
6778
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006779 // Add the deployment target.
Tim Northover157d9112014-01-16 08:48:16 +00006780 MachOTC.addMinVersionArgs(Args, CmdArgs);
Daniel Dunbarc44d3132011-04-28 21:23:41 +00006781
Daniel Dunbarc1964212009-03-26 16:23:12 +00006782 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6783 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6784 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6785 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6786 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006787
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006788 if (const Arg *A =
6789 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6790 options::OPT_fno_pie, options::OPT_fno_PIE)) {
Daniel Dunbaraf68a882010-07-13 23:31:40 +00006791 if (A->getOption().matches(options::OPT_fpie) ||
6792 A->getOption().matches(options::OPT_fPIE))
6793 CmdArgs.push_back("-pie");
6794 else
6795 CmdArgs.push_back("-no_pie");
6796 }
Daniel Dunbarc1964212009-03-26 16:23:12 +00006797
6798 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6799 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6800 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6801 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6802 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6803 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6804 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6805 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6806 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6807 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6808 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6809 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6810 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6811 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6812 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6813 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006814
Daniel Dunbar84384642011-05-02 21:03:47 +00006815 // Give --sysroot= preference, over the Apple specific behavior to also use
6816 // --isysroot as the syslibroot.
Sebastian Pop980920a2012-04-16 04:16:43 +00006817 StringRef sysroot = C.getSysRoot();
6818 if (sysroot != "") {
Daniel Dunbar84384642011-05-02 21:03:47 +00006819 CmdArgs.push_back("-syslibroot");
Sebastian Pop980920a2012-04-16 04:16:43 +00006820 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
Daniel Dunbar84384642011-05-02 21:03:47 +00006821 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6822 CmdArgs.push_back("-syslibroot");
Richard Smithbd55daf2012-11-01 04:30:05 +00006823 CmdArgs.push_back(A->getValue());
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006824 }
6825
Daniel Dunbarc1964212009-03-26 16:23:12 +00006826 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6827 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6828 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6829 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6830 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
Daniel Dunbar2b5f6812009-09-04 18:35:41 +00006831 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006832 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6833 Args.AddAllArgs(CmdArgs, options::OPT_y);
6834 Args.AddLastArg(CmdArgs, options::OPT_w);
6835 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6836 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6837 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6838 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6839 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6840 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6841 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6842 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6843 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6844 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6845 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6846 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6847}
6848
Douglas Katzman95354292015-06-23 20:42:09 +00006849void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6850 const InputInfo &Output,
6851 const InputInfoList &Inputs,
6852 const ArgList &Args,
6853 const char *LinkingOutput) const {
Daniel Dunbarc1964212009-03-26 16:23:12 +00006854 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
Daniel Dunbarc09988d2009-09-08 16:39:16 +00006855
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006856 // If the number of arguments surpasses the system limits, we will encode the
6857 // input files in a separate file, shortening the command line. To this end,
6858 // build a list of input file names that can be passed via a file with the
6859 // -filelist linker option.
6860 llvm::opt::ArgStringList InputFileList;
6861
Daniel Dunbarc1964212009-03-26 16:23:12 +00006862 // The logic here is derived from gcc's behavior; most of which
6863 // comes from specs (starting with link_command). Consult gcc for
6864 // more information.
Daniel Dunbarc1964212009-03-26 16:23:12 +00006865 ArgStringList CmdArgs;
6866
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006867 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6868 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6869 options::OPT_ccc_arcmt_migrate)) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00006870 for (const auto &Arg : Args)
6871 Arg->claim();
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006872 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006873 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006874 CmdArgs.push_back(Output.getFilename());
Justin Bognerd3371d82015-07-17 03:35:54 +00006875 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
Argyrios Kyrtzidis741fab12011-10-07 22:58:08 +00006876 return;
6877 }
6878
Daniel Dunbarc1964212009-03-26 16:23:12 +00006879 // I'm not sure why this particular decomposition exists in gcc, but
6880 // we follow suite for ease of comparison.
Bill Wendling3b2000f2012-10-02 18:02:50 +00006881 AddLinkArgs(C, Args, CmdArgs, Inputs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006882
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00006883 // It seems that the 'e' option is completely ignored for dynamic executables
6884 // (the default), and with static executables, the last one wins, as expected.
6885 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
6886 options::OPT_Z_Flag, options::OPT_u_Group,
6887 options::OPT_e, options::OPT_r});
Daniel Dunbarc1964212009-03-26 16:23:12 +00006888
Daniel Dunbar767bbab2010-10-18 22:08:36 +00006889 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6890 // members of static archive libraries which implement Objective-C classes or
6891 // categories.
6892 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6893 CmdArgs.push_back("-ObjC");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00006894
Daniel Dunbarc1964212009-03-26 16:23:12 +00006895 CmdArgs.push_back("-o");
6896 CmdArgs.push_back(Output.getFilename());
6897
Chad Rosier06fd3c62012-05-16 23:45:12 +00006898 if (!Args.hasArg(options::OPT_nostdlib) &&
Tim Northover157d9112014-01-16 08:48:16 +00006899 !Args.hasArg(options::OPT_nostartfiles))
6900 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006901
Peter Collingbournec4122c12015-06-15 21:08:13 +00006902 // SafeStack requires its own runtime libraries
6903 // These libraries should be linked first, to make sure the
6904 // __safestack_init constructor executes before everything else
6905 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
6906 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
6907 "libclang_rt.safestack_osx.a",
6908 /*AlwaysLink=*/true);
6909 }
6910
Daniel Dunbarc1964212009-03-26 16:23:12 +00006911 Args.AddAllArgs(CmdArgs, options::OPT_L);
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006912
Douglas Gregor9295df02012-05-15 21:00:27 +00006913 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006914 // Build the input file for -filelist (list of linker input files) in case we
6915 // need it later
6916 for (const auto &II : Inputs) {
6917 if (!II.isFilename()) {
6918 // This is a linker input argument.
6919 // We cannot mix input arguments and file names in a -filelist input, thus
6920 // we prematurely stop our list (remaining files shall be passed as
6921 // arguments).
6922 if (InputFileList.size() > 0)
6923 break;
6924
6925 continue;
6926 }
6927
6928 InputFileList.push_back(II.getFilename());
6929 }
6930
Joerg Sonnenberger5c3f9d52015-09-23 20:07:56 +00006931 if (!Args.hasArg(options::OPT_nostdlib) &&
6932 !Args.hasArg(options::OPT_nodefaultlibs))
6933 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
6934
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006935 if (isObjCRuntimeLinked(Args) && !Args.hasArg(options::OPT_nostdlib) &&
Bob Wilson16d93952012-05-15 18:57:39 +00006936 !Args.hasArg(options::OPT_nodefaultlibs)) {
Tim Northover157d9112014-01-16 08:48:16 +00006937 // We use arclite library for both ARC and subscripting support.
6938 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6939
Bob Wilson7dda0cd2012-04-21 00:21:42 +00006940 CmdArgs.push_back("-framework");
6941 CmdArgs.push_back("Foundation");
Ted Kremeneke65b0862012-03-06 20:05:56 +00006942 // Link libobj.
6943 CmdArgs.push_back("-lobjc");
John McCall24fc0de2011-07-06 00:26:06 +00006944 }
John McCall31168b02011-06-15 23:02:42 +00006945
Daniel Dunbarc1964212009-03-26 16:23:12 +00006946 if (LinkingOutput) {
6947 CmdArgs.push_back("-arch_multiple");
6948 CmdArgs.push_back("-final_output");
6949 CmdArgs.push_back(LinkingOutput);
6950 }
6951
Daniel Dunbarc1964212009-03-26 16:23:12 +00006952 if (Args.hasArg(options::OPT_fnested_functions))
6953 CmdArgs.push_back("-allow_stack_execute");
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006954
Justin Bognerc7701242015-05-12 05:44:36 +00006955 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6956
Daniel Dunbarc1964212009-03-26 16:23:12 +00006957 if (!Args.hasArg(options::OPT_nostdlib) &&
6958 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00006959 if (getToolChain().getDriver().CCCIsCXX())
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00006960 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Daniel Dunbarad0f62b2009-04-08 06:06:21 +00006961
Daniel Dunbarc1964212009-03-26 16:23:12 +00006962 // link_ssp spec is empty.
6963
Daniel Dunbar26d482a2009-09-18 08:15:03 +00006964 // Let the tool chain choose which runtime library to link.
Tim Northover157d9112014-01-16 08:48:16 +00006965 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
Daniel Dunbarc1964212009-03-26 16:23:12 +00006966 }
6967
Chad Rosier06fd3c62012-05-16 23:45:12 +00006968 if (!Args.hasArg(options::OPT_nostdlib) &&
Daniel Dunbarc1964212009-03-26 16:23:12 +00006969 !Args.hasArg(options::OPT_nostartfiles)) {
6970 // endfile_spec is empty.
6971 }
6972
6973 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6974 Args.AddAllArgs(CmdArgs, options::OPT_F);
6975
Steven Wu3ffb61b2015-02-06 18:08:29 +00006976 // -iframework should be forwarded as -F.
Sean Silva14facf32015-06-09 01:57:17 +00006977 for (const Arg *A : Args.filtered(options::OPT_iframework))
6978 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
Steven Wu3ffb61b2015-02-06 18:08:29 +00006979
Michael Zolotukhind0cf6c82015-03-17 22:13:05 +00006980 if (!Args.hasArg(options::OPT_nostdlib) &&
6981 !Args.hasArg(options::OPT_nodefaultlibs)) {
6982 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6983 if (A->getValue() == StringRef("Accelerate")) {
6984 CmdArgs.push_back("-framework");
6985 CmdArgs.push_back("Accelerate");
6986 }
6987 }
6988 }
6989
Douglas Katzmana67e50c2015-06-26 15:47:46 +00006990 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006991 std::unique_ptr<Command> Cmd =
Justin Bognerd3371d82015-07-17 03:35:54 +00006992 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
Reid Kleckner0290c9c2014-09-15 17:45:39 +00006993 Cmd->setInputFileList(std::move(InputFileList));
6994 C.addCommand(std::move(Cmd));
Daniel Dunbarc1964212009-03-26 16:23:12 +00006995}
6996
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00006997void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00006998 const InputInfo &Output,
Daniel Dunbard067f7f2009-04-08 23:54:23 +00006999 const InputInfoList &Inputs,
7000 const ArgList &Args,
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007001 const char *LinkingOutput) const {
7002 ArgStringList CmdArgs;
7003
7004 CmdArgs.push_back("-create");
7005 assert(Output.isFilename() && "Unexpected lipo output.");
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007006
7007 CmdArgs.push_back("-output");
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007008 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar06686ab2009-03-24 00:24:37 +00007009
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007010 for (const auto &II : Inputs) {
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007011 assert(II.isFilename() && "Unexpected lipo input.");
7012 CmdArgs.push_back(II.getFilename());
7013 }
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007014
7015 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007016 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar64ed5e32009-03-20 00:52:38 +00007017}
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007018
Daniel Dunbar88299622010-06-04 18:28:36 +00007019void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00007020 const InputInfo &Output,
Daniel Dunbar88299622010-06-04 18:28:36 +00007021 const InputInfoList &Inputs,
7022 const ArgList &Args,
7023 const char *LinkingOutput) const {
7024 ArgStringList CmdArgs;
7025
Daniel Dunbareb86b042011-05-09 17:23:16 +00007026 CmdArgs.push_back("-o");
7027 CmdArgs.push_back(Output.getFilename());
7028
Daniel Dunbar88299622010-06-04 18:28:36 +00007029 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7030 const InputInfo &Input = Inputs[0];
7031 assert(Input.isFilename() && "Unexpected dsymutil input.");
7032 CmdArgs.push_back(Input.getFilename());
7033
Daniel Dunbar88299622010-06-04 18:28:36 +00007034 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007035 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007036 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar88299622010-06-04 18:28:36 +00007037}
7038
Eric Christopher551ef452011-08-23 17:56:55 +00007039void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
Eric Christopher45f2e712012-12-18 00:31:10 +00007040 const InputInfo &Output,
7041 const InputInfoList &Inputs,
7042 const ArgList &Args,
7043 const char *LinkingOutput) const {
Eric Christopher551ef452011-08-23 17:56:55 +00007044 ArgStringList CmdArgs;
7045 CmdArgs.push_back("--verify");
Eric Christopher36222212012-02-06 19:13:09 +00007046 CmdArgs.push_back("--debug-info");
7047 CmdArgs.push_back("--eh-frame");
Eric Christopher65c05fa2012-02-06 19:43:51 +00007048 CmdArgs.push_back("--quiet");
Eric Christopher551ef452011-08-23 17:56:55 +00007049
7050 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
7051 const InputInfo &Input = Inputs[0];
7052 assert(Input.isFilename() && "Unexpected verify input");
7053
7054 // Grabbing the output of the earlier dsymutil run.
7055 CmdArgs.push_back(Input.getFilename());
7056
7057 const char *Exec =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007058 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007059 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher551ef452011-08-23 17:56:55 +00007060}
7061
Douglas Katzman95354292015-06-23 20:42:09 +00007062void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
David Chisnallf571cde2012-02-15 13:39:01 +00007063 const InputInfo &Output,
7064 const InputInfoList &Inputs,
7065 const ArgList &Args,
7066 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007067 claimNoWarnArgs(Args);
David Chisnallf571cde2012-02-15 13:39:01 +00007068 ArgStringList CmdArgs;
7069
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007070 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
David Chisnallf571cde2012-02-15 13:39:01 +00007071
7072 CmdArgs.push_back("-o");
7073 CmdArgs.push_back(Output.getFilename());
7074
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007075 for (const auto &II : Inputs)
David Chisnallf571cde2012-02-15 13:39:01 +00007076 CmdArgs.push_back(II.getFilename());
David Chisnallf571cde2012-02-15 13:39:01 +00007077
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007078 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007079 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007080}
7081
Douglas Katzman95354292015-06-23 20:42:09 +00007082void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7083 const InputInfo &Output,
7084 const InputInfoList &Inputs,
7085 const ArgList &Args,
7086 const char *LinkingOutput) const {
David Chisnallf571cde2012-02-15 13:39:01 +00007087 ArgStringList CmdArgs;
7088
David Chisnall272a0712012-02-29 15:06:12 +00007089 // Demangle C++ names in errors
7090 CmdArgs.push_back("-C");
7091
David Chisnallf571cde2012-02-15 13:39:01 +00007092 if ((!Args.hasArg(options::OPT_nostdlib)) &&
7093 (!Args.hasArg(options::OPT_shared))) {
7094 CmdArgs.push_back("-e");
7095 CmdArgs.push_back("_start");
7096 }
7097
7098 if (Args.hasArg(options::OPT_static)) {
7099 CmdArgs.push_back("-Bstatic");
7100 CmdArgs.push_back("-dn");
7101 } else {
7102 CmdArgs.push_back("-Bdynamic");
7103 if (Args.hasArg(options::OPT_shared)) {
7104 CmdArgs.push_back("-shared");
7105 } else {
7106 CmdArgs.push_back("--dynamic-linker");
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007107 CmdArgs.push_back(
7108 Args.MakeArgString(getToolChain().GetFilePath("ld.so.1")));
David Chisnallf571cde2012-02-15 13:39:01 +00007109 }
7110 }
7111
7112 if (Output.isFilename()) {
7113 CmdArgs.push_back("-o");
7114 CmdArgs.push_back(Output.getFilename());
7115 } else {
7116 assert(Output.isNothing() && "Invalid output.");
7117 }
7118
7119 if (!Args.hasArg(options::OPT_nostdlib) &&
7120 !Args.hasArg(options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007121 if (!Args.hasArg(options::OPT_shared))
7122 CmdArgs.push_back(
7123 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7124
7125 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7126 CmdArgs.push_back(
7127 Args.MakeArgString(getToolChain().GetFilePath("values-Xa.o")));
7128 CmdArgs.push_back(
7129 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007130 }
7131
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007132 const ToolChain::path_list &Paths = getToolChain().getFilePaths();
7133 for (const auto &Path : Paths)
7134 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
David Chisnallf571cde2012-02-15 13:39:01 +00007135
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007136 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7137 options::OPT_e, options::OPT_r});
David Chisnallf571cde2012-02-15 13:39:01 +00007138
7139 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7140
7141 if (!Args.hasArg(options::OPT_nostdlib) &&
7142 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007143 if (getToolChain().getDriver().CCCIsCXX())
David Chisnall3d127c72012-04-10 11:49:50 +00007144 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
David Chisnall1026fb02012-02-15 18:24:31 +00007145 CmdArgs.push_back("-lgcc_s");
Rafael Espindola8d4d9d2f2015-09-14 19:30:53 +00007146 CmdArgs.push_back("-lc");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007147 if (!Args.hasArg(options::OPT_shared)) {
7148 CmdArgs.push_back("-lgcc");
David Chisnallc73fb892012-02-28 20:06:45 +00007149 CmdArgs.push_back("-lm");
David Chisnall0c52c0f2012-02-28 17:10:04 +00007150 }
David Chisnallf571cde2012-02-15 13:39:01 +00007151 }
7152
7153 if (!Args.hasArg(options::OPT_nostdlib) &&
7154 !Args.hasArg(options::OPT_nostartfiles)) {
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007155 CmdArgs.push_back(
7156 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007157 }
Rafael Espindolac53c5b12015-08-31 19:17:51 +00007158 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
David Chisnallf571cde2012-02-15 13:39:01 +00007159
Xinliang David Li69306c02015-10-22 06:15:31 +00007160 getToolChain().addProfileRTLibs(Args, CmdArgs);
David Chisnallf571cde2012-02-15 13:39:01 +00007161
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007162 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007163 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
David Chisnallf571cde2012-02-15 13:39:01 +00007164}
7165
Douglas Katzman95354292015-06-23 20:42:09 +00007166void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7167 const InputInfo &Output,
7168 const InputInfoList &Inputs,
7169 const ArgList &Args,
7170 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007171 claimNoWarnArgs(Args);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007172 ArgStringList CmdArgs;
7173
Rafael Espindolacc126272014-02-28 01:55:21 +00007174 switch (getToolChain().getArch()) {
7175 case llvm::Triple::x86:
7176 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
7177 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007178 CmdArgs.push_back("--32");
Rafael Espindolacc126272014-02-28 01:55:21 +00007179 break;
7180
7181 case llvm::Triple::ppc:
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007182 CmdArgs.push_back("-mppc");
7183 CmdArgs.push_back("-many");
Rafael Espindolacc126272014-02-28 01:55:21 +00007184 break;
7185
7186 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007187 case llvm::Triple::sparcel: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007188 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007189 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7190 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7191 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007192 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007193 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007194
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007195 case llvm::Triple::sparcv9: {
Rafael Espindolacc126272014-02-28 01:55:21 +00007196 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007197 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7198 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
7199 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007200 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007201 }
Rafael Espindolacc126272014-02-28 01:55:21 +00007202
7203 case llvm::Triple::mips64:
7204 case llvm::Triple::mips64el: {
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007205 StringRef CPUName;
7206 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007207 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007208
7209 CmdArgs.push_back("-mabi");
7210 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7211
7212 if (getToolChain().getArch() == llvm::Triple::mips64)
7213 CmdArgs.push_back("-EB");
7214 else
7215 CmdArgs.push_back("-EL");
7216
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007217 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Rafael Espindolacc126272014-02-28 01:55:21 +00007218 break;
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007219 }
7220
Rafael Espindolacc126272014-02-28 01:55:21 +00007221 default:
7222 break;
7223 }
7224
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007225 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007226
7227 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007228 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007229
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007230 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007231 CmdArgs.push_back(II.getFilename());
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007232
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007233 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007234 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007235}
7236
Douglas Katzman95354292015-06-23 20:42:09 +00007237void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7238 const InputInfo &Output,
7239 const InputInfoList &Inputs,
7240 const ArgList &Args,
7241 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00007242 const Driver &D = getToolChain().getDriver();
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007243 ArgStringList CmdArgs;
7244
Rafael Espindolaaadd30e2012-12-31 22:41:36 +00007245 // Silence warning for "clang -g foo.o -o foo"
7246 Args.ClaimAllArgs(options::OPT_g_Group);
7247 // and "clang -emit-llvm foo.o -o foo"
7248 Args.ClaimAllArgs(options::OPT_emit_llvm);
7249 // and for "clang -w foo.o -o foo". Other warning options are already
7250 // handled somewhere else.
7251 Args.ClaimAllArgs(options::OPT_w);
7252
Joerg Sonnenbergeree3b2da2013-12-07 00:57:46 +00007253 if (getToolChain().getArch() == llvm::Triple::mips64)
7254 CmdArgs.push_back("-EB");
7255 else if (getToolChain().getArch() == llvm::Triple::mips64el)
7256 CmdArgs.push_back("-EL");
7257
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007258 if ((!Args.hasArg(options::OPT_nostdlib)) &&
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007259 (!Args.hasArg(options::OPT_shared))) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007260 CmdArgs.push_back("-e");
7261 CmdArgs.push_back("__start");
7262 }
7263
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007264 if (Args.hasArg(options::OPT_static)) {
7265 CmdArgs.push_back("-Bstatic");
7266 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007267 if (Args.hasArg(options::OPT_rdynamic))
7268 CmdArgs.push_back("-export-dynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007269 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007270 CmdArgs.push_back("-Bdynamic");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007271 if (Args.hasArg(options::OPT_shared)) {
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007272 CmdArgs.push_back("-shared");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007273 } else {
7274 CmdArgs.push_back("-dynamic-linker");
7275 CmdArgs.push_back("/usr/libexec/ld.so");
7276 }
7277 }
7278
Rafael Espindola044f7832013-06-05 04:28:55 +00007279 if (Args.hasArg(options::OPT_nopie))
7280 CmdArgs.push_back("-nopie");
7281
Daniel Dunbarb440f562010-08-02 02:38:21 +00007282 if (Output.isFilename()) {
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007283 CmdArgs.push_back("-o");
7284 CmdArgs.push_back(Output.getFilename());
7285 } else {
7286 assert(Output.isNothing() && "Invalid output.");
7287 }
7288
7289 if (!Args.hasArg(options::OPT_nostdlib) &&
7290 !Args.hasArg(options::OPT_nostartfiles)) {
7291 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007292 if (Args.hasArg(options::OPT_pg))
7293 CmdArgs.push_back(
7294 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman3715d1f2011-12-15 02:15:56 +00007295 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007296 CmdArgs.push_back(
7297 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7298 CmdArgs.push_back(
7299 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007300 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007301 CmdArgs.push_back(
7302 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007303 }
7304 }
7305
Edward O'Callaghan5c521462009-10-28 15:13:08 +00007306 std::string Triple = getToolChain().getTripleString();
7307 if (Triple.substr(0, 6) == "x86_64")
Daniel Dunbar1c7577c2009-11-04 06:24:38 +00007308 Triple.replace(0, 6, "amd64");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007309 CmdArgs.push_back(
7310 Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1"));
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007311
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007312 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7313 options::OPT_e, options::OPT_s, options::OPT_t,
7314 options::OPT_Z_Flag, options::OPT_r});
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007315
Daniel Dunbar54423b22010-09-17 00:24:54 +00007316 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007317
7318 if (!Args.hasArg(options::OPT_nostdlib) &&
7319 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007320 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00007321 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007322 if (Args.hasArg(options::OPT_pg))
Eli Friedman3715d1f2011-12-15 02:15:56 +00007323 CmdArgs.push_back("-lm_p");
7324 else
7325 CmdArgs.push_back("-lm");
Daniel Dunbarea3813f2010-08-01 23:13:54 +00007326 }
7327
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007328 // FIXME: For some reason GCC passes -lgcc before adding
7329 // the default system libraries. Just mimic this for now.
7330 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007331
Eric Christopher17674ec2012-09-13 06:32:34 +00007332 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007333 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7334 CmdArgs.push_back("-lpthread_p");
Eric Christopher17674ec2012-09-13 06:32:34 +00007335 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007336 CmdArgs.push_back("-lpthread");
Eric Christopher17674ec2012-09-13 06:32:34 +00007337 }
7338
Chandler Carruth45661652011-12-17 22:32:42 +00007339 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopher17674ec2012-09-13 06:32:34 +00007340 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007341 CmdArgs.push_back("-lc_p");
Eli Friedman3715d1f2011-12-15 02:15:56 +00007342 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007343 CmdArgs.push_back("-lc");
Chandler Carruth45661652011-12-17 22:32:42 +00007344 }
Eric Christopher17674ec2012-09-13 06:32:34 +00007345
Daniel Dunbara8888ac2009-08-03 01:28:59 +00007346 CmdArgs.push_back("-lgcc");
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007347 }
7348
7349 if (!Args.hasArg(options::OPT_nostdlib) &&
7350 !Args.hasArg(options::OPT_nostartfiles)) {
7351 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007352 CmdArgs.push_back(
7353 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007354 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007355 CmdArgs.push_back(
7356 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007357 }
7358
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007359 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007360 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar10de9e62009-06-29 20:52:51 +00007361}
Ed Schoutene33194b2009-04-02 19:13:12 +00007362
Douglas Katzman95354292015-06-23 20:42:09 +00007363void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7364 const InputInfo &Output,
7365 const InputInfoList &Inputs,
7366 const ArgList &Args,
7367 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007368 claimNoWarnArgs(Args);
Eli Friedman9fa28852012-08-08 23:57:20 +00007369 ArgStringList CmdArgs;
7370
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007371 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Eli Friedman9fa28852012-08-08 23:57:20 +00007372
7373 CmdArgs.push_back("-o");
7374 CmdArgs.push_back(Output.getFilename());
7375
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007376 for (const auto &II : Inputs)
Eli Friedman9fa28852012-08-08 23:57:20 +00007377 CmdArgs.push_back(II.getFilename());
Eli Friedman9fa28852012-08-08 23:57:20 +00007378
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007379 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007380 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007381}
7382
Douglas Katzman95354292015-06-23 20:42:09 +00007383void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7384 const InputInfo &Output,
7385 const InputInfoList &Inputs,
7386 const ArgList &Args,
7387 const char *LinkingOutput) const {
Eli Friedman9fa28852012-08-08 23:57:20 +00007388 const Driver &D = getToolChain().getDriver();
7389 ArgStringList CmdArgs;
7390
7391 if ((!Args.hasArg(options::OPT_nostdlib)) &&
7392 (!Args.hasArg(options::OPT_shared))) {
7393 CmdArgs.push_back("-e");
7394 CmdArgs.push_back("__start");
7395 }
7396
7397 if (Args.hasArg(options::OPT_static)) {
7398 CmdArgs.push_back("-Bstatic");
7399 } else {
7400 if (Args.hasArg(options::OPT_rdynamic))
7401 CmdArgs.push_back("-export-dynamic");
7402 CmdArgs.push_back("--eh-frame-hdr");
7403 CmdArgs.push_back("-Bdynamic");
7404 if (Args.hasArg(options::OPT_shared)) {
7405 CmdArgs.push_back("-shared");
7406 } else {
7407 CmdArgs.push_back("-dynamic-linker");
7408 CmdArgs.push_back("/usr/libexec/ld.so");
7409 }
7410 }
7411
7412 if (Output.isFilename()) {
7413 CmdArgs.push_back("-o");
7414 CmdArgs.push_back(Output.getFilename());
7415 } else {
7416 assert(Output.isNothing() && "Invalid output.");
7417 }
7418
7419 if (!Args.hasArg(options::OPT_nostdlib) &&
7420 !Args.hasArg(options::OPT_nostartfiles)) {
7421 if (!Args.hasArg(options::OPT_shared)) {
7422 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007423 CmdArgs.push_back(
7424 Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007425 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007426 CmdArgs.push_back(
7427 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7428 CmdArgs.push_back(
7429 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007430 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007431 CmdArgs.push_back(
7432 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007433 }
7434 }
7435
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00007436 Args.AddAllArgs(CmdArgs,
7437 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Eli Friedman9fa28852012-08-08 23:57:20 +00007438
7439 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7440
7441 if (!Args.hasArg(options::OPT_nostdlib) &&
7442 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00007443 if (D.CCCIsCXX()) {
Eli Friedman9fa28852012-08-08 23:57:20 +00007444 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7445 if (Args.hasArg(options::OPT_pg))
7446 CmdArgs.push_back("-lm_p");
7447 else
7448 CmdArgs.push_back("-lm");
7449 }
7450
Rafael Espindola1ad26f02012-10-23 17:07:31 +00007451 if (Args.hasArg(options::OPT_pthread)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007452 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
Rafael Espindola1ad26f02012-10-23 17:07:31 +00007453 CmdArgs.push_back("-lpthread_p");
7454 else
7455 CmdArgs.push_back("-lpthread");
7456 }
7457
Eli Friedman9fa28852012-08-08 23:57:20 +00007458 if (!Args.hasArg(options::OPT_shared)) {
7459 if (Args.hasArg(options::OPT_pg))
7460 CmdArgs.push_back("-lc_p");
7461 else
7462 CmdArgs.push_back("-lc");
7463 }
7464
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00007465 StringRef MyArch;
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007466 switch (getToolChain().getArch()) {
Benjamin Kramerb2ccade2013-10-21 12:33:55 +00007467 case llvm::Triple::arm:
7468 MyArch = "arm";
7469 break;
7470 case llvm::Triple::x86:
7471 MyArch = "i386";
7472 break;
7473 case llvm::Triple::x86_64:
7474 MyArch = "amd64";
7475 break;
7476 default:
7477 llvm_unreachable("Unsupported architecture");
7478 }
7479 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
Eli Friedman9fa28852012-08-08 23:57:20 +00007480 }
7481
7482 if (!Args.hasArg(options::OPT_nostdlib) &&
7483 !Args.hasArg(options::OPT_nostartfiles)) {
7484 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007485 CmdArgs.push_back(
7486 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007487 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007488 CmdArgs.push_back(
7489 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
Eli Friedman9fa28852012-08-08 23:57:20 +00007490 }
Eli Friedman5bb2ba02012-08-09 22:42:04 +00007491
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007492 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007493 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eli Friedman9fa28852012-08-08 23:57:20 +00007494}
7495
Douglas Katzman95354292015-06-23 20:42:09 +00007496void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7497 const InputInfo &Output,
7498 const InputInfoList &Inputs,
7499 const ArgList &Args,
7500 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007501 claimNoWarnArgs(Args);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007502 ArgStringList CmdArgs;
7503
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007504 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7505 // instruct as in the base system to assemble 32-bit code.
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007506 switch (getToolChain().getArch()) {
7507 default:
7508 break;
7509 case llvm::Triple::x86:
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007510 CmdArgs.push_back("--32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007511 break;
7512 case llvm::Triple::ppc:
Roman Divacky00859c22011-06-04 07:37:31 +00007513 CmdArgs.push_back("-a32");
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007514 break;
7515 case llvm::Triple::mips:
7516 case llvm::Triple::mipsel:
7517 case llvm::Triple::mips64:
7518 case llvm::Triple::mips64el: {
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007519 StringRef CPUName;
7520 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007521 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00007522
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007523 CmdArgs.push_back("-march");
7524 CmdArgs.push_back(CPUName.data());
7525
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007526 CmdArgs.push_back("-mabi");
Simon Atanasyan0da400c2013-02-27 14:55:49 +00007527 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007528
7529 if (getToolChain().getArch() == llvm::Triple::mips ||
7530 getToolChain().getArch() == llvm::Triple::mips64)
7531 CmdArgs.push_back("-EB");
7532 else
7533 CmdArgs.push_back("-EL");
7534
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007535 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007536 break;
7537 }
7538 case llvm::Triple::arm:
7539 case llvm::Triple::armeb:
7540 case llvm::Triple::thumb:
7541 case llvm::Triple::thumbeb: {
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00007542 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
Renato Golinf4421f72014-02-19 10:44:07 +00007543
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00007544 if (ABI == arm::FloatABI::Hard)
Renato Golinf4421f72014-02-19 10:44:07 +00007545 CmdArgs.push_back("-mfpu=vfp");
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00007546 else
Renato Golinf4421f72014-02-19 10:44:07 +00007547 CmdArgs.push_back("-mfpu=softvfp");
Renato Golinf4421f72014-02-19 10:44:07 +00007548
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007549 switch (getToolChain().getTriple().getEnvironment()) {
Renato Golinf4421f72014-02-19 10:44:07 +00007550 case llvm::Triple::GNUEABIHF:
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007551 case llvm::Triple::GNUEABI:
7552 case llvm::Triple::EABI:
Anton Korobeynikov2bed8472013-03-18 07:59:20 +00007553 CmdArgs.push_back("-meabi=5");
Rafael Espindola0f207ed2012-12-13 04:17:14 +00007554 break;
7555
7556 default:
7557 CmdArgs.push_back("-matpcs");
7558 }
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007559 break;
7560 }
7561 case llvm::Triple::sparc:
7562 case llvm::Triple::sparcel:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007563 case llvm::Triple::sparcv9: {
7564 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7565 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007566 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger9d3e4f62015-11-10 00:23:12 +00007567 break;
Eric Christopherc0f1a5e2012-09-05 21:32:44 +00007568 }
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00007569 }
Eric Christopher0b26a612010-03-02 02:41:08 +00007570
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007571 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007572
7573 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00007574 CmdArgs.push_back(Output.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007575
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007576 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00007577 CmdArgs.push_back(II.getFilename());
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007578
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007579 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00007580 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbar8eb473c2009-03-31 17:45:15 +00007581}
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007582
Douglas Katzman95354292015-06-23 20:42:09 +00007583void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7584 const InputInfo &Output,
7585 const InputInfoList &Inputs,
7586 const ArgList &Args,
7587 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007588 const toolchains::FreeBSD &ToolChain =
7589 static_cast<const toolchains::FreeBSD &>(getToolChain());
Roman Divackyafe2f232012-08-28 15:09:03 +00007590 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007591 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007592 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007593 !Args.hasArg(options::OPT_shared) &&
7594 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007595 ArgStringList CmdArgs;
David Chisnall5f99f482012-07-29 15:24:44 +00007596
7597 // Silence warning for "clang -g foo.o -o foo"
7598 Args.ClaimAllArgs(options::OPT_g_Group);
7599 // and "clang -emit-llvm foo.o -o foo"
7600 Args.ClaimAllArgs(options::OPT_emit_llvm);
7601 // and for "clang -w foo.o -o foo". Other warning options are already
7602 // handled somewhere else.
7603 Args.ClaimAllArgs(options::OPT_w);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007604
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007605 if (!D.SysRoot.empty())
7606 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7607
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007608 if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007609 CmdArgs.push_back("-pie");
7610
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007611 if (Args.hasArg(options::OPT_static)) {
7612 CmdArgs.push_back("-Bstatic");
7613 } else {
Rafael Espindola7ba97af2010-11-11 02:17:51 +00007614 if (Args.hasArg(options::OPT_rdynamic))
7615 CmdArgs.push_back("-export-dynamic");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007616 CmdArgs.push_back("--eh-frame-hdr");
7617 if (Args.hasArg(options::OPT_shared)) {
7618 CmdArgs.push_back("-Bshareable");
7619 } else {
7620 CmdArgs.push_back("-dynamic-linker");
7621 CmdArgs.push_back("/libexec/ld-elf.so.1");
7622 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007623 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
David Chisnall5f99f482012-07-29 15:24:44 +00007624 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7625 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7626 CmdArgs.push_back("--hash-style=both");
7627 }
7628 }
7629 CmdArgs.push_back("--enable-new-dtags");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007630 }
7631
7632 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7633 // instruct ld in the base system to link 32-bit code.
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007634 if (Arch == llvm::Triple::x86) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007635 CmdArgs.push_back("-m");
7636 CmdArgs.push_back("elf_i386_fbsd");
7637 }
7638
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00007639 if (Arch == llvm::Triple::ppc) {
Roman Divacky5e300b82011-06-04 07:40:24 +00007640 CmdArgs.push_back("-m");
Roman Divackyd150ad32011-11-21 16:50:32 +00007641 CmdArgs.push_back("elf32ppc_fbsd");
Roman Divacky5e300b82011-06-04 07:40:24 +00007642 }
7643
Daniel Dunbarb440f562010-08-02 02:38:21 +00007644 if (Output.isFilename()) {
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007645 CmdArgs.push_back("-o");
7646 CmdArgs.push_back(Output.getFilename());
7647 } else {
7648 assert(Output.isNothing() && "Invalid output.");
7649 }
7650
7651 if (!Args.hasArg(options::OPT_nostdlib) &&
7652 !Args.hasArg(options::OPT_nostartfiles)) {
Craig Topper92fc2df2014-05-17 16:56:41 +00007653 const char *crt1 = nullptr;
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007654 if (!Args.hasArg(options::OPT_shared)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007655 if (Args.hasArg(options::OPT_pg))
Roman Divackyafe2f232012-08-28 15:09:03 +00007656 crt1 = "gcrt1.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007657 else if (IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007658 crt1 = "Scrt1.o";
7659 else
7660 crt1 = "crt1.o";
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007661 }
Roman Divackyafe2f232012-08-28 15:09:03 +00007662 if (crt1)
7663 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7664
7665 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7666
Craig Topper92fc2df2014-05-17 16:56:41 +00007667 const char *crtbegin = nullptr;
Roman Divackyafe2f232012-08-28 15:09:03 +00007668 if (Args.hasArg(options::OPT_static))
7669 crtbegin = "crtbeginT.o";
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007670 else if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007671 crtbegin = "crtbeginS.o";
7672 else
7673 crtbegin = "crtbegin.o";
7674
7675 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007676 }
7677
7678 Args.AddAllArgs(CmdArgs, options::OPT_L);
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00007679 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007680 for (const auto &Path : Paths)
7681 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007682 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7683 Args.AddAllArgs(CmdArgs, options::OPT_e);
David Chisnall589a4942010-08-15 22:58:12 +00007684 Args.AddAllArgs(CmdArgs, options::OPT_s);
7685 Args.AddAllArgs(CmdArgs, options::OPT_t);
7686 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7687 Args.AddAllArgs(CmdArgs, options::OPT_r);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007688
Teresa Johnson945bc502015-10-15 20:35:53 +00007689 if (D.isUsingLTO())
7690 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Roman Divackyf0d7f942013-11-10 09:31:43 +00007691
Alexey Samsonov52550342014-09-15 19:58:40 +00007692 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Roman Divackyafe2f232012-08-28 15:09:03 +00007693 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007694
7695 if (!Args.hasArg(options::OPT_nostdlib) &&
7696 !Args.hasArg(options::OPT_nodefaultlibs)) {
Dimitry Andric0cc6f472015-10-18 13:32:20 +00007697 addOpenMPRuntime(CmdArgs, ToolChain, Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00007698 if (D.CCCIsCXX()) {
Roman Divackyafe2f232012-08-28 15:09:03 +00007699 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Roman Divacky66f22762011-02-10 16:59:40 +00007700 if (Args.hasArg(options::OPT_pg))
7701 CmdArgs.push_back("-lm_p");
7702 else
7703 CmdArgs.push_back("-lm");
Daniel Dunbar4b8ef282010-02-17 08:07:51 +00007704 }
Alexey Samsonov52550342014-09-15 19:58:40 +00007705 if (NeedsSanitizerDeps)
7706 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007707 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7708 // the default system libraries. Just mimic this for now.
Roman Divacky66f22762011-02-10 16:59:40 +00007709 if (Args.hasArg(options::OPT_pg))
7710 CmdArgs.push_back("-lgcc_p");
7711 else
7712 CmdArgs.push_back("-lgcc");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007713 if (Args.hasArg(options::OPT_static)) {
7714 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007715 } else if (Args.hasArg(options::OPT_pg)) {
7716 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007717 } else {
7718 CmdArgs.push_back("--as-needed");
7719 CmdArgs.push_back("-lgcc_s");
7720 CmdArgs.push_back("--no-as-needed");
7721 }
7722
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007723 if (Args.hasArg(options::OPT_pthread)) {
Roman Divacky66f22762011-02-10 16:59:40 +00007724 if (Args.hasArg(options::OPT_pg))
7725 CmdArgs.push_back("-lpthread_p");
7726 else
7727 CmdArgs.push_back("-lpthread");
Matt Beaumont-Gay1fe49152011-02-10 20:35:01 +00007728 }
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007729
Roman Divacky66f22762011-02-10 16:59:40 +00007730 if (Args.hasArg(options::OPT_pg)) {
7731 if (Args.hasArg(options::OPT_shared))
7732 CmdArgs.push_back("-lc");
7733 else
7734 CmdArgs.push_back("-lc_p");
7735 CmdArgs.push_back("-lgcc_p");
7736 } else {
7737 CmdArgs.push_back("-lc");
7738 CmdArgs.push_back("-lgcc");
7739 }
7740
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007741 if (Args.hasArg(options::OPT_static)) {
7742 CmdArgs.push_back("-lgcc_eh");
Roman Divacky66f22762011-02-10 16:59:40 +00007743 } else if (Args.hasArg(options::OPT_pg)) {
7744 CmdArgs.push_back("-lgcc_eh_p");
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007745 } else {
7746 CmdArgs.push_back("--as-needed");
7747 CmdArgs.push_back("-lgcc_s");
7748 CmdArgs.push_back("--no-as-needed");
7749 }
7750 }
7751
7752 if (!Args.hasArg(options::OPT_nostdlib) &&
7753 !Args.hasArg(options::OPT_nostartfiles)) {
Alexey Samsonove65ceb92014-02-25 13:26:03 +00007754 if (Args.hasArg(options::OPT_shared) || IsPIE)
Roman Divackyafe2f232012-08-28 15:09:03 +00007755 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
Roman Divackya3c50242012-09-07 13:36:21 +00007756 else
7757 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
Roman Divackyafe2f232012-08-28 15:09:03 +00007758 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007759 }
7760
Xinliang David Li69306c02015-10-22 06:15:31 +00007761 ToolChain.addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00007762
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007763 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00007764 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbard854c8d2009-04-01 19:36:32 +00007765}
Daniel Dunbarcc912342009-05-02 18:28:39 +00007766
Douglas Katzman95354292015-06-23 20:42:09 +00007767void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007768 const InputInfo &Output,
7769 const InputInfoList &Inputs,
7770 const ArgList &Args,
7771 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00007772 claimNoWarnArgs(Args);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007773 ArgStringList CmdArgs;
7774
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007775 // GNU as needs different flags for creating the correct output format
7776 // on architectures with different ABIs or optional feature sets.
7777 switch (getToolChain().getArch()) {
7778 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007779 CmdArgs.push_back("--32");
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007780 break;
7781 case llvm::Triple::arm:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007782 case llvm::Triple::armeb:
7783 case llvm::Triple::thumb:
7784 case llvm::Triple::thumbeb: {
Renato Goline17c5802015-07-27 23:44:42 +00007785 StringRef MArch, MCPU;
Renato Golin7c542b42015-07-27 23:44:45 +00007786 getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true);
7787 std::string Arch =
7788 arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple());
Renato Goline17c5802015-07-27 23:44:42 +00007789 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007790 break;
Joerg Sonnenberger1f94da52013-12-05 21:07:29 +00007791 }
7792
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007793 case llvm::Triple::mips:
7794 case llvm::Triple::mipsel:
7795 case llvm::Triple::mips64:
7796 case llvm::Triple::mips64el: {
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007797 StringRef CPUName;
7798 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00007799 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007800
7801 CmdArgs.push_back("-march");
7802 CmdArgs.push_back(CPUName.data());
7803
7804 CmdArgs.push_back("-mabi");
7805 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7806
7807 if (getToolChain().getArch() == llvm::Triple::mips ||
7808 getToolChain().getArch() == llvm::Triple::mips64)
7809 CmdArgs.push_back("-EB");
7810 else
7811 CmdArgs.push_back("-EL");
7812
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007813 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007814 break;
7815 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007816
7817 case llvm::Triple::sparc:
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007818 case llvm::Triple::sparcel: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007819 CmdArgs.push_back("-32");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007820 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7821 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007822 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007823 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007824 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007825
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007826 case llvm::Triple::sparcv9: {
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007827 CmdArgs.push_back("-64");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007828 std::string CPU = getCPUName(Args, getToolChain().getTriple());
7829 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
James Y Knight5bdf7ab2015-08-19 15:12:02 +00007830 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007831 break;
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007832 }
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007833
Joerg Sonnenberger25e18172014-02-19 22:16:19 +00007834 default:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007835 break;
Joerg Sonnenberger21baded2013-12-08 13:54:58 +00007836 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007837
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007838 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007839
7840 CmdArgs.push_back("-o");
7841 CmdArgs.push_back(Output.getFilename());
7842
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00007843 for (const auto &II : Inputs)
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007844 CmdArgs.push_back(II.getFilename());
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007845
David Chisnallddbd68f2011-09-27 22:03:18 +00007846 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
Justin Bognerd3371d82015-07-17 03:35:54 +00007847 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007848}
7849
Douglas Katzman95354292015-06-23 20:42:09 +00007850void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7851 const InputInfo &Output,
7852 const InputInfoList &Inputs,
7853 const ArgList &Args,
7854 const char *LinkingOutput) const {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007855 const Driver &D = getToolChain().getDriver();
7856 ArgStringList CmdArgs;
7857
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00007858 if (!D.SysRoot.empty())
7859 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7860
Joerg Sonnenberger52be0b42014-03-13 00:42:01 +00007861 CmdArgs.push_back("--eh-frame-hdr");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007862 if (Args.hasArg(options::OPT_static)) {
7863 CmdArgs.push_back("-Bstatic");
7864 } else {
7865 if (Args.hasArg(options::OPT_rdynamic))
7866 CmdArgs.push_back("-export-dynamic");
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007867 if (Args.hasArg(options::OPT_shared)) {
7868 CmdArgs.push_back("-Bshareable");
7869 } else {
7870 CmdArgs.push_back("-dynamic-linker");
7871 CmdArgs.push_back("/libexec/ld.elf_so");
7872 }
7873 }
7874
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007875 // Many NetBSD architectures support more than one ABI.
7876 // Determine the correct emulation for ld.
7877 switch (getToolChain().getArch()) {
7878 case llvm::Triple::x86:
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007879 CmdArgs.push_back("-m");
7880 CmdArgs.push_back("elf_i386");
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007881 break;
7882 case llvm::Triple::arm:
7883 case llvm::Triple::thumb:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007884 CmdArgs.push_back("-m");
7885 switch (getToolChain().getTriple().getEnvironment()) {
7886 case llvm::Triple::EABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007887 case llvm::Triple::GNUEABI:
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007888 CmdArgs.push_back("armelf_nbsd_eabi");
7889 break;
Joerg Sonnenberger83a33c02014-02-06 21:04:32 +00007890 case llvm::Triple::EABIHF:
7891 case llvm::Triple::GNUEABIHF:
7892 CmdArgs.push_back("armelf_nbsd_eabihf");
7893 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007894 default:
7895 CmdArgs.push_back("armelf_nbsd");
7896 break;
7897 }
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007898 break;
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007899 case llvm::Triple::armeb:
7900 case llvm::Triple::thumbeb:
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007901 arm::appendEBLinkFlags(
7902 Args, CmdArgs,
John Brawn94fd9632015-05-21 12:19:49 +00007903 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
Joerg Sonnenbergerb7045342014-08-14 19:12:41 +00007904 CmdArgs.push_back("-m");
7905 switch (getToolChain().getTriple().getEnvironment()) {
7906 case llvm::Triple::EABI:
7907 case llvm::Triple::GNUEABI:
7908 CmdArgs.push_back("armelfb_nbsd_eabi");
7909 break;
7910 case llvm::Triple::EABIHF:
7911 case llvm::Triple::GNUEABIHF:
7912 CmdArgs.push_back("armelfb_nbsd_eabihf");
7913 break;
7914 default:
7915 CmdArgs.push_back("armelfb_nbsd");
7916 break;
7917 }
7918 break;
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007919 case llvm::Triple::mips64:
7920 case llvm::Triple::mips64el:
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00007921 if (mips::hasMipsAbiArg(Args, "32")) {
Joerg Sonnenbergere7f97592014-02-02 22:59:16 +00007922 CmdArgs.push_back("-m");
7923 if (getToolChain().getArch() == llvm::Triple::mips64)
7924 CmdArgs.push_back("elf32btsmip");
7925 else
7926 CmdArgs.push_back("elf32ltsmip");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007927 } else if (mips::hasMipsAbiArg(Args, "64")) {
7928 CmdArgs.push_back("-m");
7929 if (getToolChain().getArch() == llvm::Triple::mips64)
7930 CmdArgs.push_back("elf64btsmip");
7931 else
7932 CmdArgs.push_back("elf64ltsmip");
7933 }
7934 break;
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00007935 case llvm::Triple::ppc:
7936 CmdArgs.push_back("-m");
7937 CmdArgs.push_back("elf32ppc_nbsd");
7938 break;
7939
7940 case llvm::Triple::ppc64:
7941 case llvm::Triple::ppc64le:
7942 CmdArgs.push_back("-m");
7943 CmdArgs.push_back("elf64ppc");
7944 break;
Joerg Sonnenbergered3f0692014-02-19 22:40:18 +00007945
7946 case llvm::Triple::sparc:
7947 CmdArgs.push_back("-m");
7948 CmdArgs.push_back("elf32_sparc");
7949 break;
7950
7951 case llvm::Triple::sparcv9:
7952 CmdArgs.push_back("-m");
7953 CmdArgs.push_back("elf64_sparc");
7954 break;
7955
Joerg Sonnenberger6cd7deb2014-02-02 22:50:34 +00007956 default:
7957 break;
Joerg Sonnenberger25de31d2014-02-02 22:47:37 +00007958 }
7959
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007960 if (Output.isFilename()) {
7961 CmdArgs.push_back("-o");
7962 CmdArgs.push_back(Output.getFilename());
7963 } else {
7964 assert(Output.isNothing() && "Invalid output.");
7965 }
7966
7967 if (!Args.hasArg(options::OPT_nostdlib) &&
7968 !Args.hasArg(options::OPT_nostartfiles)) {
7969 if (!Args.hasArg(options::OPT_shared)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007970 CmdArgs.push_back(
7971 Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7972 CmdArgs.push_back(
7973 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7974 CmdArgs.push_back(
7975 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007976 } else {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007977 CmdArgs.push_back(
7978 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7979 CmdArgs.push_back(
7980 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00007981 }
7982 }
7983
7984 Args.AddAllArgs(CmdArgs, options::OPT_L);
7985 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7986 Args.AddAllArgs(CmdArgs, options::OPT_e);
7987 Args.AddAllArgs(CmdArgs, options::OPT_s);
7988 Args.AddAllArgs(CmdArgs, options::OPT_t);
7989 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7990 Args.AddAllArgs(CmdArgs, options::OPT_r);
7991
7992 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7993
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00007994 unsigned Major, Minor, Micro;
7995 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7996 bool useLibgcc = true;
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00007997 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00007998 switch (getToolChain().getArch()) {
Joerg Sonnenberger323cea92014-08-09 18:28:36 +00007999 case llvm::Triple::aarch64:
Joerg Sonnenberger1ea66472014-05-07 08:45:26 +00008000 case llvm::Triple::arm:
8001 case llvm::Triple::armeb:
8002 case llvm::Triple::thumb:
8003 case llvm::Triple::thumbeb:
Joerg Sonnenbergerc8887572014-07-25 20:57:24 +00008004 case llvm::Triple::ppc:
Joerg Sonnenbergerdd13b302014-08-13 14:17:32 +00008005 case llvm::Triple::ppc64:
8006 case llvm::Triple::ppc64le:
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008007 case llvm::Triple::x86:
8008 case llvm::Triple::x86_64:
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008009 useLibgcc = false;
Joerg Sonnenbergerd769a1e2014-01-18 00:50:49 +00008010 break;
8011 default:
8012 break;
8013 }
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008014 }
8015
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008016 if (!Args.hasArg(options::OPT_nostdlib) &&
8017 !Args.hasArg(options::OPT_nodefaultlibs)) {
Joerg Sonnenberger27a69a22015-09-23 20:11:00 +00008018 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
Hans Wennborg70850d82013-07-18 20:29:38 +00008019 if (D.CCCIsCXX()) {
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008020 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8021 CmdArgs.push_back("-lm");
8022 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008023 if (Args.hasArg(options::OPT_pthread))
8024 CmdArgs.push_back("-lpthread");
8025 CmdArgs.push_back("-lc");
8026
Joerg Sonnenbergera4435632013-10-14 20:13:05 +00008027 if (useLibgcc) {
8028 if (Args.hasArg(options::OPT_static)) {
8029 // libgcc_eh depends on libc, so resolve as much as possible,
8030 // pull in any new requirements from libc and then get the rest
8031 // of libgcc.
8032 CmdArgs.push_back("-lgcc_eh");
8033 CmdArgs.push_back("-lc");
8034 CmdArgs.push_back("-lgcc");
8035 } else {
8036 CmdArgs.push_back("-lgcc");
8037 CmdArgs.push_back("--as-needed");
8038 CmdArgs.push_back("-lgcc_s");
8039 CmdArgs.push_back("--no-as-needed");
8040 }
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008041 }
8042 }
8043
8044 if (!Args.hasArg(options::OPT_nostdlib) &&
8045 !Args.hasArg(options::OPT_nostartfiles)) {
8046 if (!Args.hasArg(options::OPT_shared))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008047 CmdArgs.push_back(
8048 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008049 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008050 CmdArgs.push_back(
8051 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
8052 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008053 }
8054
Xinliang David Li69306c02015-10-22 06:15:31 +00008055 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00008056
Logan Chieneb9162f2014-06-26 14:23:45 +00008057 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008058 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00008059}
8060
Douglas Katzman95354292015-06-23 20:42:09 +00008061void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8062 const InputInfo &Output,
8063 const InputInfoList &Inputs,
8064 const ArgList &Args,
8065 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008066 claimNoWarnArgs(Args);
8067
James Y Knight2db38f32015-08-15 03:45:25 +00008068 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8069 llvm::Triple Triple = llvm::Triple(TripleStr);
8070
Rafael Espindola92b00932010-08-10 00:25:48 +00008071 ArgStringList CmdArgs;
8072
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008073 llvm::Reloc::Model RelocationModel;
8074 unsigned PICLevel;
8075 bool IsPIE;
8076 std::tie(RelocationModel, PICLevel, IsPIE) =
8077 ParsePICArgs(getToolChain(), Triple, Args);
8078
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008079 switch (getToolChain().getArch()) {
8080 default:
8081 break;
Rafael Espindola92b00932010-08-10 00:25:48 +00008082 // Add --32/--64 to make sure we get the format we want.
8083 // This is incomplete
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008084 case llvm::Triple::x86:
Rafael Espindola92b00932010-08-10 00:25:48 +00008085 CmdArgs.push_back("--32");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008086 break;
8087 case llvm::Triple::x86_64:
Zinovy Nis1db95732014-07-10 15:27:19 +00008088 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
8089 CmdArgs.push_back("--x32");
8090 else
8091 CmdArgs.push_back("--64");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008092 break;
8093 case llvm::Triple::ppc:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008094 CmdArgs.push_back("-a32");
8095 CmdArgs.push_back("-mppc");
8096 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008097 break;
8098 case llvm::Triple::ppc64:
Eli Friedman4a4932c2011-11-28 23:46:52 +00008099 CmdArgs.push_back("-a64");
8100 CmdArgs.push_back("-mppc64");
8101 CmdArgs.push_back("-many");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008102 break;
8103 case llvm::Triple::ppc64le:
Bill Schmidt778d3872013-07-26 01:36:11 +00008104 CmdArgs.push_back("-a64");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008105 CmdArgs.push_back("-mppc64");
Bill Schmidt778d3872013-07-26 01:36:11 +00008106 CmdArgs.push_back("-many");
Will Schmidtc1fc1902014-03-24 17:10:37 +00008107 CmdArgs.push_back("-mlittle-endian");
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008108 break;
8109 case llvm::Triple::sparc:
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008110 case llvm::Triple::sparcel: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008111 CmdArgs.push_back("-32");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008112 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8113 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8114 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008115 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008116 }
8117 case llvm::Triple::sparcv9: {
Jakob Stoklund Olesen2490e552014-01-10 03:51:29 +00008118 CmdArgs.push_back("-64");
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008119 std::string CPU = getCPUName(Args, getToolChain().getTriple());
8120 CmdArgs.push_back(getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
8121 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008122 break;
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008123 }
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008124 case llvm::Triple::arm:
8125 case llvm::Triple::armeb:
8126 case llvm::Triple::thumb:
8127 case llvm::Triple::thumbeb: {
James Y Knight2db38f32015-08-15 03:45:25 +00008128 const llvm::Triple &Triple2 = getToolChain().getTriple();
8129 switch (Triple2.getSubArch()) {
Scott Douglass3205f522015-03-23 10:54:24 +00008130 case llvm::Triple::ARMSubArch_v7:
Rafael Espindola92b00932010-08-10 00:25:48 +00008131 CmdArgs.push_back("-mfpu=neon");
Scott Douglass3205f522015-03-23 10:54:24 +00008132 break;
8133 case llvm::Triple::ARMSubArch_v8:
Bernard Ogdena58ef052013-10-24 18:32:41 +00008134 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
Scott Douglass3205f522015-03-23 10:54:24 +00008135 break;
8136 default:
8137 break;
8138 }
Evgeniy Stepanoved943f62012-04-20 09:03:40 +00008139
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008140 switch (arm::getARMFloatABI(getToolChain(), Args)) {
Saleem Abdulrasooleee54b42015-09-18 05:32:23 +00008141 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
8142 case arm::FloatABI::Soft:
8143 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
8144 break;
8145 case arm::FloatABI::SoftFP:
8146 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
8147 break;
8148 case arm::FloatABI::Hard:
8149 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
8150 break;
8151 }
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008152
8153 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
Ana Pazosdd6068d2013-12-06 22:43:17 +00008154
8155 // FIXME: remove krait check when GNU tools support krait cpu
8156 // for now replace it with -march=armv7-a to avoid a lower
8157 // march from being picked in the absence of a cpu flag.
8158 Arg *A;
8159 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008160 StringRef(A->getValue()).lower() == "krait")
8161 CmdArgs.push_back("-march=armv7-a");
Ana Pazosdd6068d2013-12-06 22:43:17 +00008162 else
8163 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
Evgeniy Stepanov582911a2012-04-24 09:05:31 +00008164 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008165 break;
8166 }
8167 case llvm::Triple::mips:
8168 case llvm::Triple::mipsel:
8169 case llvm::Triple::mips64:
8170 case llvm::Triple::mips64el: {
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008171 StringRef CPUName;
8172 StringRef ABIName;
Simon Atanasyan7018e1d2014-07-16 12:29:22 +00008173 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
Daniel Sanders379d44b2014-07-16 11:52:23 +00008174 ABIName = getGnuCompatibleMipsABIName(ABIName);
Akira Hatanaka5e9dde32011-11-30 19:31:38 +00008175
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008176 CmdArgs.push_back("-march");
8177 CmdArgs.push_back(CPUName.data());
8178
Simon Atanasyan571d7bd2012-04-07 22:31:29 +00008179 CmdArgs.push_back("-mabi");
Daniel Sanders379d44b2014-07-16 11:52:23 +00008180 CmdArgs.push_back(ABIName.data());
8181
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008182 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
8183 // or -mshared (not implemented) is in effect.
James Y Knight5bdf7ab2015-08-19 15:12:02 +00008184 if (RelocationModel == llvm::Reloc::Static)
Daniel Sanders54d8ee62014-07-23 12:06:13 +00008185 CmdArgs.push_back("-mno-shared");
8186
Daniel Sanders379d44b2014-07-16 11:52:23 +00008187 // LLVM doesn't support -mplt yet and acts as if it is always given.
8188 // However, -mplt has no effect with the N64 ABI.
8189 CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
Simon Atanasyan2390aa12012-04-06 19:15:24 +00008190
8191 if (getToolChain().getArch() == llvm::Triple::mips ||
8192 getToolChain().getArch() == llvm::Triple::mips64)
8193 CmdArgs.push_back("-EB");
8194 else
8195 CmdArgs.push_back("-EL");
Simon Atanasyan217dc2d2012-05-29 19:07:33 +00008196
Simon Atanasyan22127ce2013-09-24 09:09:16 +00008197 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
8198 if (StringRef(A->getValue()) == "2008")
8199 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
8200 }
8201
Daniel Sanders379d44b2014-07-16 11:52:23 +00008202 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
8203 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
8204 options::OPT_mfp64)) {
8205 A->claim();
8206 A->render(Args, CmdArgs);
Saleem Abdulrasoold5556e32015-09-19 04:33:38 +00008207 } else if (mips::shouldUseFPXX(
8208 Args, getToolChain().getTriple(), CPUName, ABIName,
8209 getMipsFloatABI(getToolChain().getDriver(), Args)))
Daniel Sanders379d44b2014-07-16 11:52:23 +00008210 CmdArgs.push_back("-mfpxx");
8211
8212 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
8213 // -mno-mips16 is actually -no-mips16.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008214 if (Arg *A =
8215 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
Daniel Sanders379d44b2014-07-16 11:52:23 +00008216 if (A->getOption().matches(options::OPT_mips16)) {
8217 A->claim();
8218 A->render(Args, CmdArgs);
8219 } else {
8220 A->claim();
8221 CmdArgs.push_back("-no-mips16");
8222 }
8223 }
8224
Simon Atanasyan036d16d2013-04-30 07:47:13 +00008225 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
8226 options::OPT_mno_micromips);
8227 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
8228 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
8229
Simon Atanasyanbd986632013-11-26 11:58:04 +00008230 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
8231 // Do not use AddLastArg because not all versions of MIPS assembler
8232 // support -mmsa / -mno-msa options.
8233 if (A->getOption().matches(options::OPT_mmsa))
8234 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
8235 }
8236
Daniel Sanders379d44b2014-07-16 11:52:23 +00008237 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
8238 options::OPT_msoft_float);
8239
Toma Tabacub36d6102015-06-11 12:13:18 +00008240 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
8241 options::OPT_msingle_float);
8242
Daniel Sanders379d44b2014-07-16 11:52:23 +00008243 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
8244 options::OPT_mno_odd_spreg);
8245
Joerg Sonnenberger5c1ac902015-11-10 00:40:29 +00008246 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008247 break;
8248 }
8249 case llvm::Triple::systemz: {
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008250 // Always pass an -march option, since our default of z10 is later
8251 // than the GNU assembler's default.
8252 StringRef CPUName = getSystemZTargetCPU(Args);
8253 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
Scott Douglassd4cfffc2015-03-23 10:46:28 +00008254 break;
8255 }
Jakob Stoklund Olesen8d7f5062014-01-12 04:53:36 +00008256 }
8257
Renato Golina74bbc72015-07-22 15:32:36 +00008258 Args.AddAllArgs(CmdArgs, options::OPT_I);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008259 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Rafael Espindola92b00932010-08-10 00:25:48 +00008260
8261 CmdArgs.push_back("-o");
8262 CmdArgs.push_back(Output.getFilename());
8263
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008264 for (const auto &II : Inputs)
Rafael Espindola92b00932010-08-10 00:25:48 +00008265 CmdArgs.push_back(II.getFilename());
Rafael Espindola92b00932010-08-10 00:25:48 +00008266
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008267 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008268 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Eric Christopher30aa6b62013-06-05 23:58:15 +00008269
8270 // Handle the debug info splitting at object creation time if we're
8271 // creating an object.
8272 // TODO: Currently only works on linux with newer objcopy.
8273 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
Cameron Esfahani556d91e2013-09-14 01:09:11 +00008274 getToolChain().getTriple().isOSLinux())
Eric Christopher30aa6b62013-06-05 23:58:15 +00008275 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
Artem Belevichba558952015-05-06 18:20:23 +00008276 SplitDebugName(Args, Inputs[0]));
Rafael Espindola92b00932010-08-10 00:25:48 +00008277}
8278
Benjamin Kramer9299637dc2014-03-04 19:31:42 +00008279static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008280 ArgStringList &CmdArgs, const ArgList &Args) {
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00008281 bool isAndroid = Triple.isAndroid();
Reid Kleckner0213a472015-07-22 16:01:38 +00008282 bool isCygMing = Triple.isOSCygMing();
Chandler Carruth58d6eb62013-03-04 02:07:55 +00008283 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
8284 Args.hasArg(options::OPT_static);
Hans Wennborg70850d82013-07-18 20:29:38 +00008285 if (!D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008286 CmdArgs.push_back("-lgcc");
8287
Logan Chien3d3373c2012-11-19 12:04:11 +00008288 if (StaticLibgcc || isAndroid) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008289 if (D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008290 CmdArgs.push_back("-lgcc");
8291 } else {
Reid Kleckner0213a472015-07-22 16:01:38 +00008292 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008293 CmdArgs.push_back("--as-needed");
8294 CmdArgs.push_back("-lgcc_s");
Reid Kleckner0213a472015-07-22 16:01:38 +00008295 if (!D.CCCIsCXX() && !isCygMing)
Rafael Espindolacc354322011-10-17 21:39:04 +00008296 CmdArgs.push_back("--no-as-needed");
8297 }
8298
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008299 if (StaticLibgcc && !isAndroid)
Rafael Espindolacc354322011-10-17 21:39:04 +00008300 CmdArgs.push_back("-lgcc_eh");
Hans Wennborg70850d82013-07-18 20:29:38 +00008301 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
Rafael Espindolacc354322011-10-17 21:39:04 +00008302 CmdArgs.push_back("-lgcc");
Logan Chien3d3373c2012-11-19 12:04:11 +00008303
8304 // According to Android ABI, we have to link with libdl if we are
8305 // linking with non-static libgcc.
8306 //
8307 // NOTE: This fixes a link error on Android MIPS as well. The non-static
8308 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
8309 if (isAndroid && !StaticLibgcc)
8310 CmdArgs.push_back("-ldl");
Rafael Espindolacc354322011-10-17 21:39:04 +00008311}
8312
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008313static std::string getLinuxDynamicLinker(const ArgList &Args,
8314 const toolchains::Linux &ToolChain) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008315 const llvm::Triple::ArchType Arch = ToolChain.getArch();
8316
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00008317 if (ToolChain.getTriple().isAndroid()) {
Alexey Bataevcf7ae302014-01-23 09:08:32 +00008318 if (ToolChain.getTriple().isArch64Bit())
8319 return "/system/bin/linker64";
8320 else
8321 return "/system/bin/linker";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008322 } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
8323 Arch == llvm::Triple::sparcel)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008324 return "/lib/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008325 else if (Arch == llvm::Triple::aarch64)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008326 return "/lib/ld-linux-aarch64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008327 else if (Arch == llvm::Triple::aarch64_be)
Christian Pirkera74c7912014-03-14 12:15:45 +00008328 return "/lib/ld-linux-aarch64_be.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008329 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
Renato Golin24ba3e92015-07-27 09:56:37 +00008330 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008331 arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008332 return "/lib/ld-linux-armhf.so.3";
8333 else
8334 return "/lib/ld-linux.so.3";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008335 } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
8336 // TODO: check which dynamic linker name.
Renato Golin24ba3e92015-07-27 09:56:37 +00008337 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
Saleem Abdulrasool06f6f992015-09-19 20:40:16 +00008338 arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard)
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008339 return "/lib/ld-linux-armhf.so.3";
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00008340 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008341 return "/lib/ld-linux.so.3";
8342 } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
8343 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008344 std::string LibDir =
8345 "/lib" + mips::getMipsABILibSuffix(Args, ToolChain.getTriple());
Vasileios Kalintiris71b0dfe2015-10-30 11:28:39 +00008346 StringRef LibName;
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008347 bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
Simon Atanasyand95c67d2014-08-13 14:34:14 +00008348 if (mips::isUCLibc(Args))
8349 LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008350 else if (!ToolChain.getTriple().hasEnvironment()) {
8351 bool LE = (ToolChain.getTriple().getArch() == llvm::Triple::mipsel) ||
8352 (ToolChain.getTriple().getArch() == llvm::Triple::mips64el);
8353 LibName = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
8354 } else
Simon Atanasyand95c67d2014-08-13 14:34:14 +00008355 LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
Simon Atanasyan2c590ff2014-08-04 12:57:52 +00008356
8357 return (LibDir + "/" + LibName).str();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008358 } else if (Arch == llvm::Triple::ppc)
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008359 return "/lib/ld.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008360 else if (Arch == llvm::Triple::ppc64) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00008361 if (ppc::hasPPCAbiArg(Args, "elfv2"))
8362 return "/lib64/ld64.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008363 return "/lib64/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008364 } else if (Arch == llvm::Triple::ppc64le) {
Ulrich Weigand8afad612014-07-28 13:17:52 +00008365 if (ppc::hasPPCAbiArg(Args, "elfv1"))
8366 return "/lib64/ld64.so.1";
Ulrich Weigand68e902c2014-06-20 14:19:02 +00008367 return "/lib64/ld64.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008368 } else if (Arch == llvm::Triple::systemz)
Sylvestre Ledruc0babf22015-08-28 12:26:09 +00008369 return "/lib/ld64.so.1";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008370 else if (Arch == llvm::Triple::sparcv9)
Jakob Stoklund Olesen73cb84c2014-01-10 08:18:34 +00008371 return "/lib64/ld-linux.so.2";
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008372 else if (Arch == llvm::Triple::x86_64 &&
Zinovy Nis1db95732014-07-10 15:27:19 +00008373 ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
8374 return "/libx32/ld-linux-x32.so.2";
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +00008375 else
8376 return "/lib64/ld-linux-x86-64.so.2";
8377}
8378
Renato Golinc4b49242014-02-13 10:01:16 +00008379static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
Saleem Abdulrasool2e46ebe2014-12-30 22:52:06 +00008380 ArgStringList &CmdArgs, const ArgList &Args) {
Renato Golinc4b49242014-02-13 10:01:16 +00008381 // Make use of compiler-rt if --rtlib option is used
8382 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
8383
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00008384 switch (RLT) {
Renato Golinc4b49242014-02-13 10:01:16 +00008385 case ToolChain::RLT_CompilerRT:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008386 switch (TC.getTriple().getOS()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008387 default:
8388 llvm_unreachable("unsupported OS");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008389 case llvm::Triple::Win32:
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008390 case llvm::Triple::Linux:
Saleem Abdulrasool8d7ade72014-12-30 02:10:36 +00008391 addClangRT(TC, Args, CmdArgs);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00008392 break;
8393 }
Renato Golinc4b49242014-02-13 10:01:16 +00008394 break;
8395 case ToolChain::RLT_Libgcc:
8396 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
8397 break;
Renato Golinc4b49242014-02-13 10:01:16 +00008398 }
8399}
8400
Rafael Espindola1e085772014-08-15 17:14:35 +00008401static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
8402 switch (T.getArch()) {
8403 case llvm::Triple::x86:
8404 return "elf_i386";
8405 case llvm::Triple::aarch64:
8406 return "aarch64linux";
8407 case llvm::Triple::aarch64_be:
8408 return "aarch64_be_linux";
8409 case llvm::Triple::arm:
8410 case llvm::Triple::thumb:
8411 return "armelf_linux_eabi";
8412 case llvm::Triple::armeb:
8413 case llvm::Triple::thumbeb:
8414 return "armebelf_linux_eabi"; /* TODO: check which NAME. */
8415 case llvm::Triple::ppc:
8416 return "elf32ppclinux";
8417 case llvm::Triple::ppc64:
8418 return "elf64ppc";
8419 case llvm::Triple::ppc64le:
8420 return "elf64lppc";
8421 case llvm::Triple::sparc:
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00008422 case llvm::Triple::sparcel:
Rafael Espindola1e085772014-08-15 17:14:35 +00008423 return "elf32_sparc";
8424 case llvm::Triple::sparcv9:
8425 return "elf64_sparc";
8426 case llvm::Triple::mips:
8427 return "elf32btsmip";
8428 case llvm::Triple::mipsel:
8429 return "elf32ltsmip";
8430 case llvm::Triple::mips64:
8431 if (mips::hasMipsAbiArg(Args, "n32"))
8432 return "elf32btsmipn32";
8433 return "elf64btsmip";
8434 case llvm::Triple::mips64el:
8435 if (mips::hasMipsAbiArg(Args, "n32"))
8436 return "elf32ltsmipn32";
8437 return "elf64ltsmip";
8438 case llvm::Triple::systemz:
8439 return "elf64_s390";
8440 case llvm::Triple::x86_64:
8441 if (T.getEnvironment() == llvm::Triple::GNUX32)
8442 return "elf32_x86_64";
8443 return "elf_x86_64";
8444 default:
8445 llvm_unreachable("Unexpected arch");
8446 }
8447}
8448
Douglas Katzman95354292015-06-23 20:42:09 +00008449void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8450 const InputInfo &Output,
8451 const InputInfoList &Inputs,
8452 const ArgList &Args,
8453 const char *LinkingOutput) const {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008454 const toolchains::Linux &ToolChain =
8455 static_cast<const toolchains::Linux &>(getToolChain());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008456 const Driver &D = ToolChain.getDriver();
James Y Knight2db38f32015-08-15 03:45:25 +00008457
8458 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8459 llvm::Triple Triple = llvm::Triple(TripleStr);
8460
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008461 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +00008462 const bool isAndroid = ToolChain.getTriple().isAndroid();
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008463 const bool IsPIE =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008464 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
8465 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008466 const bool HasCRTBeginEndFiles =
8467 ToolChain.getTriple().hasEnvironment() ||
8468 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008469
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008470 ArgStringList CmdArgs;
8471
Rafael Espindolad1002f62010-11-15 18:28:16 +00008472 // Silence warning for "clang -g foo.o -o foo"
8473 Args.ClaimAllArgs(options::OPT_g_Group);
Rafael Espindolad95a8122011-03-01 05:25:27 +00008474 // and "clang -emit-llvm foo.o -o foo"
8475 Args.ClaimAllArgs(options::OPT_emit_llvm);
David Chisnall5f99f482012-07-29 15:24:44 +00008476 // and for "clang -w foo.o -o foo". Other warning options are already
Rafael Espindolaf92614c2010-11-17 20:37:10 +00008477 // handled somewhere else.
8478 Args.ClaimAllArgs(options::OPT_w);
Rafael Espindolad1002f62010-11-15 18:28:16 +00008479
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008480 if (llvm::sys::path::filename(ToolChain.Linker) == "lld") {
8481 CmdArgs.push_back("-flavor");
8482 CmdArgs.push_back("gnu");
8483 CmdArgs.push_back("-target");
8484 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
8485 }
8486
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008487 if (!D.SysRoot.empty())
8488 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008489
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008490 if (IsPIE)
Rafael Espindolad47ac232010-11-17 22:26:15 +00008491 CmdArgs.push_back("-pie");
8492
Rafael Espindola1c76c592010-11-07 22:57:16 +00008493 if (Args.hasArg(options::OPT_rdynamic))
8494 CmdArgs.push_back("-export-dynamic");
8495
Rafael Espindola34d77dc2010-11-11 19:34:42 +00008496 if (Args.hasArg(options::OPT_s))
8497 CmdArgs.push_back("-s");
8498
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008499 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
James Y Knight2db38f32015-08-15 03:45:25 +00008500 arm::appendEBLinkFlags(Args, CmdArgs, Triple);
Joerg Sonnenberger1689d3f2015-01-28 23:30:39 +00008501
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008502 for (const auto &Opt : ToolChain.ExtraOpts)
8503 CmdArgs.push_back(Opt.c_str());
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008504
8505 if (!Args.hasArg(options::OPT_static)) {
8506 CmdArgs.push_back("--eh-frame-hdr");
8507 }
8508
8509 CmdArgs.push_back("-m");
Rafael Espindola1e085772014-08-15 17:14:35 +00008510 CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008511
8512 if (Args.hasArg(options::OPT_static)) {
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008513 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8514 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008515 CmdArgs.push_back("-Bstatic");
8516 else
8517 CmdArgs.push_back("-static");
8518 } else if (Args.hasArg(options::OPT_shared)) {
8519 CmdArgs.push_back("-shared");
8520 }
8521
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008522 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8523 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
NAKAMURA Takumi557fb622014-06-29 16:00:11 +00008524 (!Args.hasArg(options::OPT_static) &&
8525 !Args.hasArg(options::OPT_shared))) {
8526 CmdArgs.push_back("-dynamic-linker");
8527 CmdArgs.push_back(Args.MakeArgString(
8528 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
8529 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008530
8531 CmdArgs.push_back("-o");
8532 CmdArgs.push_back(Output.getFilename());
8533
Rafael Espindola81937ec2010-12-01 01:52:43 +00008534 if (!Args.hasArg(options::OPT_nostdlib) &&
8535 !Args.hasArg(options::OPT_nostartfiles)) {
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008536 if (!isAndroid) {
Craig Topper92fc2df2014-05-17 16:56:41 +00008537 const char *crt1 = nullptr;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008538 if (!Args.hasArg(options::OPT_shared)) {
Eric Christopherac021742013-06-07 23:25:01 +00008539 if (Args.hasArg(options::OPT_pg))
8540 crt1 = "gcrt1.o";
8541 else if (IsPIE)
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008542 crt1 = "Scrt1.o";
8543 else
8544 crt1 = "crt1.o";
8545 }
8546 if (crt1)
8547 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008548
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008549 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8550 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008551
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008552 const char *crtbegin;
8553 if (Args.hasArg(options::OPT_static))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008554 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008555 else if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008556 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008557 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008558 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008559 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008560 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008561
8562 if (HasCRTBeginEndFiles)
8563 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
Benjamin Kramer058666a2012-10-04 19:42:20 +00008564
8565 // Add crtfastmath.o if available and fast math is enabled.
8566 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008567 }
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008568
8569 Args.AddAllArgs(CmdArgs, options::OPT_L);
Reid Kleckner69071442014-06-26 01:08:54 +00008570 Args.AddAllArgs(CmdArgs, options::OPT_u);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008571
Benjamin Kramer22c68ef2014-09-11 14:13:49 +00008572 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008573
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008574 for (const auto &Path : Paths)
8575 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008576
Teresa Johnson945bc502015-10-15 20:35:53 +00008577 if (D.isUsingLTO())
8578 AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin);
Chandler Carruth953fb082013-01-13 11:46:33 +00008579
Nick Lewycky2fe6aab2012-08-17 03:39:16 +00008580 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8581 CmdArgs.push_back("--no-demangle");
8582
Alexey Samsonov52550342014-09-15 19:58:40 +00008583 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008584 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008585 // The profile runtime also needs access to system libraries.
Xinliang David Li69306c02015-10-22 06:15:31 +00008586 getToolChain().addProfileRTLibs(Args, CmdArgs);
Chandler Carruthe4458b32013-06-24 09:38:45 +00008587
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008588 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
Chandler Carruth94a32012012-05-14 18:31:18 +00008589 !Args.hasArg(options::OPT_nodefaultlibs)) {
Rafael Espindola70b8d762011-10-17 22:14:51 +00008590 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008591 !Args.hasArg(options::OPT_static);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008592 if (OnlyLibstdcxxStatic)
8593 CmdArgs.push_back("-Bstatic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008594 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola70b8d762011-10-17 22:14:51 +00008595 if (OnlyLibstdcxxStatic)
8596 CmdArgs.push_back("-Bdynamic");
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008597 CmdArgs.push_back("-lm");
8598 }
Chandler Carruth7e7dd472015-03-07 10:01:29 +00008599 // Silence warnings when linking C code with a C++ '-stdlib' argument.
8600 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008601
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008602 if (!Args.hasArg(options::OPT_nostdlib)) {
Chandler Carruth94a32012012-05-14 18:31:18 +00008603 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8604 if (Args.hasArg(options::OPT_static))
8605 CmdArgs.push_back("--start-group");
Nick Lewycky97864da2011-06-04 06:27:06 +00008606
Alexey Samsonov52550342014-09-15 19:58:40 +00008607 if (NeedsSanitizerDeps)
8608 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
8609
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008610 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8611 Args.hasArg(options::OPT_pthreads);
8612
8613 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8614 options::OPT_fno_openmp, false)) {
8615 // OpenMP runtimes implies pthreads when using the GNU toolchain.
8616 // FIXME: Does this really make sense for all GNU toolchains?
8617 WantPthread = true;
8618
8619 // Also link the particular OpenMP runtimes.
8620 switch (getOpenMPRuntime(ToolChain, Args)) {
8621 case OMPRT_OMP:
8622 CmdArgs.push_back("-lomp");
8623 break;
8624 case OMPRT_GOMP:
Richard Smith31d1de22015-05-20 22:48:44 +00008625 CmdArgs.push_back("-lgomp");
8626
8627 // FIXME: Exclude this for platforms with libgomp that don't require
8628 // librt. Most modern Linux platforms require it, but some may not.
8629 CmdArgs.push_back("-lrt");
8630 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008631 case OMPRT_IOMP5:
Richard Smith31d1de22015-05-20 22:48:44 +00008632 CmdArgs.push_back("-liomp5");
8633 break;
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008634 case OMPRT_Unknown:
8635 // Already diagnosed.
Richard Smith31d1de22015-05-20 22:48:44 +00008636 break;
8637 }
Chandler Carruth01538002013-01-17 13:19:29 +00008638 }
Chandler Carruth9c6b4f82015-05-28 01:52:38 +00008639
Renato Golinc4b49242014-02-13 10:01:16 +00008640 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008641
Richard Smith31d1de22015-05-20 22:48:44 +00008642 if (WantPthread && !isAndroid)
Chandler Carruth94a32012012-05-14 18:31:18 +00008643 CmdArgs.push_back("-lpthread");
8644
8645 CmdArgs.push_back("-lc");
8646
8647 if (Args.hasArg(options::OPT_static))
8648 CmdArgs.push_back("--end-group");
8649 else
Renato Golinc4b49242014-02-13 10:01:16 +00008650 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Chandler Carruth94a32012012-05-14 18:31:18 +00008651 }
Rafael Espindolad47ac232010-11-17 22:26:15 +00008652
Rafael Espindola81937ec2010-12-01 01:52:43 +00008653 if (!Args.hasArg(options::OPT_nostartfiles)) {
8654 const char *crtend;
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008655 if (Args.hasArg(options::OPT_shared))
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008656 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
Peter Collingbourne54d770c2013-04-09 04:35:11 +00008657 else if (IsPIE)
Evgeniy Stepanovc9cde482012-09-10 10:30:12 +00008658 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
Rafael Espindola81937ec2010-12-01 01:52:43 +00008659 else
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008660 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
Rafael Espindola9aa60e92010-11-12 03:00:39 +00008661
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008662 if (HasCRTBeginEndFiles)
8663 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
Evgeniy Stepanov77866712012-04-25 08:59:22 +00008664 if (!isAndroid)
8665 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
Rafael Espindola81937ec2010-12-01 01:52:43 +00008666 }
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00008667 } else if (Args.hasArg(options::OPT_rtlib_EQ))
8668 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
Rafael Espindolac8f008f2010-11-07 20:14:31 +00008669
Justin Bognerd3371d82015-07-17 03:35:54 +00008670 C.addCommand(llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(),
8671 CmdArgs, Inputs));
Saleem Abdulrasoola4a474b2014-06-29 06:11:14 +00008672}
8673
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008674// NaCl ARM assembly (inline or standalone) can be written with a set of macros
8675// for the various SFI requirements like register masking. The assembly tool
8676// inserts the file containing the macros as an input into all the assembly
8677// jobs.
Douglas Katzman95354292015-06-23 20:42:09 +00008678void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
8679 const InputInfo &Output,
8680 const InputInfoList &Inputs,
8681 const ArgList &Args,
8682 const char *LinkingOutput) const {
Douglas Katzman54366072015-07-27 16:53:08 +00008683 const toolchains::NaClToolChain &ToolChain =
8684 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008685 InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8686 "nacl-arm-macros.s");
8687 InputInfoList NewInputs;
8688 NewInputs.push_back(NaClMacros);
8689 NewInputs.append(Inputs.begin(), Inputs.end());
Douglas Katzman95354292015-06-23 20:42:09 +00008690 gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
8691 LinkingOutput);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008692}
8693
Douglas Katzman750cfc52015-06-29 18:42:16 +00008694// This is quite similar to gnutools::Linker::ConstructJob with changes that
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008695// we use static by default, do not yet support sanitizers or LTO, and a few
8696// others. Eventually we can support more of that and hopefully migrate back
Douglas Katzman750cfc52015-06-29 18:42:16 +00008697// to gnutools::Linker.
Douglas Katzman95354292015-06-23 20:42:09 +00008698void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8699 const InputInfo &Output,
8700 const InputInfoList &Inputs,
8701 const ArgList &Args,
8702 const char *LinkingOutput) const {
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008703
Douglas Katzman54366072015-07-27 16:53:08 +00008704 const toolchains::NaClToolChain &ToolChain =
8705 static_cast<const toolchains::NaClToolChain &>(getToolChain());
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008706 const Driver &D = ToolChain.getDriver();
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008707 const llvm::Triple::ArchType Arch = ToolChain.getArch();
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008708 const bool IsStatic =
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008709 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008710
8711 ArgStringList CmdArgs;
8712
8713 // Silence warning for "clang -g foo.o -o foo"
8714 Args.ClaimAllArgs(options::OPT_g_Group);
8715 // and "clang -emit-llvm foo.o -o foo"
8716 Args.ClaimAllArgs(options::OPT_emit_llvm);
8717 // and for "clang -w foo.o -o foo". Other warning options are already
8718 // handled somewhere else.
8719 Args.ClaimAllArgs(options::OPT_w);
8720
8721 if (!D.SysRoot.empty())
8722 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8723
8724 if (Args.hasArg(options::OPT_rdynamic))
8725 CmdArgs.push_back("-export-dynamic");
8726
8727 if (Args.hasArg(options::OPT_s))
8728 CmdArgs.push_back("-s");
8729
Douglas Katzman54366072015-07-27 16:53:08 +00008730 // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
8731 // from there is --build-id, which we do want.
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008732 CmdArgs.push_back("--build-id");
8733
8734 if (!IsStatic)
8735 CmdArgs.push_back("--eh-frame-hdr");
8736
8737 CmdArgs.push_back("-m");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008738 if (Arch == llvm::Triple::x86)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008739 CmdArgs.push_back("elf_i386_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008740 else if (Arch == llvm::Triple::arm)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008741 CmdArgs.push_back("armelf_nacl");
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008742 else if (Arch == llvm::Triple::x86_64)
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008743 CmdArgs.push_back("elf_x86_64_nacl");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008744 else if (Arch == llvm::Triple::mipsel)
8745 CmdArgs.push_back("mipselelf_nacl");
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008746 else
Douglas Katzmanfe77e0d2015-06-04 00:15:00 +00008747 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8748 << "Native Client";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008749
8750 if (IsStatic)
8751 CmdArgs.push_back("-static");
8752 else if (Args.hasArg(options::OPT_shared))
8753 CmdArgs.push_back("-shared");
8754
8755 CmdArgs.push_back("-o");
8756 CmdArgs.push_back(Output.getFilename());
8757 if (!Args.hasArg(options::OPT_nostdlib) &&
8758 !Args.hasArg(options::OPT_nostartfiles)) {
8759 if (!Args.hasArg(options::OPT_shared))
8760 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8761 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8762
8763 const char *crtbegin;
8764 if (IsStatic)
8765 crtbegin = "crtbeginT.o";
8766 else if (Args.hasArg(options::OPT_shared))
8767 crtbegin = "crtbeginS.o";
8768 else
8769 crtbegin = "crtbegin.o";
8770 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8771 }
8772
8773 Args.AddAllArgs(CmdArgs, options::OPT_L);
8774 Args.AddAllArgs(CmdArgs, options::OPT_u);
8775
8776 const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8777
8778 for (const auto &Path : Paths)
8779 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8780
8781 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8782 CmdArgs.push_back("--no-demangle");
8783
8784 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8785
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008786 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008787 !Args.hasArg(options::OPT_nodefaultlibs)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008788 bool OnlyLibstdcxxStatic =
8789 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008790 if (OnlyLibstdcxxStatic)
8791 CmdArgs.push_back("-Bstatic");
8792 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8793 if (OnlyLibstdcxxStatic)
8794 CmdArgs.push_back("-Bdynamic");
8795 CmdArgs.push_back("-lm");
8796 }
8797
8798 if (!Args.hasArg(options::OPT_nostdlib)) {
8799 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8800 // Always use groups, since it has no effect on dynamic libraries.
8801 CmdArgs.push_back("--start-group");
8802 CmdArgs.push_back("-lc");
8803 // NaCl's libc++ currently requires libpthread, so just always include it
8804 // in the group for C++.
8805 if (Args.hasArg(options::OPT_pthread) ||
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008806 Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008807 // Gold, used by Mips, handles nested groups differently than ld, and
8808 // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
8809 // which is not a desired behaviour here.
8810 // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
8811 if (getToolChain().getArch() == llvm::Triple::mipsel)
8812 CmdArgs.push_back("-lnacl");
8813
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008814 CmdArgs.push_back("-lpthread");
8815 }
8816
8817 CmdArgs.push_back("-lgcc");
8818 CmdArgs.push_back("--as-needed");
8819 if (IsStatic)
8820 CmdArgs.push_back("-lgcc_eh");
8821 else
8822 CmdArgs.push_back("-lgcc_s");
8823 CmdArgs.push_back("--no-as-needed");
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008824
8825 // Mips needs to create and use pnacl_legacy library that contains
8826 // definitions from bitcode/pnaclmm.c and definitions for
8827 // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
8828 if (getToolChain().getArch() == llvm::Triple::mipsel)
8829 CmdArgs.push_back("-lpnacl_legacy");
8830
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008831 CmdArgs.push_back("--end-group");
8832 }
8833
8834 if (!Args.hasArg(options::OPT_nostartfiles)) {
8835 const char *crtend;
8836 if (Args.hasArg(options::OPT_shared))
8837 crtend = "crtendS.o";
8838 else
8839 crtend = "crtend.o";
8840
8841 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8842 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8843 }
8844 }
8845
Justin Bognerd3371d82015-07-17 03:35:54 +00008846 C.addCommand(llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(),
8847 CmdArgs, Inputs));
Derek Schuff6ab52fa2015-03-30 20:31:33 +00008848}
8849
Douglas Katzman95354292015-06-23 20:42:09 +00008850void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8851 const InputInfo &Output,
8852 const InputInfoList &Inputs,
8853 const ArgList &Args,
8854 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008855 claimNoWarnArgs(Args);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008856 ArgStringList CmdArgs;
8857
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008858 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008859
8860 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008861 CmdArgs.push_back(Output.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008862
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008863 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008864 CmdArgs.push_back(II.getFilename());
Chris Lattner3e2ee142010-07-07 16:01:42 +00008865
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008866 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008867 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008868}
8869
Douglas Katzman95354292015-06-23 20:42:09 +00008870void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8871 const InputInfo &Output,
8872 const InputInfoList &Inputs,
8873 const ArgList &Args,
8874 const char *LinkingOutput) const {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008875 const Driver &D = getToolChain().getDriver();
8876 ArgStringList CmdArgs;
8877
Daniel Dunbarb440f562010-08-02 02:38:21 +00008878 if (Output.isFilename()) {
Chris Lattner3e2ee142010-07-07 16:01:42 +00008879 CmdArgs.push_back("-o");
8880 CmdArgs.push_back(Output.getFilename());
8881 } else {
8882 assert(Output.isNothing() && "Invalid output.");
8883 }
8884
8885 if (!Args.hasArg(options::OPT_nostdlib) &&
Eli Friedman83de5132011-12-08 23:54:21 +00008886 !Args.hasArg(options::OPT_nostartfiles)) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008887 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8888 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8889 CmdArgs.push_back(
8890 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8891 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Eli Friedman83de5132011-12-08 23:54:21 +00008892 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008893
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00008894 Args.AddAllArgs(CmdArgs,
8895 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Chris Lattner3e2ee142010-07-07 16:01:42 +00008896
Daniel Dunbar54423b22010-09-17 00:24:54 +00008897 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008898
Xinliang David Li69306c02015-10-22 06:15:31 +00008899 getToolChain().addProfileRTLibs(Args, CmdArgs);
Eli Friedman83de5132011-12-08 23:54:21 +00008900
Chris Lattner3e2ee142010-07-07 16:01:42 +00008901 if (!Args.hasArg(options::OPT_nostdlib) &&
8902 !Args.hasArg(options::OPT_nodefaultlibs)) {
Hans Wennborg70850d82013-07-18 20:29:38 +00008903 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00008904 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Chris Lattner3e2ee142010-07-07 16:01:42 +00008905 CmdArgs.push_back("-lm");
8906 }
Chris Lattner3e2ee142010-07-07 16:01:42 +00008907 }
8908
8909 if (!Args.hasArg(options::OPT_nostdlib) &&
8910 !Args.hasArg(options::OPT_nostartfiles)) {
Eli Friedman83de5132011-12-08 23:54:21 +00008911 if (Args.hasArg(options::OPT_pthread))
8912 CmdArgs.push_back("-lpthread");
8913 CmdArgs.push_back("-lc");
8914 CmdArgs.push_back("-lCompilerRT-Generic");
8915 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8916 CmdArgs.push_back(
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008917 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008918 }
8919
Logan Chieneb9162f2014-06-26 14:23:45 +00008920 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00008921 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Chris Lattner3e2ee142010-07-07 16:01:42 +00008922}
8923
Daniel Dunbarcc912342009-05-02 18:28:39 +00008924/// DragonFly Tools
8925
8926// For now, DragonFly Assemble does just about the same as for
8927// FreeBSD, but this may change soon.
Douglas Katzman95354292015-06-23 20:42:09 +00008928void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8929 const InputInfo &Output,
8930 const InputInfoList &Inputs,
8931 const ArgList &Args,
8932 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00008933 claimNoWarnArgs(Args);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008934 ArgStringList CmdArgs;
8935
8936 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8937 // instruct as in the base system to assemble 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008938 if (getToolChain().getArch() == llvm::Triple::x86)
Daniel Dunbarcc912342009-05-02 18:28:39 +00008939 CmdArgs.push_back("--32");
8940
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008941 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Daniel Dunbarcc912342009-05-02 18:28:39 +00008942
8943 CmdArgs.push_back("-o");
Daniel Dunbarb440f562010-08-02 02:38:21 +00008944 CmdArgs.push_back(Output.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008945
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008946 for (const auto &II : Inputs)
Daniel Dunbarb440f562010-08-02 02:38:21 +00008947 CmdArgs.push_back(II.getFilename());
Daniel Dunbarcc912342009-05-02 18:28:39 +00008948
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00008949 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00008950 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00008951}
8952
Douglas Katzman95354292015-06-23 20:42:09 +00008953void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8954 const InputInfo &Output,
8955 const InputInfoList &Inputs,
8956 const ArgList &Args,
8957 const char *LinkingOutput) const {
Daniel Dunbar083edf72009-12-21 18:54:17 +00008958 const Driver &D = getToolChain().getDriver();
Daniel Dunbarcc912342009-05-02 18:28:39 +00008959 ArgStringList CmdArgs;
Rafael Espindola611505f2014-09-11 18:10:13 +00008960 bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
John McCall65b8da02013-04-11 22:55:55 +00008961
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00008962 if (!D.SysRoot.empty())
8963 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8964
John McCall65b8da02013-04-11 22:55:55 +00008965 CmdArgs.push_back("--eh-frame-hdr");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008966 if (Args.hasArg(options::OPT_static)) {
8967 CmdArgs.push_back("-Bstatic");
8968 } else {
John McCall65b8da02013-04-11 22:55:55 +00008969 if (Args.hasArg(options::OPT_rdynamic))
8970 CmdArgs.push_back("-export-dynamic");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008971 if (Args.hasArg(options::OPT_shared))
8972 CmdArgs.push_back("-Bshareable");
8973 else {
8974 CmdArgs.push_back("-dynamic-linker");
8975 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8976 }
John McCall65b8da02013-04-11 22:55:55 +00008977 CmdArgs.push_back("--hash-style=both");
Daniel Dunbarcc912342009-05-02 18:28:39 +00008978 }
8979
8980 // When building 32-bit code on DragonFly/pc64, we have to explicitly
8981 // instruct ld in the base system to link 32-bit code.
Rafael Espindola35ca7d92012-10-07 04:44:33 +00008982 if (getToolChain().getArch() == llvm::Triple::x86) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008983 CmdArgs.push_back("-m");
8984 CmdArgs.push_back("elf_i386");
8985 }
8986
Daniel Dunbarb440f562010-08-02 02:38:21 +00008987 if (Output.isFilename()) {
Daniel Dunbarcc912342009-05-02 18:28:39 +00008988 CmdArgs.push_back("-o");
8989 CmdArgs.push_back(Output.getFilename());
8990 } else {
8991 assert(Output.isNothing() && "Invalid output.");
8992 }
8993
8994 if (!Args.hasArg(options::OPT_nostdlib) &&
8995 !Args.hasArg(options::OPT_nostartfiles)) {
8996 if (!Args.hasArg(options::OPT_shared)) {
John McCall65b8da02013-04-11 22:55:55 +00008997 if (Args.hasArg(options::OPT_pg))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00008998 CmdArgs.push_back(
8999 Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009000 else {
9001 if (Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009002 CmdArgs.push_back(
9003 Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009004 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009005 CmdArgs.push_back(
9006 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
John McCall65b8da02013-04-11 22:55:55 +00009007 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009008 }
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009009 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
John McCall65b8da02013-04-11 22:55:55 +00009010 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009011 CmdArgs.push_back(
9012 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009013 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009014 CmdArgs.push_back(
9015 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009016 }
9017
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009018 Args.AddAllArgs(CmdArgs,
9019 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
Daniel Dunbarcc912342009-05-02 18:28:39 +00009020
Daniel Dunbar54423b22010-09-17 00:24:54 +00009021 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
Daniel Dunbarcc912342009-05-02 18:28:39 +00009022
9023 if (!Args.hasArg(options::OPT_nostdlib) &&
9024 !Args.hasArg(options::OPT_nodefaultlibs)) {
9025 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
9026 // rpaths
John McCall65b8da02013-04-11 22:55:55 +00009027 if (UseGCC47)
9028 CmdArgs.push_back("-L/usr/lib/gcc47");
9029 else
9030 CmdArgs.push_back("-L/usr/lib/gcc44");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009031
9032 if (!Args.hasArg(options::OPT_static)) {
John McCall65b8da02013-04-11 22:55:55 +00009033 if (UseGCC47) {
9034 CmdArgs.push_back("-rpath");
9035 CmdArgs.push_back("/usr/lib/gcc47");
9036 } else {
9037 CmdArgs.push_back("-rpath");
9038 CmdArgs.push_back("/usr/lib/gcc44");
9039 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009040 }
9041
Hans Wennborg70850d82013-07-18 20:29:38 +00009042 if (D.CCCIsCXX()) {
Daniel Dunbar3f7796f2010-09-17 01:20:05 +00009043 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
Rafael Espindola38360b32010-07-20 12:59:03 +00009044 CmdArgs.push_back("-lm");
9045 }
9046
Daniel Dunbarcc912342009-05-02 18:28:39 +00009047 if (Args.hasArg(options::OPT_pthread))
Mike Stump0a65b632009-10-31 20:11:46 +00009048 CmdArgs.push_back("-lpthread");
Daniel Dunbarcc912342009-05-02 18:28:39 +00009049
9050 if (!Args.hasArg(options::OPT_nolibc)) {
9051 CmdArgs.push_back("-lc");
9052 }
9053
John McCall65b8da02013-04-11 22:55:55 +00009054 if (UseGCC47) {
9055 if (Args.hasArg(options::OPT_static) ||
9056 Args.hasArg(options::OPT_static_libgcc)) {
9057 CmdArgs.push_back("-lgcc");
9058 CmdArgs.push_back("-lgcc_eh");
9059 } else {
9060 if (Args.hasArg(options::OPT_shared_libgcc)) {
9061 CmdArgs.push_back("-lgcc_pic");
9062 if (!Args.hasArg(options::OPT_shared))
9063 CmdArgs.push_back("-lgcc");
9064 } else {
9065 CmdArgs.push_back("-lgcc");
9066 CmdArgs.push_back("--as-needed");
9067 CmdArgs.push_back("-lgcc_pic");
9068 CmdArgs.push_back("--no-as-needed");
9069 }
9070 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009071 } else {
John McCall65b8da02013-04-11 22:55:55 +00009072 if (Args.hasArg(options::OPT_shared)) {
9073 CmdArgs.push_back("-lgcc_pic");
9074 } else {
9075 CmdArgs.push_back("-lgcc");
9076 }
Daniel Dunbarcc912342009-05-02 18:28:39 +00009077 }
9078 }
9079
9080 if (!Args.hasArg(options::OPT_nostdlib) &&
9081 !Args.hasArg(options::OPT_nostartfiles)) {
John McCall65b8da02013-04-11 22:55:55 +00009082 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009083 CmdArgs.push_back(
9084 Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
John McCall65b8da02013-04-11 22:55:55 +00009085 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009086 CmdArgs.push_back(
9087 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
9088 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009089 }
9090
Xinliang David Li69306c02015-10-22 06:15:31 +00009091 getToolChain().addProfileRTLibs(Args, CmdArgs);
Nick Lewycky82fe5f42011-05-24 21:54:59 +00009092
Logan Chieneb9162f2014-06-26 14:23:45 +00009093 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
Justin Bognerd3371d82015-07-17 03:35:54 +00009094 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Daniel Dunbarcc912342009-05-02 18:28:39 +00009095}
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009096
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009097// Try to find Exe from a Visual Studio distribution. This first tries to find
9098// an installed copy of Visual Studio and, failing that, looks in the PATH,
9099// making sure that whatever executable that's found is not a same-named exe
9100// from clang itself to prevent clang from falling back to itself.
9101static std::string FindVisualStudioExecutable(const ToolChain &TC,
9102 const char *Exe,
9103 const char *ClangProgramPath) {
9104 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
9105 std::string visualStudioBinDir;
9106 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
9107 visualStudioBinDir)) {
9108 SmallString<128> FilePath(visualStudioBinDir);
9109 llvm::sys::path::append(FilePath, Exe);
9110 if (llvm::sys::fs::can_execute(FilePath.c_str()))
9111 return FilePath.str();
9112 }
9113
9114 return Exe;
9115}
9116
Douglas Katzman95354292015-06-23 20:42:09 +00009117void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9118 const InputInfo &Output,
9119 const InputInfoList &Inputs,
9120 const ArgList &Args,
9121 const char *LinkingOutput) const {
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009122 ArgStringList CmdArgs;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009123 const ToolChain &TC = getToolChain();
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009124
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00009125 assert((Output.isFilename() || Output.isNothing()) && "invalid output");
9126 if (Output.isFilename())
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009127 CmdArgs.push_back(
9128 Args.MakeArgString(std::string("-out:") + Output.getFilename()));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009129
9130 if (!Args.hasArg(options::OPT_nostdlib) &&
Saleem Abdulrasool9a215462014-12-19 23:56:31 +00009131 !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009132 CmdArgs.push_back("-defaultlib:libcmt");
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009133
Zachary Turner10d75b22014-10-22 20:40:43 +00009134 if (!llvm::sys::Process::GetEnv("LIB")) {
9135 // If the VC environment hasn't been configured (perhaps because the user
9136 // did not run vcvarsall), try to build a consistent link environment. If
Nico Webere93bcd12015-03-11 00:05:26 +00009137 // the environment variable is set however, assume the user knows what
9138 // they're doing.
Zachary Turner10d75b22014-10-22 20:40:43 +00009139 std::string VisualStudioDir;
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009140 const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
Zachary Turner10d75b22014-10-22 20:40:43 +00009141 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
9142 SmallString<128> LibDir(VisualStudioDir);
9143 llvm::sys::path::append(LibDir, "VC", "lib");
9144 switch (MSVC.getArch()) {
9145 case llvm::Triple::x86:
9146 // x86 just puts the libraries directly in lib
9147 break;
9148 case llvm::Triple::x86_64:
9149 llvm::sys::path::append(LibDir, "amd64");
9150 break;
9151 case llvm::Triple::arm:
9152 llvm::sys::path::append(LibDir, "arm");
9153 break;
9154 default:
9155 break;
9156 }
9157 CmdArgs.push_back(
9158 Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
Reid Kleckner7531f7d2015-09-11 00:09:39 +00009159
9160 if (MSVC.useUniversalCRT(VisualStudioDir)) {
9161 std::string UniversalCRTLibPath;
9162 if (MSVC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
9163 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9164 UniversalCRTLibPath.c_str()));
9165 }
Zachary Turner10d75b22014-10-22 20:40:43 +00009166 }
9167
9168 std::string WindowsSdkLibPath;
9169 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
9170 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9171 WindowsSdkLibPath.c_str()));
9172 }
9173
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009174 CmdArgs.push_back("-nologo");
9175
Reid Kleckner124955a2015-08-05 18:51:13 +00009176 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009177 CmdArgs.push_back("-debug");
Hans Wennborgbbb5f072014-04-25 16:24:19 +00009178
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009179 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
Hans Wennborge4c47f22015-03-04 23:16:21 +00009180 options::OPT_shared);
Hans Wennborgf1a74252013-09-10 20:18:04 +00009181 if (DLL) {
9182 CmdArgs.push_back(Args.MakeArgString("-dll"));
9183
9184 SmallString<128> ImplibName(Output.getFilename());
9185 llvm::sys::path::replace_extension(ImplibName, "lib");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009186 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
Hans Wennborgf1a74252013-09-10 20:18:04 +00009187 }
9188
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009189 if (TC.getSanitizerArgs().needsAsanRt()) {
Hans Wennborg0517e752013-08-28 17:36:07 +00009190 CmdArgs.push_back(Args.MakeArgString("-debug"));
Hans Wennborgd024c1c2013-08-30 10:50:52 +00009191 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009192 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009193 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
9194 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Timur Iskhodzhanov651725e2014-09-12 14:01:30 +00009195 // Make sure the dynamic runtime thunk is not optimized out at link time
9196 // to ensure proper SEH handling.
9197 CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
Timur Iskhodzhanov6903e102014-08-26 10:08:24 +00009198 } else if (DLL) {
Xinliang David Li69306c02015-10-22 06:15:31 +00009199 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009200 } else {
Saleem Abdulrasoolb48f1fe2015-10-29 03:36:42 +00009201 for (const auto &Lib : {"asan", "asan_cxx"})
9202 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
Alexey Samsonov6424e022014-05-12 20:20:20 +00009203 }
Hans Wennborg65f17522013-08-27 18:10:21 +00009204 }
9205
Hans Wennborg2e274592013-08-13 23:38:57 +00009206 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
Michael J. Spencere2f49362012-06-18 16:56:04 +00009207
Alexey Bataevc7e84352015-08-19 04:49:01 +00009208 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9209 options::OPT_fno_openmp, false)) {
9210 CmdArgs.push_back("-nodefaultlib:vcomp.lib");
9211 CmdArgs.push_back("-nodefaultlib:vcompd.lib");
9212 CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
9213 TC.getDriver().Dir + "/../lib"));
9214 switch (getOpenMPRuntime(getToolChain(), Args)) {
9215 case OMPRT_OMP:
9216 CmdArgs.push_back("-defaultlib:libomp.lib");
9217 break;
9218 case OMPRT_IOMP5:
9219 CmdArgs.push_back("-defaultlib:libiomp5md.lib");
9220 break;
9221 case OMPRT_GOMP:
9222 break;
9223 case OMPRT_Unknown:
9224 // Already diagnosed.
9225 break;
9226 }
9227 }
9228
Reid Kleckner337188f2014-09-16 19:22:00 +00009229 // Add filenames, libraries, and other linker inputs.
9230 for (const auto &Input : Inputs) {
9231 if (Input.isFilename()) {
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009232 CmdArgs.push_back(Input.getFilename());
Reid Kleckner337188f2014-09-16 19:22:00 +00009233 continue;
9234 }
9235
9236 const Arg &A = Input.getInputArg();
9237
9238 // Render -l options differently for the MSVC linker.
9239 if (A.getOption().matches(options::OPT_l)) {
9240 StringRef Lib = A.getValue();
9241 const char *LinkLibArg;
9242 if (Lib.endswith(".lib"))
9243 LinkLibArg = Args.MakeArgString(Lib);
9244 else
9245 LinkLibArg = Args.MakeArgString(Lib + ".lib");
9246 CmdArgs.push_back(LinkLibArg);
9247 continue;
9248 }
9249
9250 // Otherwise, this is some other kind of linker input option like -Wl, -z,
9251 // or -L. Render it, even if MSVC doesn't understand it.
9252 A.renderAsInput(Args, CmdArgs);
9253 }
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009254
Zachary Turner719f58c2014-12-01 23:06:47 +00009255 // We need to special case some linker paths. In the case of lld, we need to
9256 // translate 'lld' into 'lld-link', and in the case of the regular msvc
9257 // linker, we need to use a special search algorithm.
9258 llvm::SmallString<128> linkPath;
9259 StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
9260 if (Linker.equals_lower("lld"))
9261 Linker = "lld-link";
9262
9263 if (Linker.equals_lower("link")) {
9264 // If we're using the MSVC linker, it's not sufficient to just use link
9265 // from the program PATH, because other environments like GnuWin32 install
9266 // their own link.exe which may come first.
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009267 linkPath = FindVisualStudioExecutable(TC, "link.exe",
Zachary Turner719f58c2014-12-01 23:06:47 +00009268 C.getDriver().getClangProgramPath());
9269 } else {
9270 linkPath = Linker;
9271 llvm::sys::path::replace_extension(linkPath, "exe");
Saleem Abdulrasool21b18762014-12-19 23:56:28 +00009272 linkPath = TC.GetProgramPath(linkPath.c_str());
Zachary Turner719f58c2014-12-01 23:06:47 +00009273 }
9274
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009275 const char *Exec = Args.MakeArgString(linkPath);
Justin Bognerd3371d82015-07-17 03:35:54 +00009276 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Michael J. Spencerb186bc32010-08-21 21:55:07 +00009277}
Hans Wennborg87cfa712013-09-19 20:32:16 +00009278
Douglas Katzman95354292015-06-23 20:42:09 +00009279void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9280 const InputInfo &Output,
9281 const InputInfoList &Inputs,
9282 const ArgList &Args,
9283 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009284 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
9285}
9286
Douglas Katzman95354292015-06-23 20:42:09 +00009287std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
David Blaikiec11bf802014-09-04 16:04:28 +00009288 Compilation &C, const JobAction &JA, const InputInfo &Output,
9289 const InputInfoList &Inputs, const ArgList &Args,
9290 const char *LinkingOutput) const {
Hans Wennborg87cfa712013-09-19 20:32:16 +00009291 ArgStringList CmdArgs;
Hans Wennborg263c2132013-09-24 17:36:21 +00009292 CmdArgs.push_back("/nologo");
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009293 CmdArgs.push_back("/c"); // Compile only.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009294 CmdArgs.push_back("/W0"); // No warnings.
9295
9296 // The goal is to be able to invoke this tool correctly based on
9297 // any flag accepted by clang-cl.
9298
9299 // These are spelled the same way in clang and cl.exe,.
Douglas Katzman57a9c7e2015-07-29 18:39:14 +00009300 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009301
9302 // Optimization level.
David Majnemer015ce0f2015-07-27 07:32:11 +00009303 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
9304 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"
9305 : "/Oi-");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009306 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
9307 if (A->getOption().getID() == options::OPT_O0) {
9308 CmdArgs.push_back("/Od");
9309 } else {
David Majnemer015ce0f2015-07-27 07:32:11 +00009310 CmdArgs.push_back("/Og");
9311
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009312 StringRef OptLevel = A->getValue();
David Majnemer015ce0f2015-07-27 07:32:11 +00009313 if (OptLevel == "s" || OptLevel == "z")
9314 CmdArgs.push_back("/Os");
9315 else
9316 CmdArgs.push_back("/Ot");
9317
9318 CmdArgs.push_back("/Ob2");
Hans Wennborgb6331dc2013-09-24 18:17:21 +00009319 }
9320 }
David Majnemer015ce0f2015-07-27 07:32:11 +00009321 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
9322 options::OPT_fno_omit_frame_pointer))
9323 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
9324 ? "/Oy"
9325 : "/Oy-");
9326 if (!Args.hasArg(options::OPT_fwritable_strings))
9327 CmdArgs.push_back("/GF");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009328
Nico Weber3f8dafb2015-03-12 19:37:10 +00009329 // Flags for which clang-cl has an alias.
Hans Wennborg87cfa712013-09-19 20:32:16 +00009330 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
9331
David Majnemerf6072342014-07-01 22:24:56 +00009332 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
9333 /*default=*/false))
9334 CmdArgs.push_back("/GR-");
Hans Wennborg5149a3b2014-03-25 14:48:54 +00009335 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
9336 options::OPT_fno_function_sections))
9337 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
9338 ? "/Gy"
9339 : "/Gy-");
David Majnemerdc7a47c2014-04-07 16:14:38 +00009340 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
9341 options::OPT_fno_data_sections))
David Majnemer6c684a72014-04-07 16:19:27 +00009342 CmdArgs.push_back(
9343 A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009344 if (Args.hasArg(options::OPT_fsyntax_only))
9345 CmdArgs.push_back("/Zs");
Reid Kleckner124955a2015-08-05 18:51:13 +00009346 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
9347 options::OPT__SLASH_Z7))
Reid Klecknerc688daf2014-02-19 22:05:59 +00009348 CmdArgs.push_back("/Z7");
Hans Wennborg87cfa712013-09-19 20:32:16 +00009349
Nico Weber3f8dafb2015-03-12 19:37:10 +00009350 std::vector<std::string> Includes =
9351 Args.getAllArgValues(options::OPT_include);
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009352 for (const auto &Include : Includes)
9353 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
Hans Wennborg260ff402013-09-27 17:54:18 +00009354
Hans Wennborg87cfa712013-09-19 20:32:16 +00009355 // Flags that can simply be passed through.
9356 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
9357 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
Reid Klecknerc542d372014-06-27 17:02:02 +00009358 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
David Majnemerbac941c2015-07-25 06:07:59 +00009359 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
Hans Wennborg87cfa712013-09-19 20:32:16 +00009360
9361 // The order of these flags is relevant, so pick the last one.
9362 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
9363 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
9364 A->render(Args, CmdArgs);
9365
Hans Wennborg87cfa712013-09-19 20:32:16 +00009366 // Input filename.
9367 assert(Inputs.size() == 1);
9368 const InputInfo &II = Inputs[0];
9369 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9370 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
9371 if (II.isFilename())
9372 CmdArgs.push_back(II.getFilename());
9373 else
9374 II.getInputArg().renderAsInput(Args, CmdArgs);
9375
9376 // Output filename.
9377 assert(Output.getType() == types::TY_Object);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009378 const char *Fo =
9379 Args.MakeArgString(std::string("/Fo") + Output.getFilename());
Hans Wennborg87cfa712013-09-19 20:32:16 +00009380 CmdArgs.push_back(Fo);
9381
Hans Wennborg188382e2013-09-20 18:16:35 +00009382 const Driver &D = getToolChain().getDriver();
Zachary Turner0eaf8fc2014-10-22 20:40:28 +00009383 std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
9384 D.getClangProgramPath());
David Blaikiec11bf802014-09-04 16:04:28 +00009385 return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
Justin Bognerd3371d82015-07-17 03:35:54 +00009386 CmdArgs, Inputs);
Hans Wennborg87cfa712013-09-19 20:32:16 +00009387}
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009388
Yaron Keren1c0070c2015-07-02 04:45:27 +00009389/// MinGW Tools
9390void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9391 const InputInfo &Output,
9392 const InputInfoList &Inputs,
9393 const ArgList &Args,
9394 const char *LinkingOutput) const {
9395 claimNoWarnArgs(Args);
9396 ArgStringList CmdArgs;
9397
9398 if (getToolChain().getArch() == llvm::Triple::x86) {
9399 CmdArgs.push_back("--32");
9400 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
9401 CmdArgs.push_back("--64");
9402 }
9403
9404 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9405
9406 CmdArgs.push_back("-o");
9407 CmdArgs.push_back(Output.getFilename());
9408
9409 for (const auto &II : Inputs)
9410 CmdArgs.push_back(II.getFilename());
9411
9412 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009413 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +00009414
9415 if (Args.hasArg(options::OPT_gsplit_dwarf))
9416 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
9417 SplitDebugName(Args, Inputs[0]));
9418}
9419
9420void MinGW::Linker::AddLibGCC(const ArgList &Args,
9421 ArgStringList &CmdArgs) const {
9422 if (Args.hasArg(options::OPT_mthreads))
9423 CmdArgs.push_back("-lmingwthrd");
9424 CmdArgs.push_back("-lmingw32");
Reid Kleckner0213a472015-07-22 16:01:38 +00009425
Yaron Kerenaa281332015-08-09 00:24:07 +00009426 // Make use of compiler-rt if --rtlib option is used
9427 ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
9428 if (RLT == ToolChain::RLT_Libgcc) {
9429 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
9430 Args.hasArg(options::OPT_static);
9431 bool Shared = Args.hasArg(options::OPT_shared);
9432 bool CXX = getToolChain().getDriver().CCCIsCXX();
9433
9434 if (Static || (!CXX && !Shared)) {
9435 CmdArgs.push_back("-lgcc");
9436 CmdArgs.push_back("-lgcc_eh");
9437 } else {
9438 CmdArgs.push_back("-lgcc_s");
9439 CmdArgs.push_back("-lgcc");
9440 }
9441 } else {
9442 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
9443 }
Reid Kleckner0213a472015-07-22 16:01:38 +00009444
Yaron Keren1c0070c2015-07-02 04:45:27 +00009445 CmdArgs.push_back("-lmoldname");
9446 CmdArgs.push_back("-lmingwex");
9447 CmdArgs.push_back("-lmsvcrt");
9448}
9449
9450void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9451 const InputInfo &Output,
9452 const InputInfoList &Inputs,
9453 const ArgList &Args,
9454 const char *LinkingOutput) const {
9455 const ToolChain &TC = getToolChain();
9456 const Driver &D = TC.getDriver();
9457 // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
9458
9459 ArgStringList CmdArgs;
9460
9461 // Silence warning for "clang -g foo.o -o foo"
9462 Args.ClaimAllArgs(options::OPT_g_Group);
9463 // and "clang -emit-llvm foo.o -o foo"
9464 Args.ClaimAllArgs(options::OPT_emit_llvm);
9465 // and for "clang -w foo.o -o foo". Other warning options are already
9466 // handled somewhere else.
9467 Args.ClaimAllArgs(options::OPT_w);
9468
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009469 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
9470 if (LinkerName.equals_lower("lld")) {
9471 CmdArgs.push_back("-flavor");
9472 CmdArgs.push_back("gnu");
9473 }
9474
Yaron Keren1c0070c2015-07-02 04:45:27 +00009475 if (!D.SysRoot.empty())
9476 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9477
9478 if (Args.hasArg(options::OPT_s))
9479 CmdArgs.push_back("-s");
9480
9481 CmdArgs.push_back("-m");
9482 if (TC.getArch() == llvm::Triple::x86)
9483 CmdArgs.push_back("i386pe");
9484 if (TC.getArch() == llvm::Triple::x86_64)
9485 CmdArgs.push_back("i386pep");
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009486 if (TC.getArch() == llvm::Triple::arm)
9487 CmdArgs.push_back("thumb2pe");
Yaron Keren1c0070c2015-07-02 04:45:27 +00009488
9489 if (Args.hasArg(options::OPT_mwindows)) {
9490 CmdArgs.push_back("--subsystem");
9491 CmdArgs.push_back("windows");
9492 } else if (Args.hasArg(options::OPT_mconsole)) {
9493 CmdArgs.push_back("--subsystem");
9494 CmdArgs.push_back("console");
9495 }
9496
9497 if (Args.hasArg(options::OPT_static))
9498 CmdArgs.push_back("-Bstatic");
9499 else {
9500 if (Args.hasArg(options::OPT_mdll))
9501 CmdArgs.push_back("--dll");
9502 else if (Args.hasArg(options::OPT_shared))
9503 CmdArgs.push_back("--shared");
9504 CmdArgs.push_back("-Bdynamic");
9505 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
9506 CmdArgs.push_back("-e");
9507 if (TC.getArch() == llvm::Triple::x86)
9508 CmdArgs.push_back("_DllMainCRTStartup@12");
9509 else
9510 CmdArgs.push_back("DllMainCRTStartup");
9511 CmdArgs.push_back("--enable-auto-image-base");
9512 }
9513 }
9514
9515 CmdArgs.push_back("-o");
9516 CmdArgs.push_back(Output.getFilename());
9517
9518 Args.AddAllArgs(CmdArgs, options::OPT_e);
9519 // FIXME: add -N, -n flags
9520 Args.AddLastArg(CmdArgs, options::OPT_r);
9521 Args.AddLastArg(CmdArgs, options::OPT_s);
9522 Args.AddLastArg(CmdArgs, options::OPT_t);
9523 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
9524 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
9525
9526 if (!Args.hasArg(options::OPT_nostdlib) &&
9527 !Args.hasArg(options::OPT_nostartfiles)) {
9528 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
9529 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
9530 } else {
9531 if (Args.hasArg(options::OPT_municode))
9532 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
9533 else
9534 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
9535 }
9536 if (Args.hasArg(options::OPT_pg))
9537 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
9538 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
9539 }
9540
9541 Args.AddAllArgs(CmdArgs, options::OPT_L);
9542 const ToolChain::path_list Paths = TC.getFilePaths();
9543 for (const auto &Path : Paths)
9544 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9545
9546 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9547
9548 // TODO: Add ASan stuff here
9549
9550 // TODO: Add profile stuff here
9551
9552 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9553 !Args.hasArg(options::OPT_nodefaultlibs)) {
9554 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
9555 !Args.hasArg(options::OPT_static);
9556 if (OnlyLibstdcxxStatic)
9557 CmdArgs.push_back("-Bstatic");
9558 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9559 if (OnlyLibstdcxxStatic)
9560 CmdArgs.push_back("-Bdynamic");
9561 }
9562
9563 if (!Args.hasArg(options::OPT_nostdlib)) {
9564 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9565 if (Args.hasArg(options::OPT_static))
9566 CmdArgs.push_back("--start-group");
9567
9568 if (Args.hasArg(options::OPT_fstack_protector) ||
9569 Args.hasArg(options::OPT_fstack_protector_strong) ||
9570 Args.hasArg(options::OPT_fstack_protector_all)) {
9571 CmdArgs.push_back("-lssp_nonshared");
9572 CmdArgs.push_back("-lssp");
9573 }
9574 if (Args.hasArg(options::OPT_fopenmp))
9575 CmdArgs.push_back("-lgomp");
9576
9577 AddLibGCC(Args, CmdArgs);
9578
9579 if (Args.hasArg(options::OPT_pg))
9580 CmdArgs.push_back("-lgmon");
9581
Yaron Kerenadce68e2015-07-06 18:52:19 +00009582 if (Args.hasArg(options::OPT_pthread))
9583 CmdArgs.push_back("-lpthread");
Yaron Keren1c0070c2015-07-02 04:45:27 +00009584
9585 // add system libraries
9586 if (Args.hasArg(options::OPT_mwindows)) {
9587 CmdArgs.push_back("-lgdi32");
9588 CmdArgs.push_back("-lcomdlg32");
9589 }
9590 CmdArgs.push_back("-ladvapi32");
9591 CmdArgs.push_back("-lshell32");
9592 CmdArgs.push_back("-luser32");
9593 CmdArgs.push_back("-lkernel32");
9594
9595 if (Args.hasArg(options::OPT_static))
9596 CmdArgs.push_back("--end-group");
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009597 else if (!LinkerName.equals_lower("lld"))
Yaron Keren1c0070c2015-07-02 04:45:27 +00009598 AddLibGCC(Args, CmdArgs);
9599 }
9600
9601 if (!Args.hasArg(options::OPT_nostartfiles)) {
9602 // Add crtfastmath.o if available and fast math is enabled.
9603 TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
9604
9605 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
9606 }
9607 }
Yaron Keren2ffb36e2015-07-14 05:23:34 +00009608 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
Justin Bognerd3371d82015-07-17 03:35:54 +00009609 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Yaron Keren1c0070c2015-07-02 04:45:27 +00009610}
9611
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009612/// XCore Tools
9613// We pass assemble and link construction to the xcc tool.
9614
Douglas Katzman95354292015-06-23 20:42:09 +00009615void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9616 const InputInfo &Output,
9617 const InputInfoList &Inputs,
9618 const ArgList &Args,
9619 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009620 claimNoWarnArgs(Args);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009621 ArgStringList CmdArgs;
9622
9623 CmdArgs.push_back("-o");
9624 CmdArgs.push_back(Output.getFilename());
9625
9626 CmdArgs.push_back("-c");
9627
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009628 if (Args.hasArg(options::OPT_v))
9629 CmdArgs.push_back("-v");
9630
Robert Lytton894d25c2014-05-02 09:33:25 +00009631 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
9632 if (!A->getOption().matches(options::OPT_g0))
9633 CmdArgs.push_back("-g");
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009634
Robert Lytton8e95d4e2014-02-11 10:34:45 +00009635 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
9636 false))
9637 CmdArgs.push_back("-fverbose-asm");
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009638
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009639 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009640
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009641 for (const auto &II : Inputs)
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009642 CmdArgs.push_back(II.getFilename());
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009643
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009644 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009645 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009646}
9647
Douglas Katzman95354292015-06-23 20:42:09 +00009648void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9649 const InputInfo &Output,
9650 const InputInfoList &Inputs,
9651 const ArgList &Args,
9652 const char *LinkingOutput) const {
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009653 ArgStringList CmdArgs;
9654
9655 if (Output.isFilename()) {
9656 CmdArgs.push_back("-o");
9657 CmdArgs.push_back(Output.getFilename());
9658 } else {
9659 assert(Output.isNothing() && "Invalid output.");
9660 }
9661
Robert Lytton9e8c1a42014-02-13 10:40:12 +00009662 if (Args.hasArg(options::OPT_v))
9663 CmdArgs.push_back("-v");
9664
Reid Kleckner0bb1fc42015-07-10 22:25:44 +00009665 // Pass -fexceptions through to the linker if it was present.
9666 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
9667 false))
Robert Lyttonf7e03c12014-02-13 10:34:44 +00009668 CmdArgs.push_back("-fexceptions");
9669
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009670 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
9671
Saleem Abdulrasool2456cea2014-06-12 02:08:04 +00009672 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009673 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Robert Lyttoncf1dd692013-10-11 10:29:40 +00009674}
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009675
Douglas Katzman95354292015-06-23 20:42:09 +00009676void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9677 const InputInfo &Output,
9678 const InputInfoList &Inputs,
9679 const ArgList &Args,
9680 const char *LinkingOutput) const {
Rafael Espindola577637a2015-01-03 00:06:04 +00009681 claimNoWarnArgs(Args);
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009682 const auto &TC =
9683 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9684 ArgStringList CmdArgs;
9685 const char *Exec;
9686
9687 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009688 default:
9689 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009690 case llvm::Triple::arm:
9691 case llvm::Triple::thumb:
9692 break;
9693 case llvm::Triple::x86:
9694 CmdArgs.push_back("--32");
9695 break;
9696 case llvm::Triple::x86_64:
9697 CmdArgs.push_back("--64");
9698 break;
9699 }
9700
9701 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9702
9703 CmdArgs.push_back("-o");
9704 CmdArgs.push_back(Output.getFilename());
9705
9706 for (const auto &Input : Inputs)
9707 CmdArgs.push_back(Input.getFilename());
9708
9709 const std::string Assembler = TC.GetProgramPath("as");
9710 Exec = Args.MakeArgString(Assembler);
9711
Justin Bognerd3371d82015-07-17 03:35:54 +00009712 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009713}
9714
Douglas Katzman95354292015-06-23 20:42:09 +00009715void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9716 const InputInfo &Output,
9717 const InputInfoList &Inputs,
9718 const ArgList &Args,
9719 const char *LinkingOutput) const {
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009720 const auto &TC =
9721 static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9722 const llvm::Triple &T = TC.getTriple();
9723 const Driver &D = TC.getDriver();
9724 SmallString<128> EntryPoint;
9725 ArgStringList CmdArgs;
9726 const char *Exec;
9727
9728 // Silence warning for "clang -g foo.o -o foo"
9729 Args.ClaimAllArgs(options::OPT_g_Group);
9730 // and "clang -emit-llvm foo.o -o foo"
9731 Args.ClaimAllArgs(options::OPT_emit_llvm);
9732 // and for "clang -w foo.o -o foo"
9733 Args.ClaimAllArgs(options::OPT_w);
9734 // Other warning options are already handled somewhere else.
9735
9736 if (!D.SysRoot.empty())
9737 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9738
9739 if (Args.hasArg(options::OPT_pie))
9740 CmdArgs.push_back("-pie");
9741 if (Args.hasArg(options::OPT_rdynamic))
9742 CmdArgs.push_back("-export-dynamic");
9743 if (Args.hasArg(options::OPT_s))
9744 CmdArgs.push_back("--strip-all");
9745
9746 CmdArgs.push_back("-m");
9747 switch (TC.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009748 default:
9749 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009750 case llvm::Triple::arm:
9751 case llvm::Triple::thumb:
9752 // FIXME: this is incorrect for WinCE
9753 CmdArgs.push_back("thumb2pe");
9754 break;
9755 case llvm::Triple::x86:
9756 CmdArgs.push_back("i386pe");
9757 EntryPoint.append("_");
9758 break;
9759 case llvm::Triple::x86_64:
9760 CmdArgs.push_back("i386pep");
9761 break;
9762 }
9763
9764 if (Args.hasArg(options::OPT_shared)) {
9765 switch (T.getArch()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00009766 default:
9767 llvm_unreachable("unsupported architecture");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009768 case llvm::Triple::arm:
9769 case llvm::Triple::thumb:
9770 case llvm::Triple::x86_64:
9771 EntryPoint.append("_DllMainCRTStartup");
9772 break;
9773 case llvm::Triple::x86:
9774 EntryPoint.append("_DllMainCRTStartup@12");
9775 break;
9776 }
9777
9778 CmdArgs.push_back("-shared");
9779 CmdArgs.push_back("-Bdynamic");
9780
9781 CmdArgs.push_back("--enable-auto-image-base");
9782
9783 CmdArgs.push_back("--entry");
9784 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9785 } else {
9786 EntryPoint.append("mainCRTStartup");
9787
9788 CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
9789 : "-Bdynamic");
9790
9791 if (!Args.hasArg(options::OPT_nostdlib) &&
9792 !Args.hasArg(options::OPT_nostartfiles)) {
9793 CmdArgs.push_back("--entry");
9794 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9795 }
9796
9797 // FIXME: handle subsystem
9798 }
9799
9800 // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
Saleem Abdulrasool56dd1ac2014-10-28 03:15:02 +00009801 CmdArgs.push_back("--allow-multiple-definition");
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009802
9803 CmdArgs.push_back("-o");
9804 CmdArgs.push_back(Output.getFilename());
9805
9806 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9807 SmallString<261> ImpLib(Output.getFilename());
9808 llvm::sys::path::replace_extension(ImpLib, ".lib");
9809
9810 CmdArgs.push_back("--out-implib");
9811 CmdArgs.push_back(Args.MakeArgString(ImpLib));
9812 }
9813
9814 if (!Args.hasArg(options::OPT_nostdlib) &&
9815 !Args.hasArg(options::OPT_nostartfiles)) {
9816 const std::string CRTPath(D.SysRoot + "/usr/lib/");
9817 const char *CRTBegin;
9818
9819 CRTBegin =
9820 Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
9821 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9822 }
9823
9824 Args.AddAllArgs(CmdArgs, options::OPT_L);
9825
9826 const auto &Paths = TC.getFilePaths();
9827 for (const auto &Path : Paths)
9828 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9829
9830 AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9831
9832 if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9833 !Args.hasArg(options::OPT_nodefaultlibs)) {
9834 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9835 !Args.hasArg(options::OPT_static);
9836 if (StaticCXX)
9837 CmdArgs.push_back("-Bstatic");
9838 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9839 if (StaticCXX)
9840 CmdArgs.push_back("-Bdynamic");
9841 }
9842
9843 if (!Args.hasArg(options::OPT_nostdlib)) {
9844 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9845 // TODO handle /MT[d] /MD[d]
9846 CmdArgs.push_back("-lmsvcrt");
9847 AddRunTimeLibs(TC, D, CmdArgs, Args);
9848 }
9849 }
9850
Saleem Abdulrasoolbb2e5e42015-10-29 03:36:45 +00009851 if (TC.getSanitizerArgs().needsAsanRt()) {
9852 // TODO handle /MT[d] /MD[d]
9853 if (Args.hasArg(options::OPT_shared)) {
9854 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
9855 } else {
9856 for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
9857 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
9858 // Make sure the dynamic runtime thunk is not optimized out at link time
9859 // to ensure proper SEH handling.
9860 CmdArgs.push_back(Args.MakeArgString("--undefined"));
9861 CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
9862 ? "___asan_seh_interceptor"
9863 : "__asan_seh_interceptor"));
9864 }
9865 }
9866
Saleem Abdulrasoolfd80f832015-10-28 04:45:58 +00009867 Exec = Args.MakeArgString(TC.GetLinkerPath());
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009868
Justin Bognerd3371d82015-07-17 03:35:54 +00009869 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00009870}
Douglas Katzman84a75642015-06-19 14:55:19 +00009871
Douglas Katzman95354292015-06-23 20:42:09 +00009872void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9873 const InputInfo &Output,
9874 const InputInfoList &Inputs,
9875 const ArgList &Args,
9876 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +00009877
9878 ArgStringList CmdArgs;
9879
9880 assert(Inputs.size() == 1);
9881 const InputInfo &II = Inputs[0];
9882 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9883 assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm.
9884
Douglas Katzman84a75642015-06-19 14:55:19 +00009885 CmdArgs.push_back("-DMYRIAD2");
9886 CmdArgs.push_back("-mcpu=myriad2");
9887 CmdArgs.push_back("-S");
9888
Douglas Katzmanf6071112015-08-03 14:34:22 +00009889 // Append all -I, -iquote, -isystem paths, defines/undefines,
9890 // 'f' flags, optimize flags, and warning options.
9891 // These are spelled the same way in clang and moviCompile.
Douglas Katzman38dca882015-09-08 19:29:55 +00009892 Args.AddAllArgs(CmdArgs, {options::OPT_I_Group, options::OPT_clang_i_Group,
9893 options::OPT_D, options::OPT_U,
9894 options::OPT_f_Group, options::OPT_f_clang_Group,
9895 options::OPT_g_Group, options::OPT_M_Group,
9896 options::OPT_O_Group, options::OPT_W_Group});
9897
9898 // If we're producing a dependency file, and assembly is the final action,
9899 // then the name of the target in the dependency file should be the '.o'
9900 // file, not the '.s' file produced by this step. For example, instead of
9901 // /tmp/mumble.s: mumble.c .../someheader.h
9902 // the filename on the lefthand side should be "mumble.o"
9903 if (Args.getLastArg(options::OPT_MF) && !Args.getLastArg(options::OPT_MT) &&
9904 C.getActions().size() == 1 &&
9905 C.getActions()[0]->getKind() == Action::AssembleJobClass) {
9906 Arg *A = Args.getLastArg(options::OPT_o);
9907 if (A) {
9908 CmdArgs.push_back("-MT");
9909 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
9910 }
9911 }
9912
Douglas Katzman84a75642015-06-19 14:55:19 +00009913 CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified.
9914
9915 CmdArgs.push_back(II.getFilename());
9916 CmdArgs.push_back("-o");
9917 CmdArgs.push_back(Output.getFilename());
9918
9919 std::string Exec =
9920 Args.MakeArgString(getToolChain().GetProgramPath("moviCompile"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009921 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
9922 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +00009923}
9924
Douglas Katzman95354292015-06-23 20:42:09 +00009925void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9926 const InputInfo &Output,
9927 const InputInfoList &Inputs,
9928 const ArgList &Args,
9929 const char *LinkingOutput) const {
Douglas Katzman84a75642015-06-19 14:55:19 +00009930 ArgStringList CmdArgs;
9931
9932 assert(Inputs.size() == 1);
9933 const InputInfo &II = Inputs[0];
9934 assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input.
9935 assert(Output.getType() == types::TY_Object);
9936
9937 CmdArgs.push_back("-no6thSlotCompression");
Douglas Katzmanae2f3582015-09-11 21:13:46 +00009938 CmdArgs.push_back("-cv:myriad2"); // Chip Version
Douglas Katzman84a75642015-06-19 14:55:19 +00009939 CmdArgs.push_back("-noSPrefixing");
9940 CmdArgs.push_back("-a"); // Mystery option.
Douglas Katzmanae2f3582015-09-11 21:13:46 +00009941 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9942 for (const Arg *A : Args.filtered(options::OPT_I, options::OPT_isystem)) {
9943 A->claim();
Douglas Katzman84a75642015-06-19 14:55:19 +00009944 CmdArgs.push_back(
Douglas Katzmanae2f3582015-09-11 21:13:46 +00009945 Args.MakeArgString(std::string("-i:") + A->getValue(0)));
Douglas Katzman84a75642015-06-19 14:55:19 +00009946 }
9947 CmdArgs.push_back("-elf"); // Output format.
9948 CmdArgs.push_back(II.getFilename());
9949 CmdArgs.push_back(
9950 Args.MakeArgString(std::string("-o:") + Output.getFilename()));
9951
9952 std::string Exec =
9953 Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
Justin Bognerd3371d82015-07-17 03:35:54 +00009954 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
9955 CmdArgs, Inputs));
Douglas Katzman84a75642015-06-19 14:55:19 +00009956}
Douglas Katzmand6e597c2015-09-17 19:56:40 +00009957
9958void tools::Myriad::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9959 const InputInfo &Output,
9960 const InputInfoList &Inputs,
9961 const ArgList &Args,
9962 const char *LinkingOutput) const {
9963 const auto &TC =
9964 static_cast<const toolchains::MyriadToolChain &>(getToolChain());
9965 const llvm::Triple &T = TC.getTriple();
9966 ArgStringList CmdArgs;
9967 bool UseStartfiles = !Args.hasArg(options::OPT_nostartfiles);
Douglas Katzman9e31cb92015-10-02 18:39:08 +00009968 bool UseDefaultLibs = !Args.hasArg(options::OPT_nostdlib) &&
9969 !Args.hasArg(options::OPT_nodefaultlibs);
Douglas Katzmand6e597c2015-09-17 19:56:40 +00009970
9971 std::string StartFilesDir, BuiltinLibDir;
9972 TC.getCompilerSupportDir(StartFilesDir);
9973 TC.getBuiltinLibDir(BuiltinLibDir);
9974
9975 if (T.getArch() == llvm::Triple::sparc)
9976 CmdArgs.push_back("-EB");
9977 else // SHAVE assumes little-endian, and sparcel is expressly so.
9978 CmdArgs.push_back("-EL");
9979
9980 // The remaining logic is mostly like gnutools::Linker::ConstructJob,
9981 // but we never pass through a --sysroot option and various other bits.
9982 // For example, there are no sanitizers (yet) nor gold linker.
9983
9984 // Eat some arguments that may be present but have no effect.
9985 Args.ClaimAllArgs(options::OPT_g_Group);
9986 Args.ClaimAllArgs(options::OPT_w);
9987 Args.ClaimAllArgs(options::OPT_static_libgcc);
9988
9989 if (Args.hasArg(options::OPT_s)) // Pass the 'strip' option.
9990 CmdArgs.push_back("-s");
9991
9992 CmdArgs.push_back("-o");
9993 CmdArgs.push_back(Output.getFilename());
9994
9995 if (UseStartfiles) {
9996 // If you want startfiles, it means you want the builtin crti and crtbegin,
9997 // but not crt0. Myriad link commands provide their own crt0.o as needed.
9998 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crti.o"));
9999 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crtbegin.o"));
10000 }
10001
10002 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
10003 options::OPT_e, options::OPT_s, options::OPT_t,
10004 options::OPT_Z_Flag, options::OPT_r});
10005
Douglas Katzman526b5f92015-10-21 19:33:54 +000010006 // The linker doesn't use these builtin paths unless directed to,
10007 // because it was not compiled for support with sysroots, nor does
10008 // it have a default of little-endian with FPU.
10009 CmdArgs.push_back(Args.MakeArgString("-L" + BuiltinLibDir));
10010 CmdArgs.push_back(Args.MakeArgString("-L" + StartFilesDir));
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010011
10012 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
10013
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010014 if (UseDefaultLibs) {
Douglas Katzman795f57f2015-10-09 20:26:20 +000010015 if (C.getDriver().CCCIsCXX())
10016 CmdArgs.push_back("-lstdc++");
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010017 if (T.getOS() == llvm::Triple::RTEMS) {
10018 CmdArgs.push_back("--start-group");
10019 CmdArgs.push_back("-lc");
10020 // You must provide your own "-L" option to enable finding these.
10021 CmdArgs.push_back("-lrtemscpu");
10022 CmdArgs.push_back("-lrtemsbsp");
10023 CmdArgs.push_back("--end-group");
10024 } else {
10025 CmdArgs.push_back("-lc");
10026 }
Douglas Katzman9e31cb92015-10-02 18:39:08 +000010027 CmdArgs.push_back("-lgcc");
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010028 }
Douglas Katzmand6e597c2015-09-17 19:56:40 +000010029 if (UseStartfiles) {
10030 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crtend.o"));
10031 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crtn.o"));
10032 }
10033
10034 std::string Exec =
10035 Args.MakeArgString(TC.GetProgramPath("sparc-myriad-elf-ld"));
10036 C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
10037 CmdArgs, Inputs));
10038}
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010039
10040void PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
10041 const InputInfo &Output,
10042 const InputInfoList &Inputs,
10043 const ArgList &Args,
10044 const char *LinkingOutput) const {
10045 claimNoWarnArgs(Args);
10046 ArgStringList CmdArgs;
10047
10048 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10049
10050 CmdArgs.push_back("-o");
10051 CmdArgs.push_back(Output.getFilename());
10052
10053 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
10054 const InputInfo &Input = Inputs[0];
10055 assert(Input.isFilename() && "Invalid input.");
10056 CmdArgs.push_back(Input.getFilename());
10057
10058 const char *Exec =
10059 Args.MakeArgString(getToolChain().GetProgramPath("ps4-as"));
10060 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
10061}
10062
10063static void AddPS4ProfileRT(const ToolChain &TC, const ArgList &Args,
10064 ArgStringList &CmdArgs) {
10065 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
10066 false) ||
10067 Args.hasArg(options::OPT_fprofile_generate) ||
10068 Args.hasArg(options::OPT_fprofile_instr_generate) ||
10069 Args.hasArg(options::OPT_fcreate_profile) ||
10070 Args.hasArg(options::OPT_coverage)))
10071 return;
10072
10073 assert(TC.getTriple().isPS4CPU() &&
10074 "Profiling libraries are only implemented for the PS4 CPU");
10075 CmdArgs.push_back("-lclang_rt.profile-x86_64");
10076}
10077
10078static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
10079 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
10080 if (SanArgs.needsUbsanRt()) {
10081 CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
10082 }
10083 if (SanArgs.needsAsanRt()) {
10084 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
10085 }
10086}
10087
10088static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
10089 const JobAction &JA, const InputInfo &Output,
10090 const InputInfoList &Inputs,
10091 const ArgList &Args,
10092 const char *LinkingOutput) {
10093 const toolchains::FreeBSD &ToolChain =
10094 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10095 const Driver &D = ToolChain.getDriver();
10096 ArgStringList CmdArgs;
10097
10098 // Silence warning for "clang -g foo.o -o foo"
10099 Args.ClaimAllArgs(options::OPT_g_Group);
10100 // and "clang -emit-llvm foo.o -o foo"
10101 Args.ClaimAllArgs(options::OPT_emit_llvm);
10102 // and for "clang -w foo.o -o foo". Other warning options are already
10103 // handled somewhere else.
10104 Args.ClaimAllArgs(options::OPT_w);
10105
10106 if (!D.SysRoot.empty())
10107 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10108
10109 if (Args.hasArg(options::OPT_pie))
10110 CmdArgs.push_back("-pie");
10111
10112 if (Args.hasArg(options::OPT_rdynamic))
10113 CmdArgs.push_back("-export-dynamic");
10114 if (Args.hasArg(options::OPT_shared))
10115 CmdArgs.push_back("--oformat=so");
10116
10117 if (Output.isFilename()) {
10118 CmdArgs.push_back("-o");
10119 CmdArgs.push_back(Output.getFilename());
10120 } else {
10121 assert(Output.isNothing() && "Invalid output.");
10122 }
10123
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010124 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10125
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010126 Args.AddAllArgs(CmdArgs, options::OPT_L);
10127 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10128 Args.AddAllArgs(CmdArgs, options::OPT_e);
10129 Args.AddAllArgs(CmdArgs, options::OPT_s);
10130 Args.AddAllArgs(CmdArgs, options::OPT_t);
10131 Args.AddAllArgs(CmdArgs, options::OPT_r);
10132
10133 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10134 CmdArgs.push_back("--no-demangle");
10135
10136 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10137
10138 if (Args.hasArg(options::OPT_pthread)) {
10139 CmdArgs.push_back("-lpthread");
10140 }
10141
10142 AddPS4ProfileRT(ToolChain, Args, CmdArgs);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010143
10144 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("ps4-ld"));
10145
10146 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10147}
10148
10149static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
10150 const JobAction &JA, const InputInfo &Output,
10151 const InputInfoList &Inputs,
10152 const ArgList &Args,
10153 const char *LinkingOutput) {
10154 const toolchains::FreeBSD &ToolChain =
10155 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
10156 const Driver &D = ToolChain.getDriver();
10157 ArgStringList CmdArgs;
10158
10159 // Silence warning for "clang -g foo.o -o foo"
10160 Args.ClaimAllArgs(options::OPT_g_Group);
10161 // and "clang -emit-llvm foo.o -o foo"
10162 Args.ClaimAllArgs(options::OPT_emit_llvm);
10163 // and for "clang -w foo.o -o foo". Other warning options are already
10164 // handled somewhere else.
10165 Args.ClaimAllArgs(options::OPT_w);
10166
10167 if (!D.SysRoot.empty())
10168 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
10169
10170 if (Args.hasArg(options::OPT_pie))
10171 CmdArgs.push_back("-pie");
10172
10173 if (Args.hasArg(options::OPT_static)) {
10174 CmdArgs.push_back("-Bstatic");
10175 } else {
10176 if (Args.hasArg(options::OPT_rdynamic))
10177 CmdArgs.push_back("-export-dynamic");
10178 CmdArgs.push_back("--eh-frame-hdr");
10179 if (Args.hasArg(options::OPT_shared)) {
10180 CmdArgs.push_back("-Bshareable");
10181 } else {
10182 CmdArgs.push_back("-dynamic-linker");
10183 CmdArgs.push_back("/libexec/ld-elf.so.1");
10184 }
10185 CmdArgs.push_back("--enable-new-dtags");
10186 }
10187
10188 if (Output.isFilename()) {
10189 CmdArgs.push_back("-o");
10190 CmdArgs.push_back(Output.getFilename());
10191 } else {
10192 assert(Output.isNothing() && "Invalid output.");
10193 }
10194
Filipe Cabecinhas82cd6af2015-10-16 15:07:48 +000010195 AddPS4SanitizerArgs(ToolChain, CmdArgs);
10196
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010197 if (!Args.hasArg(options::OPT_nostdlib) &&
10198 !Args.hasArg(options::OPT_nostartfiles)) {
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010199 const char *crt1 = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010200 if (!Args.hasArg(options::OPT_shared)) {
10201 if (Args.hasArg(options::OPT_pg))
10202 crt1 = "gcrt1.o";
10203 else if (Args.hasArg(options::OPT_pie))
10204 crt1 = "Scrt1.o";
10205 else
10206 crt1 = "crt1.o";
10207 }
10208 if (crt1)
10209 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
10210
10211 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
10212
Eugene Zelenkod4304d22015-11-04 21:37:17 +000010213 const char *crtbegin = nullptr;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010214 if (Args.hasArg(options::OPT_static))
10215 crtbegin = "crtbeginT.o";
10216 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10217 crtbegin = "crtbeginS.o";
10218 else
10219 crtbegin = "crtbegin.o";
10220
10221 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
10222 }
10223
10224 Args.AddAllArgs(CmdArgs, options::OPT_L);
10225
10226 const ToolChain::path_list Paths = ToolChain.getFilePaths();
10227 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
10228 i != e; ++i)
10229 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
10230
10231 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10232 Args.AddAllArgs(CmdArgs, options::OPT_e);
10233 Args.AddAllArgs(CmdArgs, options::OPT_s);
10234 Args.AddAllArgs(CmdArgs, options::OPT_t);
10235 Args.AddAllArgs(CmdArgs, options::OPT_r);
10236
10237 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10238 CmdArgs.push_back("--no-demangle");
10239
10240 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
10241
10242 if (!Args.hasArg(options::OPT_nostdlib) &&
10243 !Args.hasArg(options::OPT_nodefaultlibs)) {
10244 // For PS4, we always want to pass libm, libstdc++ and libkernel
10245 // libraries for both C and C++ compilations.
10246 CmdArgs.push_back("-lkernel");
10247 if (D.CCCIsCXX()) {
10248 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
10249 if (Args.hasArg(options::OPT_pg))
10250 CmdArgs.push_back("-lm_p");
10251 else
10252 CmdArgs.push_back("-lm");
10253 }
10254 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
10255 // the default system libraries. Just mimic this for now.
10256 if (Args.hasArg(options::OPT_pg))
10257 CmdArgs.push_back("-lgcc_p");
10258 else
10259 CmdArgs.push_back("-lcompiler_rt");
10260 if (Args.hasArg(options::OPT_static)) {
10261 CmdArgs.push_back("-lstdc++");
10262 } else if (Args.hasArg(options::OPT_pg)) {
10263 CmdArgs.push_back("-lgcc_eh_p");
10264 } else {
10265 CmdArgs.push_back("--as-needed");
10266 CmdArgs.push_back("-lstdc++");
10267 CmdArgs.push_back("--no-as-needed");
10268 }
10269
10270 if (Args.hasArg(options::OPT_pthread)) {
10271 if (Args.hasArg(options::OPT_pg))
10272 CmdArgs.push_back("-lpthread_p");
10273 else
10274 CmdArgs.push_back("-lpthread");
10275 }
10276
10277 if (Args.hasArg(options::OPT_pg)) {
10278 if (Args.hasArg(options::OPT_shared))
10279 CmdArgs.push_back("-lc");
10280 else {
10281 if (Args.hasArg(options::OPT_static)) {
10282 CmdArgs.push_back("--start-group");
10283 CmdArgs.push_back("-lc_p");
10284 CmdArgs.push_back("-lpthread_p");
10285 CmdArgs.push_back("--end-group");
10286 } else {
10287 CmdArgs.push_back("-lc_p");
10288 }
10289 }
10290 CmdArgs.push_back("-lgcc_p");
10291 } else {
10292 if (Args.hasArg(options::OPT_static)) {
10293 CmdArgs.push_back("--start-group");
10294 CmdArgs.push_back("-lc");
10295 CmdArgs.push_back("-lpthread");
10296 CmdArgs.push_back("--end-group");
10297 } else {
10298 CmdArgs.push_back("-lc");
10299 }
10300 CmdArgs.push_back("-lcompiler_rt");
10301 }
10302
10303 if (Args.hasArg(options::OPT_static)) {
10304 CmdArgs.push_back("-lstdc++");
10305 } else if (Args.hasArg(options::OPT_pg)) {
10306 CmdArgs.push_back("-lgcc_eh_p");
10307 } else {
10308 CmdArgs.push_back("--as-needed");
10309 CmdArgs.push_back("-lstdc++");
10310 CmdArgs.push_back("--no-as-needed");
10311 }
10312 }
10313
10314 if (!Args.hasArg(options::OPT_nostdlib) &&
10315 !Args.hasArg(options::OPT_nostartfiles)) {
10316 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10317 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
10318 else
10319 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
10320 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
10321 }
10322
10323 AddPS4ProfileRT(ToolChain, Args, CmdArgs);
Filipe Cabecinhasc888e192015-10-14 12:25:43 +000010324
10325 const char *Exec =
10326#ifdef LLVM_ON_WIN32
10327 Args.MakeArgString(ToolChain.GetProgramPath("ps4-ld.gold.exe"));
10328#else
10329 Args.MakeArgString(ToolChain.GetProgramPath("ps4-ld"));
10330#endif
10331
10332 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10333}
10334
10335void PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
10336 const InputInfo &Output,
10337 const InputInfoList &Inputs,
10338 const ArgList &Args,
10339 const char *LinkingOutput) const {
10340 const toolchains::FreeBSD &ToolChain =
10341 static_cast<const toolchains::FreeBSD &>(getToolChain());
10342 const Driver &D = ToolChain.getDriver();
10343 bool PS4Linker;
10344 StringRef LinkerOptName;
10345 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
10346 LinkerOptName = A->getValue();
10347 if (LinkerOptName != "ps4" && LinkerOptName != "gold")
10348 D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
10349 }
10350
10351 if (LinkerOptName == "gold")
10352 PS4Linker = false;
10353 else if (LinkerOptName == "ps4")
10354 PS4Linker = true;
10355 else
10356 PS4Linker = !Args.hasArg(options::OPT_shared);
10357
10358 if (PS4Linker)
10359 ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10360 else
10361 ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
10362}