1//===--- Tools.cpp - Tools Implementations --------------------------------===//
2//
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"
11#include "InputInfo.h"
12#include "ToolChains.h"
13#include "clang/Basic/ObjCRuntime.h"
14#include "clang/Basic/Version.h"
15#include "clang/Driver/Action.h"
16#include "clang/Driver/Compilation.h"
17#include "clang/Driver/Driver.h"
18#include "clang/Driver/DriverDiagnostic.h"
19#include "clang/Driver/Job.h"
20#include "clang/Driver/Options.h"
21#include "clang/Driver/SanitizerArgs.h"
22#include "clang/Driver/ToolChain.h"
23#include "clang/Driver/Util.h"
24#include "clang/Sema/SemaDiagnostic.h"
25#include "llvm/ADT/SmallString.h"
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/ADT/StringSwitch.h"
28#include "llvm/ADT/Twine.h"
29#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/FileSystem.h"
34#include "llvm/Support/Format.h"
35#include "llvm/Support/Host.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/Program.h"
38#include "llvm/Support/Process.h"
39#include "llvm/Support/raw_ostream.h"
40#include <sys/stat.h>
41
42using namespace clang::driver;
43using namespace clang::driver::tools;
44using namespace clang;
45using namespace llvm::opt;
46
47/// CheckPreprocessingOptions - Perform some validation of preprocessing
48/// arguments that is shared with gcc.
49static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
50 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
51 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
52 D.Diag(diag::err_drv_argument_only_allowed_with)
53 << A->getAsString(Args) << "-E";
54}
55
56/// CheckCodeGenerationOptions - Perform some validation of code generation
57/// arguments that is shared with gcc.
58static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
59 // In gcc, only ARM checks this, but it seems reasonable to check universally.
60 if (Args.hasArg(options::OPT_static))
61 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
62 options::OPT_mdynamic_no_pic))
63 D.Diag(diag::err_drv_argument_not_allowed_with)
64 << A->getAsString(Args) << "-static";
65}
66
67// Quote target names for inclusion in GNU Make dependency files.
68// Only the characters '$', '#', ' ', '\t' are quoted.
69static void QuoteTarget(StringRef Target,
70 SmallVectorImpl<char> &Res) {
71 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
72 switch (Target[i]) {
73 case ' ':
74 case '\t':
75 // Escape the preceding backslashes
76 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
77 Res.push_back('\\');
78
79 // Escape the space/tab
80 Res.push_back('\\');
81 break;
82 case '$':
83 Res.push_back('$');
84 break;
85 case '#':
86 Res.push_back('\\');
87 break;
88 default:
89 break;
90 }
91
92 Res.push_back(Target[i]);
93 }
94}
95
96static void addDirectoryList(const ArgList &Args,
97 ArgStringList &CmdArgs,
98 const char *ArgName,
99 const char *EnvVar) {
100 const char *DirList = ::getenv(EnvVar);
101 bool CombinedArg = false;
102
103 if (!DirList)
104 return; // Nothing to do.
105
106 StringRef Name(ArgName);
107 if (Name.equals("-I") || Name.equals("-L"))
108 CombinedArg = true;
109
110 StringRef Dirs(DirList);
111 if (Dirs.empty()) // Empty string should not add '.'.
112 return;
113
114 StringRef::size_type Delim;
115 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
116 if (Delim == 0) { // Leading colon.
117 if (CombinedArg) {
118 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
119 } else {
120 CmdArgs.push_back(ArgName);
121 CmdArgs.push_back(".");
122 }
123 } else {
124 if (CombinedArg) {
125 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
126 } else {
127 CmdArgs.push_back(ArgName);
128 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
129 }
130 }
131 Dirs = Dirs.substr(Delim + 1);
132 }
133
134 if (Dirs.empty()) { // Trailing colon.
135 if (CombinedArg) {
136 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
137 } else {
138 CmdArgs.push_back(ArgName);
139 CmdArgs.push_back(".");
140 }
141 } else { // Add the last path.
142 if (CombinedArg) {
143 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
144 } else {
145 CmdArgs.push_back(ArgName);
146 CmdArgs.push_back(Args.MakeArgString(Dirs));
147 }
148 }
149}
150
151static void AddLinkerInputs(const ToolChain &TC,
152 const InputInfoList &Inputs, const ArgList &Args,
153 ArgStringList &CmdArgs) {
154 const Driver &D = TC.getDriver();
155
156 // Add extra linker input arguments which are not treated as inputs
157 // (constructed via -Xarch_).
158 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
159
160 for (InputInfoList::const_iterator
161 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
162 const InputInfo &II = *it;
163
164 if (!TC.HasNativeLLVMSupport()) {
165 // Don't try to pass LLVM inputs unless we have native support.
166 if (II.getType() == types::TY_LLVM_IR ||
167 II.getType() == types::TY_LTO_IR ||
168 II.getType() == types::TY_LLVM_BC ||
169 II.getType() == types::TY_LTO_BC)
170 D.Diag(diag::err_drv_no_linker_llvm_support)
171 << TC.getTripleString();
172 }
173
174 // Add filenames immediately.
175 if (II.isFilename()) {
176 CmdArgs.push_back(II.getFilename());
177 continue;
178 }
179
180 // Otherwise, this is a linker input argument.
181 const Arg &A = II.getInputArg();
182
183 // Handle reserved library options.
184 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
185 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
186 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
187 TC.AddCCKextLibArgs(Args, CmdArgs);
188 } else
189 A.renderAsInput(Args, CmdArgs);
190 }
191
192 // LIBRARY_PATH - included following the user specified library paths.
193 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
194}
195
196/// \brief Determine whether Objective-C automated reference counting is
197/// enabled.
198static bool isObjCAutoRefCount(const ArgList &Args) {
199 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
200}
201
202/// \brief Determine whether we are linking the ObjC runtime.
203static bool isObjCRuntimeLinked(const ArgList &Args) {
204 if (isObjCAutoRefCount(Args)) {
205 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
206 return true;
207 }
208 return Args.hasArg(options::OPT_fobjc_link_runtime);
209}
210
211static void addProfileRT(const ToolChain &TC, const ArgList &Args,
212 ArgStringList &CmdArgs,
213 llvm::Triple Triple) {
214 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
215 Args.hasArg(options::OPT_fprofile_generate) ||
216 Args.hasArg(options::OPT_fcreate_profile) ||
217 Args.hasArg(options::OPT_coverage)))
218 return;
219
220 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
221 // the link line. We cannot do the same thing because unlike gcov there is a
222 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
223 // not supported by old linkers.
224 std::string ProfileRT =
225 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
226
227 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
228}
229
230static bool forwardToGCC(const Option &O) {
231 // Don't forward inputs from the original command line. They are added from
232 // InputInfoList.
233 return O.getKind() != Option::InputClass &&
234 !O.hasFlag(options::DriverOption) &&
235 !O.hasFlag(options::LinkerInput);
236}
237
238void Clang::AddPreprocessingOptions(Compilation &C,
239 const JobAction &JA,
240 const Driver &D,
241 const ArgList &Args,
242 ArgStringList &CmdArgs,
243 const InputInfo &Output,
244 const InputInfoList &Inputs) const {
245 Arg *A;
246
247 CheckPreprocessingOptions(D, Args);
248
249 Args.AddLastArg(CmdArgs, options::OPT_C);
250 Args.AddLastArg(CmdArgs, options::OPT_CC);
251
252 // Handle dependency file generation.
253 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
254 (A = Args.getLastArg(options::OPT_MD)) ||
255 (A = Args.getLastArg(options::OPT_MMD))) {
256 // Determine the output location.
257 const char *DepFile;
258 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
259 DepFile = MF->getValue();
260 C.addFailureResultFile(DepFile, &JA);
261 } else if (Output.getType() == types::TY_Dependencies) {
262 DepFile = Output.getFilename();
263 } else if (A->getOption().matches(options::OPT_M) ||
264 A->getOption().matches(options::OPT_MM)) {
265 DepFile = "-";
266 } else {
267 DepFile = getDependencyFileName(Args, Inputs);
268 C.addFailureResultFile(DepFile, &JA);
269 }
270 CmdArgs.push_back("-dependency-file");
271 CmdArgs.push_back(DepFile);
272
273 // Add a default target if one wasn't specified.
274 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
275 const char *DepTarget;
276
277 // If user provided -o, that is the dependency target, except
278 // when we are only generating a dependency file.
279 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
280 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
281 DepTarget = OutputOpt->getValue();
282 } else {
283 // Otherwise derive from the base input.
284 //
285 // FIXME: This should use the computed output file location.
286 SmallString<128> P(Inputs[0].getBaseInput());
287 llvm::sys::path::replace_extension(P, "o");
288 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
289 }
290
291 CmdArgs.push_back("-MT");
292 SmallString<128> Quoted;
293 QuoteTarget(DepTarget, Quoted);
294 CmdArgs.push_back(Args.MakeArgString(Quoted));
295 }
296
297 if (A->getOption().matches(options::OPT_M) ||
298 A->getOption().matches(options::OPT_MD))
299 CmdArgs.push_back("-sys-header-deps");
300 }
301
302 if (Args.hasArg(options::OPT_MG)) {
303 if (!A || A->getOption().matches(options::OPT_MD) ||
304 A->getOption().matches(options::OPT_MMD))
305 D.Diag(diag::err_drv_mg_requires_m_or_mm);
306 CmdArgs.push_back("-MG");
307 }
308
309 Args.AddLastArg(CmdArgs, options::OPT_MP);
310
311 // Convert all -MQ <target> args to -MT <quoted target>
312 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
313 options::OPT_MQ),
314 ie = Args.filtered_end(); it != ie; ++it) {
315 const Arg *A = *it;
316 A->claim();
317
318 if (A->getOption().matches(options::OPT_MQ)) {
319 CmdArgs.push_back("-MT");
320 SmallString<128> Quoted;
321 QuoteTarget(A->getValue(), Quoted);
322 CmdArgs.push_back(Args.MakeArgString(Quoted));
323
324 // -MT flag - no change
325 } else {
326 A->render(Args, CmdArgs);
327 }
328 }
329
330 // Add -i* options, and automatically translate to
331 // -include-pch/-include-pth for transparent PCH support. It's
332 // wonky, but we include looking for .gch so we can support seamless
333 // replacement into a build system already set up to be generating
334 // .gch files.
335 bool RenderedImplicitInclude = false;
336 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
337 ie = Args.filtered_end(); it != ie; ++it) {
338 const Arg *A = it;
339
340 if (A->getOption().matches(options::OPT_include)) {
341 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
342 RenderedImplicitInclude = true;
343
344 // Use PCH if the user requested it.
345 bool UsePCH = D.CCCUsePCH;
346
347 bool FoundPTH = false;
348 bool FoundPCH = false;
349 SmallString<128> P(A->getValue());
350 // We want the files to have a name like foo.h.pch. Add a dummy extension
351 // so that replace_extension does the right thing.
352 P += ".dummy";
353 if (UsePCH) {
354 llvm::sys::path::replace_extension(P, "pch");
355 if (llvm::sys::fs::exists(P.str()))
356 FoundPCH = true;
357 }
358
359 if (!FoundPCH) {
360 llvm::sys::path::replace_extension(P, "pth");
361 if (llvm::sys::fs::exists(P.str()))
362 FoundPTH = true;
363 }
364
365 if (!FoundPCH && !FoundPTH) {
366 llvm::sys::path::replace_extension(P, "gch");
367 if (llvm::sys::fs::exists(P.str())) {
368 FoundPCH = UsePCH;
369 FoundPTH = !UsePCH;
370 }
371 }
372
373 if (FoundPCH || FoundPTH) {
374 if (IsFirstImplicitInclude) {
375 A->claim();
376 if (UsePCH)
377 CmdArgs.push_back("-include-pch");
378 else
379 CmdArgs.push_back("-include-pth");
380 CmdArgs.push_back(Args.MakeArgString(P.str()));
381 continue;
382 } else {
383 // Ignore the PCH if not first on command line and emit warning.
384 D.Diag(diag::warn_drv_pch_not_first_include)
385 << P.str() << A->getAsString(Args);
386 }
387 }
388 }
389
390 // Not translated, render as usual.
391 A->claim();
392 A->render(Args, CmdArgs);
393 }
394
395 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
396 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
397 options::OPT_index_header_map);
398
399 // Add -Wp, and -Xassembler if using the preprocessor.
400
401 // FIXME: There is a very unfortunate problem here, some troubled
402 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
403 // really support that we would have to parse and then translate
404 // those options. :(
405 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
406 options::OPT_Xpreprocessor);
407
408 // -I- is a deprecated GCC feature, reject it.
409 if (Arg *A = Args.getLastArg(options::OPT_I_))
410 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
411
412 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
413 // -isysroot to the CC1 invocation.
414 StringRef sysroot = C.getSysRoot();
415 if (sysroot != "") {
416 if (!Args.hasArg(options::OPT_isysroot)) {
417 CmdArgs.push_back("-isysroot");
418 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
419 }
420 }
421
422 // Parse additional include paths from environment variables.
423 // FIXME: We should probably sink the logic for handling these from the
424 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
425 // CPATH - included following the user specified includes (but prior to
426 // builtin and standard includes).
427 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
428 // C_INCLUDE_PATH - system includes enabled when compiling C.
429 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
430 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
431 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
432 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
433 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
434 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
435 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
436
437 // Add C++ include arguments, if needed.
438 if (types::isCXX(Inputs[0].getType()))
439 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
440
441 // Add system include arguments.
442 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
443}
444
445/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
446/// CPU.
447//
448// FIXME: This is redundant with -mcpu, why does LLVM use this.
449// FIXME: tblgen this, or kill it!
450static const char *getLLVMArchSuffixForARM(StringRef CPU) {
451 return llvm::StringSwitch<const char *>(CPU)
452 .Case("strongarm", "v4")
453 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
454 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
455 .Cases("arm920", "arm920t", "arm922t", "v4t")
456 .Cases("arm940t", "ep9312","v4t")
457 .Cases("arm10tdmi", "arm1020t", "v5")
458 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
459 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
460 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
461 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
462 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
463 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
464 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
465 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7")
466 .Cases("cortex-r4", "cortex-r5", "v7r")
467 .Case("cortex-m0", "v6m")
468 .Case("cortex-m3", "v7m")
469 .Case("cortex-m4", "v7em")
470 .Case("cortex-a9-mp", "v7f")
471 .Case("swift", "v7s")
472 .Cases("cortex-a53", "cortex-a57", "v8")
473 .Default("");
474}
475
476/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
477//
478// FIXME: tblgen this.
479static std::string getARMTargetCPU(const ArgList &Args,
480 const llvm::Triple &Triple) {
481 // FIXME: Warn on inconsistent use of -mcpu and -march.
482
483 // If we have -mcpu=, use that.
484 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
485 StringRef MCPU = A->getValue();
486 // Handle -mcpu=native.
487 if (MCPU == "native")
488 return llvm::sys::getHostCPUName();
489 else
490 return MCPU;
491 }
492
493 StringRef MArch;
494 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
495 // Otherwise, if we have -march= choose the base CPU for that arch.
496 MArch = A->getValue();
497 } else {
498 // Otherwise, use the Arch from the triple.
499 MArch = Triple.getArchName();
500 }
501
502 if (Triple.getOS() == llvm::Triple::NetBSD) {
503 if (MArch == "armv6")
504 return "arm1176jzf-s";
505 }
506
507 // Handle -march=native.
508 std::string NativeMArch;
509 if (MArch == "native") {
510 std::string CPU = llvm::sys::getHostCPUName();
511 if (CPU != "generic") {
512 // Translate the native cpu into the architecture. The switch below will
513 // then chose the minimum cpu for that arch.
514 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
515 MArch = NativeMArch;
516 }
517 }
518
519 return llvm::StringSwitch<const char *>(MArch)
520 .Cases("armv2", "armv2a","arm2")
521 .Case("armv3", "arm6")
522 .Case("armv3m", "arm7m")
523 .Case("armv4", "strongarm")
524 .Case("armv4t", "arm7tdmi")
525 .Cases("armv5", "armv5t", "arm10tdmi")
526 .Cases("armv5e", "armv5te", "arm1022e")
527 .Case("armv5tej", "arm926ej-s")
528 .Cases("armv6", "armv6k", "arm1136jf-s")
529 .Case("armv6j", "arm1136j-s")
530 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
531 .Case("armv6t2", "arm1156t2-s")
532 .Cases("armv6m", "armv6-m", "cortex-m0")
533 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
534 .Cases("armv7em", "armv7e-m", "cortex-m4")
535 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
536 .Cases("armv7s", "armv7-s", "swift")
537 .Cases("armv7r", "armv7-r", "cortex-r4")
538 .Cases("armv7m", "armv7-m", "cortex-m3")
539 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
540 .Case("ep9312", "ep9312")
541 .Case("iwmmxt", "iwmmxt")
542 .Case("xscale", "xscale")
543 // If all else failed, return the most base CPU with thumb interworking
544 // supported by LLVM.
545 .Default("arm7tdmi");
546}
547
548/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
549//
550// FIXME: tblgen this.
551static std::string getAArch64TargetCPU(const ArgList &Args,
552 const llvm::Triple &Triple) {
553 // FIXME: Warn on inconsistent use of -mcpu and -march.
554
555 // If we have -mcpu=, use that.
556 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
557 StringRef MCPU = A->getValue();
558 // Handle -mcpu=native.
559 if (MCPU == "native")
560 return llvm::sys::getHostCPUName();
561 else
562 return MCPU;
563 }
564
565 return "generic";
566}
567
568// FIXME: Move to target hook.
569static bool isSignedCharDefault(const llvm::Triple &Triple) {
570 switch (Triple.getArch()) {
571 default:
572 return true;
573
574 case llvm::Triple::aarch64:
575 case llvm::Triple::arm:
576 case llvm::Triple::ppc:
577 case llvm::Triple::ppc64:
578 if (Triple.isOSDarwin())
579 return true;
580 return false;
581
582 case llvm::Triple::ppc64le:
583 case llvm::Triple::systemz:
584 case llvm::Triple::xcore:
585 return false;
586 }
587}
588
589static bool isNoCommonDefault(const llvm::Triple &Triple) {
590 switch (Triple.getArch()) {
591 default:
592 return false;
593
594 case llvm::Triple::xcore:
595 return true;
596 }
597}
598
599// Handle -mfpu=.
600//
601// FIXME: Centralize feature selection, defaulting shouldn't be also in the
602// frontend target.
603static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
604 const ArgList &Args,
605 std::vector<const char *> &Features) {
606 StringRef FPU = A->getValue();
607 if (FPU == "fp-armv8") {
608 Features.push_back("+fp-armv8");
609 } else if (FPU == "neon-fp-armv8") {
610 Features.push_back("+fp-armv8");
611 Features.push_back("+neon");
612 } else if (FPU == "crypto-neon-fp-armv8") {
613 Features.push_back("+fp-armv8");
614 Features.push_back("+neon");
615 Features.push_back("+crypto");
616 } else if (FPU == "neon") {
617 Features.push_back("+neon");
618 } else if (FPU == "none") {
619 Features.push_back("-fp-armv8");
620 Features.push_back("-crypto");
621 Features.push_back("-neon");
622 } else
623 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
624}
625
626// Handle -mhwdiv=.
627static void getARMHWDivFeatures(const Driver &D, const Arg *A,
628 const ArgList &Args,
629 std::vector<const char *> &Features) {
630 StringRef HWDiv = A->getValue();
631 if (HWDiv == "arm") {
632 Features.push_back("+hwdiv-arm");
633 Features.push_back("-hwdiv");
634 } else if (HWDiv == "thumb") {
635 Features.push_back("-hwdiv-arm");
636 Features.push_back("+hwdiv");
637 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
638 Features.push_back("+hwdiv-arm");
639 Features.push_back("+hwdiv");
640 } else if (HWDiv == "none") {
641 Features.push_back("-hwdiv-arm");
642 Features.push_back("-hwdiv");
643 } else
644 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
645}
646
647// Handle -mfpu=.
648//
649// FIXME: Centralize feature selection, defaulting shouldn't be also in the
650// frontend target.
651static void getARMFPUFeatures(const Driver &D, const Arg *A,
652 const ArgList &Args,
653 std::vector<const char *> &Features) {
654 StringRef FPU = A->getValue();
655
656 // Set the target features based on the FPU.
657 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
658 // Disable any default FPU support.
659 Features.push_back("-vfp2");
660 Features.push_back("-vfp3");
661 Features.push_back("-neon");
662 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
663 Features.push_back("+vfp3");
664 Features.push_back("+d16");
665 Features.push_back("-neon");
666 } else if (FPU == "vfp") {
667 Features.push_back("+vfp2");
668 Features.push_back("-neon");
669 } else if (FPU == "vfp3" || FPU == "vfpv3") {
670 Features.push_back("+vfp3");
671 Features.push_back("-neon");
672 } else if (FPU == "fp-armv8") {
673 Features.push_back("+fp-armv8");
674 Features.push_back("-neon");
675 Features.push_back("-crypto");
676 } else if (FPU == "neon-fp-armv8") {
677 Features.push_back("+fp-armv8");
678 Features.push_back("+neon");
679 Features.push_back("-crypto");
680 } else if (FPU == "crypto-neon-fp-armv8") {
681 Features.push_back("+fp-armv8");
682 Features.push_back("+neon");
683 Features.push_back("+crypto");
684 } else if (FPU == "neon") {
685 Features.push_back("+neon");
686 } else if (FPU == "none") {
687 Features.push_back("-vfp2");
688 Features.push_back("-vfp3");
689 Features.push_back("-vfp4");
690 Features.push_back("-fp-armv8");
691 Features.push_back("-crypto");
692 Features.push_back("-neon");
693 } else
694 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
695}
696
697// Select the float ABI as determined by -msoft-float, -mhard-float, and
698// -mfloat-abi=.
699static StringRef getARMFloatABI(const Driver &D,
700 const ArgList &Args,
701 const llvm::Triple &Triple) {
702 StringRef FloatABI;
703 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
704 options::OPT_mhard_float,
705 options::OPT_mfloat_abi_EQ)) {
706 if (A->getOption().matches(options::OPT_msoft_float))
707 FloatABI = "soft";
708 else if (A->getOption().matches(options::OPT_mhard_float))
709 FloatABI = "hard";
710 else {
711 FloatABI = A->getValue();
712 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
713 D.Diag(diag::err_drv_invalid_mfloat_abi)
714 << A->getAsString(Args);
715 FloatABI = "soft";
716 }
717 }
718 }
719
720 // If unspecified, choose the default based on the platform.
721 if (FloatABI.empty()) {
722 switch (Triple.getOS()) {
723 case llvm::Triple::Darwin:
724 case llvm::Triple::MacOSX:
725 case llvm::Triple::IOS: {
726 // Darwin defaults to "softfp" for v6 and v7.
727 //
728 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
729 std::string ArchName =
730 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
731 if (StringRef(ArchName).startswith("v6") ||
732 StringRef(ArchName).startswith("v7"))
733 FloatABI = "softfp";
734 else
735 FloatABI = "soft";
736 break;
737 }
738
739 case llvm::Triple::FreeBSD:
740 // FreeBSD defaults to soft float
741 FloatABI = "soft";
742 break;
743
744 default:
745 switch(Triple.getEnvironment()) {
746 case llvm::Triple::GNUEABIHF:
747 FloatABI = "hard";
748 break;
749 case llvm::Triple::GNUEABI:
750 FloatABI = "softfp";
751 break;
752 case llvm::Triple::EABI:
753 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
754 FloatABI = "softfp";
755 break;
756 case llvm::Triple::Android: {
757 std::string ArchName =
758 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
759 if (StringRef(ArchName).startswith("v7"))
760 FloatABI = "softfp";
761 else
762 FloatABI = "soft";
763 break;
764 }
765 default:
766 // Assume "soft", but warn the user we are guessing.
767 FloatABI = "soft";
768 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
769 break;
770 }
771 }
772 }
773
774 return FloatABI;
775}
776
777static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
778 const ArgList &Args,
779 std::vector<const char *> &Features) {
780 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
781 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
782 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
783 // stripped out by the ARM target.
784 // Use software floating point operations?
785 if (FloatABI == "soft")
786 Features.push_back("+soft-float");
787
788 // Use software floating point argument passing?
789 if (FloatABI != "hard")
790 Features.push_back("+soft-float-abi");
791
792 // Honor -mfpu=.
793 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
794 getARMFPUFeatures(D, A, Args, Features);
795 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
796 getARMHWDivFeatures(D, A, Args, Features);
797
798 // Setting -msoft-float effectively disables NEON because of the GCC
799 // implementation, although the same isn't true of VFP or VFP3.
800 if (FloatABI == "soft")
801 Features.push_back("-neon");
802
803 // En/disable crc
804 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
805 options::OPT_mnocrc)) {
806 if (A->getOption().matches(options::OPT_mcrc))
807 Features.push_back("+crc");
808 else
809 Features.push_back("-crc");
810 }
811}
812
813void Clang::AddARMTargetArgs(const ArgList &Args,
814 ArgStringList &CmdArgs,
815 bool KernelOrKext) const {
816 const Driver &D = getToolChain().getDriver();
817 // Get the effective triple, which takes into account the deployment target.
818 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
819 llvm::Triple Triple(TripleStr);
820 std::string CPUName = getARMTargetCPU(Args, Triple);
821
822 // Select the ABI to use.
823 //
824 // FIXME: Support -meabi.
825 const char *ABIName = 0;
826 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
827 ABIName = A->getValue();
828 } else if (Triple.isOSDarwin()) {
829 // The backend is hardwired to assume AAPCS for M-class processors, ensure
830 // the frontend matches that.
831 if (Triple.getEnvironment() == llvm::Triple::EABI ||
832 StringRef(CPUName).startswith("cortex-m")) {
833 ABIName = "aapcs";
834 } else {
835 ABIName = "apcs-gnu";
836 }
837 } else {
838 // Select the default based on the platform.
839 switch(Triple.getEnvironment()) {
840 case llvm::Triple::Android:
841 case llvm::Triple::GNUEABI:
842 case llvm::Triple::GNUEABIHF:
843 ABIName = "aapcs-linux";
844 break;
845 case llvm::Triple::EABI:
846 ABIName = "aapcs";
847 break;
848 default:
849 ABIName = "apcs-gnu";
850 }
851 }
852 CmdArgs.push_back("-target-abi");
853 CmdArgs.push_back(ABIName);
854
855 // Determine floating point ABI from the options & target defaults.
856 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
857 if (FloatABI == "soft") {
858 // Floating point operations and argument passing are soft.
859 //
860 // FIXME: This changes CPP defines, we need -target-soft-float.
861 CmdArgs.push_back("-msoft-float");
862 CmdArgs.push_back("-mfloat-abi");
863 CmdArgs.push_back("soft");
864 } else if (FloatABI == "softfp") {
865 // Floating point operations are hard, but argument passing is soft.
866 CmdArgs.push_back("-mfloat-abi");
867 CmdArgs.push_back("soft");
868 } else {
869 // Floating point operations and argument passing are hard.
870 assert(FloatABI == "hard" && "Invalid float abi!");
871 CmdArgs.push_back("-mfloat-abi");
872 CmdArgs.push_back("hard");
873 }
874
875 // Kernel code has more strict alignment requirements.
876 if (KernelOrKext) {
877 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
878 CmdArgs.push_back("-backend-option");
879 CmdArgs.push_back("-arm-long-calls");
880 }
881
882 CmdArgs.push_back("-backend-option");
883 CmdArgs.push_back("-arm-strict-align");
884
885 // The kext linker doesn't know how to deal with movw/movt.
886 CmdArgs.push_back("-backend-option");
887 CmdArgs.push_back("-arm-use-movt=0");
888 }
889
890 // Setting -mno-global-merge disables the codegen global merge pass. Setting
891 // -mglobal-merge has no effect as the pass is enabled by default.
892 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
893 options::OPT_mno_global_merge)) {
894 if (A->getOption().matches(options::OPT_mno_global_merge))
895 CmdArgs.push_back("-mno-global-merge");
896 }
897
898 if (!Args.hasFlag(options::OPT_mimplicit_float,
899 options::OPT_mno_implicit_float,
900 true))
901 CmdArgs.push_back("-no-implicit-float");
902
903 // llvm does not support reserving registers in general. There is support
904 // for reserving r9 on ARM though (defined as a platform-specific register
905 // in ARM EABI).
906 if (Args.hasArg(options::OPT_ffixed_r9)) {
907 CmdArgs.push_back("-backend-option");
908 CmdArgs.push_back("-arm-reserve-r9");
909 }
910}
911
912// Get CPU and ABI names. They are not independent
913// so we have to calculate them together.
914static void getMipsCPUAndABI(const ArgList &Args,
915 const llvm::Triple &Triple,
916 StringRef &CPUName,
917 StringRef &ABIName) {
918 const char *DefMips32CPU = "mips32";
919 const char *DefMips64CPU = "mips64";
920
921 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
922 options::OPT_mcpu_EQ))
923 CPUName = A->getValue();
924
925 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
926 ABIName = A->getValue();
927 // Convert a GNU style Mips ABI name to the name
928 // accepted by LLVM Mips backend.
929 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
930 .Case("32", "o32")
931 .Case("64", "n64")
932 .Default(ABIName);
933 }
934
935 // Setup default CPU and ABI names.
936 if (CPUName.empty() && ABIName.empty()) {
937 switch (Triple.getArch()) {
938 default:
939 llvm_unreachable("Unexpected triple arch name");
940 case llvm::Triple::mips:
941 case llvm::Triple::mipsel:
942 CPUName = DefMips32CPU;
943 break;
944 case llvm::Triple::mips64:
945 case llvm::Triple::mips64el:
946 CPUName = DefMips64CPU;
947 break;
948 }
949 }
950
951 if (!ABIName.empty()) {
952 // Deduce CPU name from ABI name.
953 CPUName = llvm::StringSwitch<const char *>(ABIName)
954 .Cases("32", "o32", "eabi", DefMips32CPU)
955 .Cases("n32", "n64", "64", DefMips64CPU)
956 .Default("");
957 }
958 else if (!CPUName.empty()) {
959 // Deduce ABI name from CPU name.
960 ABIName = llvm::StringSwitch<const char *>(CPUName)
961 .Cases("mips32", "mips32r2", "o32")
962 .Cases("mips64", "mips64r2", "n64")
963 .Default("");
964 }
965
966 // FIXME: Warn on inconsistent cpu and abi usage.
967}
968
969// Convert ABI name to the GNU tools acceptable variant.
970static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
971 return llvm::StringSwitch<llvm::StringRef>(ABI)
972 .Case("o32", "32")
973 .Case("n64", "64")
974 .Default(ABI);
975}
976
977// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
978// and -mfloat-abi=.
979static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
980 StringRef FloatABI;
981 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
982 options::OPT_mhard_float,
983 options::OPT_mfloat_abi_EQ)) {
984 if (A->getOption().matches(options::OPT_msoft_float))
985 FloatABI = "soft";
986 else if (A->getOption().matches(options::OPT_mhard_float))
987 FloatABI = "hard";
988 else {
989 FloatABI = A->getValue();
990 if (FloatABI != "soft" && FloatABI != "hard") {
991 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
992 FloatABI = "hard";
993 }
994 }
995 }
996
997 // If unspecified, choose the default based on the platform.
998 if (FloatABI.empty()) {
999 // Assume "hard", because it's a default value used by gcc.
1000 // When we start to recognize specific target MIPS processors,
1001 // we will be able to select the default more correctly.
1002 FloatABI = "hard";
1003 }
1004
1005 return FloatABI;
1006}
1007
1008static void AddTargetFeature(const ArgList &Args,
1009 std::vector<const char *> &Features,
1010 OptSpecifier OnOpt, OptSpecifier OffOpt,
1011 StringRef FeatureName) {
1012 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1013 if (A->getOption().matches(OnOpt))
1014 Features.push_back(Args.MakeArgString("+" + FeatureName));
1015 else
1016 Features.push_back(Args.MakeArgString("-" + FeatureName));
1017 }
1018}
1019
1020static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1021 std::vector<const char *> &Features) {
1022 StringRef FloatABI = getMipsFloatABI(D, Args);
1023 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1024 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1025 // FIXME: Note, this is a hack. We need to pass the selected float
1026 // mode to the MipsTargetInfoBase to define appropriate macros there.
1027 // Now it is the only method.
1028 Features.push_back("+soft-float");
1029 }
1030
1031 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1032 if (StringRef(A->getValue()) == "2008")
1033 Features.push_back("+nan2008");
1034 }
1035
1036 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1037 options::OPT_mdouble_float, "single-float");
1038 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1039 "mips16");
1040 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1041 options::OPT_mno_micromips, "micromips");
1042 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1043 "dsp");
1044 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1045 "dspr2");
1046 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1047 "msa");
1048 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1049 "fp64");
1050}
1051
1052void Clang::AddMIPSTargetArgs(const ArgList &Args,
1053 ArgStringList &CmdArgs) const {
1054 const Driver &D = getToolChain().getDriver();
1055 StringRef CPUName;
1056 StringRef ABIName;
1057 const llvm::Triple &Triple = getToolChain().getTriple();
1058 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1059
1060 CmdArgs.push_back("-target-abi");
1061 CmdArgs.push_back(ABIName.data());
1062
1063 StringRef FloatABI = getMipsFloatABI(D, Args);
1064
1065 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1066
1067 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1068 // Floating point operations and argument passing are soft.
1069 CmdArgs.push_back("-msoft-float");
1070 CmdArgs.push_back("-mfloat-abi");
1071 CmdArgs.push_back("soft");
1072
1073 if (FloatABI == "hard" && IsMips16) {
1074 CmdArgs.push_back("-mllvm");
1075 CmdArgs.push_back("-mips16-hard-float");
1076 }
1077 }
1078 else {
1079 // Floating point operations and argument passing are hard.
1080 assert(FloatABI == "hard" && "Invalid float abi!");
1081 CmdArgs.push_back("-mfloat-abi");
1082 CmdArgs.push_back("hard");
1083 }
1084
1085 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1086 if (A->getOption().matches(options::OPT_mxgot)) {
1087 CmdArgs.push_back("-mllvm");
1088 CmdArgs.push_back("-mxgot");
1089 }
1090 }
1091
1092 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1093 options::OPT_mno_ldc1_sdc1)) {
1094 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1095 CmdArgs.push_back("-mllvm");
1096 CmdArgs.push_back("-mno-ldc1-sdc1");
1097 }
1098 }
1099
1100 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1101 options::OPT_mno_check_zero_division)) {
1102 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1103 CmdArgs.push_back("-mllvm");
1104 CmdArgs.push_back("-mno-check-zero-division");
1105 }
1106 }
1107
1108 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1109 StringRef v = A->getValue();
1110 CmdArgs.push_back("-mllvm");
1111 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1112 A->claim();
1113 }
1114}
1115
1116/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1117static std::string getPPCTargetCPU(const ArgList &Args) {
1118 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1119 StringRef CPUName = A->getValue();
1120
1121 if (CPUName == "native") {
1122 std::string CPU = llvm::sys::getHostCPUName();
1123 if (!CPU.empty() && CPU != "generic")
1124 return CPU;
1125 else
1126 return "";
1127 }
1128
1129 return llvm::StringSwitch<const char *>(CPUName)
1130 .Case("common", "generic")
1131 .Case("440", "440")
1132 .Case("440fp", "440")
1133 .Case("450", "450")
1134 .Case("601", "601")
1135 .Case("602", "602")
1136 .Case("603", "603")
1137 .Case("603e", "603e")
1138 .Case("603ev", "603ev")
1139 .Case("604", "604")
1140 .Case("604e", "604e")
1141 .Case("620", "620")
1142 .Case("630", "pwr3")
1143 .Case("G3", "g3")
1144 .Case("7400", "7400")
1145 .Case("G4", "g4")
1146 .Case("7450", "7450")
1147 .Case("G4+", "g4+")
1148 .Case("750", "750")
1149 .Case("970", "970")
1150 .Case("G5", "g5")
1151 .Case("a2", "a2")
1152 .Case("a2q", "a2q")
1153 .Case("e500mc", "e500mc")
1154 .Case("e5500", "e5500")
1155 .Case("power3", "pwr3")
1156 .Case("power4", "pwr4")
1157 .Case("power5", "pwr5")
1158 .Case("power5x", "pwr5x")
1159 .Case("power6", "pwr6")
1160 .Case("power6x", "pwr6x")
1161 .Case("power7", "pwr7")
1162 .Case("pwr3", "pwr3")
1163 .Case("pwr4", "pwr4")
1164 .Case("pwr5", "pwr5")
1165 .Case("pwr5x", "pwr5x")
1166 .Case("pwr6", "pwr6")
1167 .Case("pwr6x", "pwr6x")
1168 .Case("pwr7", "pwr7")
1169 .Case("powerpc", "ppc")
1170 .Case("powerpc64", "ppc64")
1171 .Case("powerpc64le", "ppc64le")
1172 .Default("");
1173 }
1174
1175 return "";
1176}
1177
1178static void getPPCTargetFeatures(const ArgList &Args,
1179 std::vector<const char *> &Features) {
1180 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1181 ie = Args.filtered_end();
1182 it != ie; ++it) {
1183 StringRef Name = (*it)->getOption().getName();
1184 (*it)->claim();
1185
1186 // Skip over "-m".
1187 assert(Name.startswith("m") && "Invalid feature name.");
1188 Name = Name.substr(1);
1189
1190 bool IsNegative = Name.startswith("no-");
1191 if (IsNegative)
1192 Name = Name.substr(3);
1193
1194 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1195 // pass the correct option to the backend while calling the frontend
1196 // option the same.
1197 // TODO: Change the LLVM backend option maybe?
1198 if (Name == "mfcrf")
1199 Name = "mfocrf";
1200
1201 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1202 }
1203
1204 // Altivec is a bit weird, allow overriding of the Altivec feature here.
1205 AddTargetFeature(Args, Features, options::OPT_faltivec,
1206 options::OPT_fno_altivec, "altivec");
1207}
1208
1209/// Get the (LLVM) name of the R600 gpu we are targeting.
1210static std::string getR600TargetGPU(const ArgList &Args) {
1211 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1212 const char *GPUName = A->getValue();
1213 return llvm::StringSwitch<const char *>(GPUName)
1214 .Cases("rv630", "rv635", "r600")
1215 .Cases("rv610", "rv620", "rs780", "rs880")
1216 .Case("rv740", "rv770")
1217 .Case("palm", "cedar")
1218 .Cases("sumo", "sumo2", "sumo")
1219 .Case("hemlock", "cypress")
1220 .Case("aruba", "cayman")
1221 .Default(GPUName);
1222 }
1223 return "";
1224}
1225
1226static void getSparcTargetFeatures(const ArgList &Args,
1227 std::vector<const char *> Features) {
1228 bool SoftFloatABI = true;
1229 if (Arg *A =
1230 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1231 if (A->getOption().matches(options::OPT_mhard_float))
1232 SoftFloatABI = false;
1233 }
1234 if (SoftFloatABI)
1235 Features.push_back("+soft-float");
1236}
1237
1238void Clang::AddSparcTargetArgs(const ArgList &Args,
1239 ArgStringList &CmdArgs) const {
1240 const Driver &D = getToolChain().getDriver();
1241
1242 // Select the float ABI as determined by -msoft-float, -mhard-float, and
1243 StringRef FloatABI;
1244 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1245 options::OPT_mhard_float)) {
1246 if (A->getOption().matches(options::OPT_msoft_float))
1247 FloatABI = "soft";
1248 else if (A->getOption().matches(options::OPT_mhard_float))
1249 FloatABI = "hard";
1250 }
1251
1252 // If unspecified, choose the default based on the platform.
1253 if (FloatABI.empty()) {
1254 // Assume "soft", but warn the user we are guessing.
1255 FloatABI = "soft";
1256 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1257 }
1258
1259 if (FloatABI == "soft") {
1260 // Floating point operations and argument passing are soft.
1261 //
1262 // FIXME: This changes CPP defines, we need -target-soft-float.
1263 CmdArgs.push_back("-msoft-float");
1264 } else {
1265 assert(FloatABI == "hard" && "Invalid float abi!");
1266 CmdArgs.push_back("-mhard-float");
1267 }
1268}
1269
1270static const char *getSystemZTargetCPU(const ArgList &Args) {
1271 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1272 return A->getValue();
1273 return "z10";
1274}
1275
1276static const char *getX86TargetCPU(const ArgList &Args,
1277 const llvm::Triple &Triple) {
1278 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1279 if (StringRef(A->getValue()) != "native") {
1280 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
1281 return "core-avx2";
1282
1283 return A->getValue();
1284 }
1285
1286 // FIXME: Reject attempts to use -march=native unless the target matches
1287 // the host.
1288 //
1289 // FIXME: We should also incorporate the detected target features for use
1290 // with -native.
1291 std::string CPU = llvm::sys::getHostCPUName();
1292 if (!CPU.empty() && CPU != "generic")
1293 return Args.MakeArgString(CPU);
1294 }
1295
1296 // Select the default CPU if none was given (or detection failed).
1297
1298 if (Triple.getArch() != llvm::Triple::x86_64 &&
1299 Triple.getArch() != llvm::Triple::x86)
1300 return 0; // This routine is only handling x86 targets.
1301
1302 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1303
1304 // FIXME: Need target hooks.
1305 if (Triple.isOSDarwin()) {
1306 if (Triple.getArchName() == "x86_64h")
1307 return "core-avx2";
1308 return Is64Bit ? "core2" : "yonah";
1309 }
1310
1311 // All x86 devices running Android have core2 as their common
1312 // denominator. This makes a better choice than pentium4.
1313 if (Triple.getEnvironment() == llvm::Triple::Android)
1314 return "core2";
1315
1316 // Everything else goes to x86-64 in 64-bit mode.
1317 if (Is64Bit)
1318 return "x86-64";
1319
1320 switch (Triple.getOS()) {
1321 case llvm::Triple::FreeBSD:
1322 case llvm::Triple::NetBSD:
1323 case llvm::Triple::OpenBSD:
1324 return "i486";
1325 case llvm::Triple::Haiku:
1326 return "i586";
1327 case llvm::Triple::Bitrig:
1328 return "i686";
1329 default:
1330 // Fallback to p4.
1331 return "pentium4";
1332 }
1333}
1334
1335static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1336 switch(T.getArch()) {
1337 default:
1338 return "";
1339
1340 case llvm::Triple::aarch64:
1341 return getAArch64TargetCPU(Args, T);
1342
1343 case llvm::Triple::arm:
1344 case llvm::Triple::thumb:
1345 return getARMTargetCPU(Args, T);
1346
1347 case llvm::Triple::mips:
1348 case llvm::Triple::mipsel:
1349 case llvm::Triple::mips64:
1350 case llvm::Triple::mips64el: {
1351 StringRef CPUName;
1352 StringRef ABIName;
1353 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1354 return CPUName;
1355 }
1356
1357 case llvm::Triple::ppc:
1358 case llvm::Triple::ppc64:
1359 case llvm::Triple::ppc64le: {
1360 std::string TargetCPUName = getPPCTargetCPU(Args);
1361 // LLVM may default to generating code for the native CPU,
1362 // but, like gcc, we default to a more generic option for
1363 // each architecture. (except on Darwin)
1364 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1365 if (T.getArch() == llvm::Triple::ppc64)
1366 TargetCPUName = "ppc64";
1367 else if (T.getArch() == llvm::Triple::ppc64le)
1368 TargetCPUName = "ppc64le";
1369 else
1370 TargetCPUName = "ppc";
1371 }
1372 return TargetCPUName;
1373 }
1374
1375 case llvm::Triple::sparc:
1376 case llvm::Triple::sparcv9:
1377 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1378 return A->getValue();
1379 return "";
1380
1381 case llvm::Triple::x86:
1382 case llvm::Triple::x86_64:
1383 return getX86TargetCPU(Args, T);
1384
1385 case llvm::Triple::hexagon:
1386 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1387
1388 case llvm::Triple::systemz:
1389 return getSystemZTargetCPU(Args);
1390
1391 case llvm::Triple::r600:
1392 return getR600TargetGPU(Args);
1393 }
1394}
1395
1396static void getX86TargetFeatures(const llvm::Triple &Triple,
1397 const ArgList &Args,
1398 std::vector<const char *> &Features) {
1399 if (Triple.getArchName() == "x86_64h") {
1400 // x86_64h implies quite a few of the more modern subtarget features
1401 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1402 Features.push_back("-rdrnd");
1403 Features.push_back("-aes");
1404 Features.push_back("-pclmul");
1405 Features.push_back("-rtm");
1406 Features.push_back("-hle");
1407 Features.push_back("-fsgsbase");
1408 }
1409
1410 // Now add any that the user explicitly requested on the command line,
1411 // which may override the defaults.
1412 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1413 ie = Args.filtered_end();
1414 it != ie; ++it) {
1415 StringRef Name = (*it)->getOption().getName();
1416 (*it)->claim();
1417
1418 // Skip over "-m".
1419 assert(Name.startswith("m") && "Invalid feature name.");
1420 Name = Name.substr(1);
1421
1422 bool IsNegative = Name.startswith("no-");
1423 if (IsNegative)
1424 Name = Name.substr(3);
1425
1426 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1427 }
1428}
1429
1430void Clang::AddX86TargetArgs(const ArgList &Args,
1431 ArgStringList &CmdArgs) const {
1432 if (!Args.hasFlag(options::OPT_mred_zone,
1433 options::OPT_mno_red_zone,
1434 true) ||
1435 Args.hasArg(options::OPT_mkernel) ||
1436 Args.hasArg(options::OPT_fapple_kext))
1437 CmdArgs.push_back("-disable-red-zone");
1438
1439 // Default to avoid implicit floating-point for kernel/kext code, but allow
1440 // that to be overridden with -mno-soft-float.
1441 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1442 Args.hasArg(options::OPT_fapple_kext));
1443 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1444 options::OPT_mno_soft_float,
1445 options::OPT_mimplicit_float,
1446 options::OPT_mno_implicit_float)) {
1447 const Option &O = A->getOption();
1448 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1449 O.matches(options::OPT_msoft_float));
1450 }
1451 if (NoImplicitFloat)
1452 CmdArgs.push_back("-no-implicit-float");
1453}
1454
1455static inline bool HasPICArg(const ArgList &Args) {
1456 return Args.hasArg(options::OPT_fPIC)
1457 || Args.hasArg(options::OPT_fpic);
1458}
1459
1460static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1461 return Args.getLastArg(options::OPT_G,
1462 options::OPT_G_EQ,
1463 options::OPT_msmall_data_threshold_EQ);
1464}
1465
1466static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1467 std::string value;
1468 if (HasPICArg(Args))
1469 value = "0";
1470 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1471 value = A->getValue();
1472 A->claim();
1473 }
1474 return value;
1475}
1476
1477void Clang::AddHexagonTargetArgs(const ArgList &Args,
1478 ArgStringList &CmdArgs) const {
1479 CmdArgs.push_back("-fno-signed-char");
1480 CmdArgs.push_back("-mqdsp6-compat");
1481 CmdArgs.push_back("-Wreturn-type");
1482
1483 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1484 if (!SmallDataThreshold.empty()) {
1485 CmdArgs.push_back ("-mllvm");
1486 CmdArgs.push_back(Args.MakeArgString(
1487 "-hexagon-small-data-threshold=" + SmallDataThreshold));
1488 }
1489
1490 if (!Args.hasArg(options::OPT_fno_short_enums))
1491 CmdArgs.push_back("-fshort-enums");
1492 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1493 CmdArgs.push_back ("-mllvm");
1494 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1495 }
1496 CmdArgs.push_back ("-mllvm");
1497 CmdArgs.push_back ("-machine-sink-split=0");
1498}
1499
1500static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1501 std::vector<const char *> &Features) {
1502 // Honor -mfpu=.
1503 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
1504 getAArch64FPUFeatures(D, A, Args, Features);
1505}
1506
1507static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1508 const ArgList &Args, ArgStringList &CmdArgs) {
1509 std::vector<const char *> Features;
1510 switch (Triple.getArch()) {
1511 default:
1512 break;
1513 case llvm::Triple::mips:
1514 case llvm::Triple::mipsel:
1515 case llvm::Triple::mips64:
1516 case llvm::Triple::mips64el:
1517 getMIPSTargetFeatures(D, Args, Features);
1518 break;
1519
1520 case llvm::Triple::arm:
1521 case llvm::Triple::thumb:
1522 getARMTargetFeatures(D, Triple, Args, Features);
1523 break;
1524
1525 case llvm::Triple::ppc:
1526 case llvm::Triple::ppc64:
1527 case llvm::Triple::ppc64le:
1528 getPPCTargetFeatures(Args, Features);
1529 break;
1530 case llvm::Triple::sparc:
1531 getSparcTargetFeatures(Args, Features);
1532 break;
1533 case llvm::Triple::aarch64:
1534 getAArch64TargetFeatures(D, Args, Features);
1535 break;
1536 case llvm::Triple::x86:
1537 case llvm::Triple::x86_64:
1538 getX86TargetFeatures(Triple, Args, Features);
1539 break;
1540 }
1541
1542 // Find the last of each feature.
1543 llvm::StringMap<unsigned> LastOpt;
1544 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1545 const char *Name = Features[I];
1546 assert(Name[0] == '-' || Name[0] == '+');
1547 LastOpt[Name + 1] = I;
1548 }
1549
1550 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1551 // If this feature was overridden, ignore it.
1552 const char *Name = Features[I];
1553 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1554 assert(LastI != LastOpt.end());
1555 unsigned Last = LastI->second;
1556 if (Last != I)
1557 continue;
1558
1559 CmdArgs.push_back("-target-feature");
1560 CmdArgs.push_back(Name);
1561 }
1562}
1563
1564static bool
1565shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1566 const llvm::Triple &Triple) {
1567 // We use the zero-cost exception tables for Objective-C if the non-fragile
1568 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1569 // later.
1570 if (runtime.isNonFragile())
1571 return true;
1572
1573 if (!Triple.isOSDarwin())
1574 return false;
1575
1576 return (!Triple.isMacOSXVersionLT(10,5) &&
1577 (Triple.getArch() == llvm::Triple::x86_64 ||
1578 Triple.getArch() == llvm::Triple::arm));
1579}
1580
1581/// addExceptionArgs - Adds exception related arguments to the driver command
1582/// arguments. There's a master flag, -fexceptions and also language specific
1583/// flags to enable/disable C++ and Objective-C exceptions.
1584/// This makes it possible to for example disable C++ exceptions but enable
1585/// Objective-C exceptions.
1586static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1587 const llvm::Triple &Triple,
1588 bool KernelOrKext,
1589 const ObjCRuntime &objcRuntime,
1590 ArgStringList &CmdArgs) {
1591 if (KernelOrKext) {
1592 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1593 // arguments now to avoid warnings about unused arguments.
1594 Args.ClaimAllArgs(options::OPT_fexceptions);
1595 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1596 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1599 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1600 return;
1601 }
1602
1603 // Exceptions are enabled by default.
1604 bool ExceptionsEnabled = true;
1605
1606 // This keeps track of whether exceptions were explicitly turned on or off.
1607 bool DidHaveExplicitExceptionFlag = false;
1608
1609 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1610 options::OPT_fno_exceptions)) {
1611 if (A->getOption().matches(options::OPT_fexceptions))
1612 ExceptionsEnabled = true;
1613 else
1614 ExceptionsEnabled = false;
1615
1616 DidHaveExplicitExceptionFlag = true;
1617 }
1618
1619 bool ShouldUseExceptionTables = false;
1620
1621 // Exception tables and cleanups can be enabled with -fexceptions even if the
1622 // language itself doesn't support exceptions.
1623 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1624 ShouldUseExceptionTables = true;
1625
1626 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1627 // is not necessarily sensible, but follows GCC.
1628 if (types::isObjC(InputType) &&
1629 Args.hasFlag(options::OPT_fobjc_exceptions,
1630 options::OPT_fno_objc_exceptions,
1631 true)) {
1632 CmdArgs.push_back("-fobjc-exceptions");
1633
1634 ShouldUseExceptionTables |=
1635 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1636 }
1637
1638 if (types::isCXX(InputType)) {
1639 bool CXXExceptionsEnabled = ExceptionsEnabled;
1640
1641 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1642 options::OPT_fno_cxx_exceptions,
1643 options::OPT_fexceptions,
1644 options::OPT_fno_exceptions)) {
1645 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1646 CXXExceptionsEnabled = true;
1647 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1648 CXXExceptionsEnabled = false;
1649 }
1650
1651 if (CXXExceptionsEnabled) {
1652 CmdArgs.push_back("-fcxx-exceptions");
1653
1654 ShouldUseExceptionTables = true;
1655 }
1656 }
1657
1658 if (ShouldUseExceptionTables)
1659 CmdArgs.push_back("-fexceptions");
1660}
1661
1662static bool ShouldDisableAutolink(const ArgList &Args,
1663 const ToolChain &TC) {
1664 bool Default = true;
1665 if (TC.getTriple().isOSDarwin()) {
1666 // The native darwin assembler doesn't support the linker_option directives,
1667 // so we disable them if we think the .s file will be passed to it.
1668 Default = TC.useIntegratedAs();
1669 }
1670 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1671 Default);
1672}
1673
1674static bool ShouldDisableCFI(const ArgList &Args,
1675 const ToolChain &TC) {
1676 bool Default = true;
1677 if (TC.getTriple().isOSDarwin()) {
1678 // The native darwin assembler doesn't support cfi directives, so
1679 // we disable them if we think the .s file will be passed to it.
1680 Default = TC.useIntegratedAs();
1681 }
1682 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1683 options::OPT_fno_dwarf2_cfi_asm,
1684 Default);
1685}
1686
1687static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1688 const ToolChain &TC) {
1689 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1690 options::OPT_fno_dwarf_directory_asm,
1691 TC.useIntegratedAs());
1692 return !UseDwarfDirectory;
1693}
1694
1695/// \brief Check whether the given input tree contains any compilation actions.
1696static bool ContainsCompileAction(const Action *A) {
1697 if (isa<CompileJobAction>(A))
1698 return true;
1699
1700 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1701 if (ContainsCompileAction(*it))
1702 return true;
1703
1704 return false;
1705}
1706
1707/// \brief Check if -relax-all should be passed to the internal assembler.
1708/// This is done by default when compiling non-assembler source with -O0.
1709static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1710 bool RelaxDefault = true;
1711
1712 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1713 RelaxDefault = A->getOption().matches(options::OPT_O0);
1714
1715 if (RelaxDefault) {
1716 RelaxDefault = false;
1717 for (ActionList::const_iterator it = C.getActions().begin(),
1718 ie = C.getActions().end(); it != ie; ++it) {
1719 if (ContainsCompileAction(*it)) {
1720 RelaxDefault = true;
1721 break;
1722 }
1723 }
1724 }
1725
1726 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1727 RelaxDefault);
1728}
1729
1730static void CollectArgsForIntegratedAssembler(Compilation &C,
1731 const ArgList &Args,
1732 ArgStringList &CmdArgs,
1733 const Driver &D) {
1734 if (UseRelaxAll(C, Args))
1735 CmdArgs.push_back("-mrelax-all");
1736
1737 // When passing -I arguments to the assembler we sometimes need to
1738 // unconditionally take the next argument. For example, when parsing
1739 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1740 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1741 // arg after parsing the '-I' arg.
1742 bool TakeNextArg = false;
1743
1744 // When using an integrated assembler, translate -Wa, and -Xassembler
1745 // options.
1746 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1747 options::OPT_Xassembler),
1748 ie = Args.filtered_end(); it != ie; ++it) {
1749 const Arg *A = *it;
1750 A->claim();
1751
1752 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1753 StringRef Value = A->getValue(i);
1754 if (TakeNextArg) {
1755 CmdArgs.push_back(Value.data());
1756 TakeNextArg = false;
1757 continue;
1758 }
1759
1760 if (Value == "-force_cpusubtype_ALL") {
1761 // Do nothing, this is the default and we don't support anything else.
1762 } else if (Value == "-L") {
1763 CmdArgs.push_back("-msave-temp-labels");
1764 } else if (Value == "--fatal-warnings") {
1765 CmdArgs.push_back("-mllvm");
1766 CmdArgs.push_back("-fatal-assembler-warnings");
1767 } else if (Value == "--noexecstack") {
1768 CmdArgs.push_back("-mnoexecstack");
1769 } else if (Value.startswith("-I")) {
1770 CmdArgs.push_back(Value.data());
1771 // We need to consume the next argument if the current arg is a plain
1772 // -I. The next arg will be the include directory.
1773 if (Value == "-I")
1774 TakeNextArg = true;
1775 } else {
1776 D.Diag(diag::err_drv_unsupported_option_argument)
1777 << A->getOption().getName() << Value;
1778 }
1779 }
1780 }
1781}
1782
1783static void addProfileRTLinux(
1784 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1785 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1786 Args.hasArg(options::OPT_fprofile_generate) ||
1787 Args.hasArg(options::OPT_fcreate_profile) ||
1788 Args.hasArg(options::OPT_coverage)))
1789 return;
1790
1791 // The profile runtime is located in the Linux library directory and has name
1792 // "libclang_rt.profile-<ArchName>.a".
1793 SmallString<128> LibProfile(TC.getDriver().ResourceDir);
1794 llvm::sys::path::append(
1795 LibProfile, "lib", "linux",
1796 Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
1797
1798 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1799}
1800
1801static void addSanitizerRTLinkFlagsLinux(
1802 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
1803 const StringRef Sanitizer, bool BeforeLibStdCXX,
1804 bool ExportSymbols = true) {
1805 // Sanitizer runtime is located in the Linux library directory and
1806 // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1807 SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1808 llvm::sys::path::append(
1809 LibSanitizer, "lib", "linux",
1810 (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
1811
1812 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1813 // etc.) so that the linker picks custom versions of the global 'operator
1814 // new' and 'operator delete' symbols. We take the extreme (but simple)
1815 // strategy of inserting it at the front of the link command. It also
1816 // needs to be forced to end up in the executable, so wrap it in
1817 // whole-archive.
1818 SmallVector<const char *, 3> LibSanitizerArgs;
1819 LibSanitizerArgs.push_back("-whole-archive");
1820 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1821 LibSanitizerArgs.push_back("-no-whole-archive");
1822
1823 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1824 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1825
1826 CmdArgs.push_back("-lpthread");
1827 CmdArgs.push_back("-lrt");
1828 CmdArgs.push_back("-ldl");
1829 CmdArgs.push_back("-lm");
1830
1831 // If possible, use a dynamic symbols file to export the symbols from the
1832 // runtime library. If we can't do so, use -export-dynamic instead to export
1833 // all symbols from the binary.
1834 if (ExportSymbols) {
1835 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1836 CmdArgs.push_back(
1837 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1838 else
1839 CmdArgs.push_back("-export-dynamic");
1840 }
1841}
1842
1843/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1844/// This needs to be called before we add the C run-time (malloc, etc).
1845static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1846 ArgStringList &CmdArgs) {
1847 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
1848 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1849 llvm::sys::path::append(LibAsan, "lib", "linux",
1850 (Twine("libclang_rt.asan-") +
1851 TC.getArchName() + "-android.so"));
1852 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
1853 } else {
1854 if (!Args.hasArg(options::OPT_shared))
1855 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
1856 }
1857}
1858
1859/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1860/// This needs to be called before we add the C run-time (malloc, etc).
1861static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1862 ArgStringList &CmdArgs) {
1863 if (!Args.hasArg(options::OPT_shared))
1864 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
1865}
1866
1867/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1868/// This needs to be called before we add the C run-time (malloc, etc).
1869static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1870 ArgStringList &CmdArgs) {
1871 if (!Args.hasArg(options::OPT_shared))
1872 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
1873}
1874
1875/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1876/// This needs to be called before we add the C run-time (malloc, etc).
1877static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args,
1878 ArgStringList &CmdArgs) {
1879 if (!Args.hasArg(options::OPT_shared))
1880 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true);
1881}
1882
1883/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1884/// (Linux).
1885static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1886 ArgStringList &CmdArgs, bool IsCXX,
1887 bool HasOtherSanitizerRt) {
1888 // Need a copy of sanitizer_common. This could come from another sanitizer
1889 // runtime; if we're not including one, include our own copy.
1890 if (!HasOtherSanitizerRt)
1891 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false);
1892
1893 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
1894
1895 // Only include the bits of the runtime which need a C++ ABI library if
1896 // we're linking in C++ mode.
1897 if (IsCXX)
1898 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false);
1899}
1900
1901static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
1902 ArgStringList &CmdArgs) {
1903 if (!Args.hasArg(options::OPT_shared))
1904 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
1905}
1906
1907static bool shouldUseFramePointerForTarget(const ArgList &Args,
1908 const llvm::Triple &Triple) {
1909 switch (Triple.getArch()) {
1910 // Don't use a frame pointer on linux if optimizing for certain targets.
1911 case llvm::Triple::mips64:
1912 case llvm::Triple::mips64el:
1913 case llvm::Triple::mips:
1914 case llvm::Triple::mipsel:
1915 case llvm::Triple::systemz:
1916 case llvm::Triple::x86:
1917 case llvm::Triple::x86_64:
1918 if (Triple.isOSLinux())
1919 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1920 if (!A->getOption().matches(options::OPT_O0))
1921 return false;
1922 return true;
1923 case llvm::Triple::xcore:
1924 return false;
1925 default:
1926 return true;
1927 }
1928}
1929
1930static bool shouldUseFramePointer(const ArgList &Args,
1931 const llvm::Triple &Triple) {
1932 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1933 options::OPT_fomit_frame_pointer))
1934 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1935
1936 return shouldUseFramePointerForTarget(Args, Triple);
1937}
1938
1939static bool shouldUseLeafFramePointer(const ArgList &Args,
1940 const llvm::Triple &Triple) {
1941 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1942 options::OPT_momit_leaf_frame_pointer))
1943 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1944
1945 return shouldUseFramePointerForTarget(Args, Triple);
1946}
1947
1948/// Add a CC1 option to specify the debug compilation directory.
1949static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1950 SmallString<128> cwd;
1951 if (!llvm::sys::fs::current_path(cwd)) {
1952 CmdArgs.push_back("-fdebug-compilation-dir");
1953 CmdArgs.push_back(Args.MakeArgString(cwd));
1954 }
1955}
1956
1957static const char *SplitDebugName(const ArgList &Args,
1958 const InputInfoList &Inputs) {
1959 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1960 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1961 SmallString<128> T(FinalOutput->getValue());
1962 llvm::sys::path::replace_extension(T, "dwo");
1963 return Args.MakeArgString(T);
1964 } else {
1965 // Use the compilation dir.
1966 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1967 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1968 llvm::sys::path::replace_extension(F, "dwo");
1969 T += F;
1970 return Args.MakeArgString(F);
1971 }
1972}
1973
1974static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1975 const Tool &T, const JobAction &JA,
1976 const ArgList &Args, const InputInfo &Output,
1977 const char *OutFile) {
1978 ArgStringList ExtractArgs;
1979 ExtractArgs.push_back("--extract-dwo");
1980
1981 ArgStringList StripArgs;
1982 StripArgs.push_back("--strip-dwo");
1983
1984 // Grabbing the output of the earlier compile step.
1985 StripArgs.push_back(Output.getFilename());
1986 ExtractArgs.push_back(Output.getFilename());
1987 ExtractArgs.push_back(OutFile);
1988
1989 const char *Exec =
1990 Args.MakeArgString(TC.GetProgramPath("objcopy"));
1991
1992 // First extract the dwo sections.
1993 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
1994
1995 // Then remove them from the original .o file.
1996 C.addCommand(new Command(JA, T, Exec, StripArgs));
1997}
1998
| 1//===--- Tools.cpp - Tools Implementations --------------------------------===//
2//
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"
11#include "InputInfo.h"
12#include "ToolChains.h"
13#include "clang/Basic/ObjCRuntime.h"
14#include "clang/Basic/Version.h"
15#include "clang/Driver/Action.h"
16#include "clang/Driver/Compilation.h"
17#include "clang/Driver/Driver.h"
18#include "clang/Driver/DriverDiagnostic.h"
19#include "clang/Driver/Job.h"
20#include "clang/Driver/Options.h"
21#include "clang/Driver/SanitizerArgs.h"
22#include "clang/Driver/ToolChain.h"
23#include "clang/Driver/Util.h"
24#include "clang/Sema/SemaDiagnostic.h"
25#include "llvm/ADT/SmallString.h"
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/ADT/StringSwitch.h"
28#include "llvm/ADT/Twine.h"
29#include "llvm/Option/Arg.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Option/Option.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/FileSystem.h"
34#include "llvm/Support/Format.h"
35#include "llvm/Support/Host.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/Program.h"
38#include "llvm/Support/Process.h"
39#include "llvm/Support/raw_ostream.h"
40#include <sys/stat.h>
41
42using namespace clang::driver;
43using namespace clang::driver::tools;
44using namespace clang;
45using namespace llvm::opt;
46
47/// CheckPreprocessingOptions - Perform some validation of preprocessing
48/// arguments that is shared with gcc.
49static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
50 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
51 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
52 D.Diag(diag::err_drv_argument_only_allowed_with)
53 << A->getAsString(Args) << "-E";
54}
55
56/// CheckCodeGenerationOptions - Perform some validation of code generation
57/// arguments that is shared with gcc.
58static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
59 // In gcc, only ARM checks this, but it seems reasonable to check universally.
60 if (Args.hasArg(options::OPT_static))
61 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
62 options::OPT_mdynamic_no_pic))
63 D.Diag(diag::err_drv_argument_not_allowed_with)
64 << A->getAsString(Args) << "-static";
65}
66
67// Quote target names for inclusion in GNU Make dependency files.
68// Only the characters '$', '#', ' ', '\t' are quoted.
69static void QuoteTarget(StringRef Target,
70 SmallVectorImpl<char> &Res) {
71 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
72 switch (Target[i]) {
73 case ' ':
74 case '\t':
75 // Escape the preceding backslashes
76 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
77 Res.push_back('\\');
78
79 // Escape the space/tab
80 Res.push_back('\\');
81 break;
82 case '$':
83 Res.push_back('$');
84 break;
85 case '#':
86 Res.push_back('\\');
87 break;
88 default:
89 break;
90 }
91
92 Res.push_back(Target[i]);
93 }
94}
95
96static void addDirectoryList(const ArgList &Args,
97 ArgStringList &CmdArgs,
98 const char *ArgName,
99 const char *EnvVar) {
100 const char *DirList = ::getenv(EnvVar);
101 bool CombinedArg = false;
102
103 if (!DirList)
104 return; // Nothing to do.
105
106 StringRef Name(ArgName);
107 if (Name.equals("-I") || Name.equals("-L"))
108 CombinedArg = true;
109
110 StringRef Dirs(DirList);
111 if (Dirs.empty()) // Empty string should not add '.'.
112 return;
113
114 StringRef::size_type Delim;
115 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
116 if (Delim == 0) { // Leading colon.
117 if (CombinedArg) {
118 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
119 } else {
120 CmdArgs.push_back(ArgName);
121 CmdArgs.push_back(".");
122 }
123 } else {
124 if (CombinedArg) {
125 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
126 } else {
127 CmdArgs.push_back(ArgName);
128 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
129 }
130 }
131 Dirs = Dirs.substr(Delim + 1);
132 }
133
134 if (Dirs.empty()) { // Trailing colon.
135 if (CombinedArg) {
136 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
137 } else {
138 CmdArgs.push_back(ArgName);
139 CmdArgs.push_back(".");
140 }
141 } else { // Add the last path.
142 if (CombinedArg) {
143 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
144 } else {
145 CmdArgs.push_back(ArgName);
146 CmdArgs.push_back(Args.MakeArgString(Dirs));
147 }
148 }
149}
150
151static void AddLinkerInputs(const ToolChain &TC,
152 const InputInfoList &Inputs, const ArgList &Args,
153 ArgStringList &CmdArgs) {
154 const Driver &D = TC.getDriver();
155
156 // Add extra linker input arguments which are not treated as inputs
157 // (constructed via -Xarch_).
158 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
159
160 for (InputInfoList::const_iterator
161 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
162 const InputInfo &II = *it;
163
164 if (!TC.HasNativeLLVMSupport()) {
165 // Don't try to pass LLVM inputs unless we have native support.
166 if (II.getType() == types::TY_LLVM_IR ||
167 II.getType() == types::TY_LTO_IR ||
168 II.getType() == types::TY_LLVM_BC ||
169 II.getType() == types::TY_LTO_BC)
170 D.Diag(diag::err_drv_no_linker_llvm_support)
171 << TC.getTripleString();
172 }
173
174 // Add filenames immediately.
175 if (II.isFilename()) {
176 CmdArgs.push_back(II.getFilename());
177 continue;
178 }
179
180 // Otherwise, this is a linker input argument.
181 const Arg &A = II.getInputArg();
182
183 // Handle reserved library options.
184 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
185 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
186 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
187 TC.AddCCKextLibArgs(Args, CmdArgs);
188 } else
189 A.renderAsInput(Args, CmdArgs);
190 }
191
192 // LIBRARY_PATH - included following the user specified library paths.
193 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
194}
195
196/// \brief Determine whether Objective-C automated reference counting is
197/// enabled.
198static bool isObjCAutoRefCount(const ArgList &Args) {
199 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
200}
201
202/// \brief Determine whether we are linking the ObjC runtime.
203static bool isObjCRuntimeLinked(const ArgList &Args) {
204 if (isObjCAutoRefCount(Args)) {
205 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
206 return true;
207 }
208 return Args.hasArg(options::OPT_fobjc_link_runtime);
209}
210
211static void addProfileRT(const ToolChain &TC, const ArgList &Args,
212 ArgStringList &CmdArgs,
213 llvm::Triple Triple) {
214 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
215 Args.hasArg(options::OPT_fprofile_generate) ||
216 Args.hasArg(options::OPT_fcreate_profile) ||
217 Args.hasArg(options::OPT_coverage)))
218 return;
219
220 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
221 // the link line. We cannot do the same thing because unlike gcov there is a
222 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
223 // not supported by old linkers.
224 std::string ProfileRT =
225 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
226
227 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
228}
229
230static bool forwardToGCC(const Option &O) {
231 // Don't forward inputs from the original command line. They are added from
232 // InputInfoList.
233 return O.getKind() != Option::InputClass &&
234 !O.hasFlag(options::DriverOption) &&
235 !O.hasFlag(options::LinkerInput);
236}
237
238void Clang::AddPreprocessingOptions(Compilation &C,
239 const JobAction &JA,
240 const Driver &D,
241 const ArgList &Args,
242 ArgStringList &CmdArgs,
243 const InputInfo &Output,
244 const InputInfoList &Inputs) const {
245 Arg *A;
246
247 CheckPreprocessingOptions(D, Args);
248
249 Args.AddLastArg(CmdArgs, options::OPT_C);
250 Args.AddLastArg(CmdArgs, options::OPT_CC);
251
252 // Handle dependency file generation.
253 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
254 (A = Args.getLastArg(options::OPT_MD)) ||
255 (A = Args.getLastArg(options::OPT_MMD))) {
256 // Determine the output location.
257 const char *DepFile;
258 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
259 DepFile = MF->getValue();
260 C.addFailureResultFile(DepFile, &JA);
261 } else if (Output.getType() == types::TY_Dependencies) {
262 DepFile = Output.getFilename();
263 } else if (A->getOption().matches(options::OPT_M) ||
264 A->getOption().matches(options::OPT_MM)) {
265 DepFile = "-";
266 } else {
267 DepFile = getDependencyFileName(Args, Inputs);
268 C.addFailureResultFile(DepFile, &JA);
269 }
270 CmdArgs.push_back("-dependency-file");
271 CmdArgs.push_back(DepFile);
272
273 // Add a default target if one wasn't specified.
274 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
275 const char *DepTarget;
276
277 // If user provided -o, that is the dependency target, except
278 // when we are only generating a dependency file.
279 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
280 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
281 DepTarget = OutputOpt->getValue();
282 } else {
283 // Otherwise derive from the base input.
284 //
285 // FIXME: This should use the computed output file location.
286 SmallString<128> P(Inputs[0].getBaseInput());
287 llvm::sys::path::replace_extension(P, "o");
288 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
289 }
290
291 CmdArgs.push_back("-MT");
292 SmallString<128> Quoted;
293 QuoteTarget(DepTarget, Quoted);
294 CmdArgs.push_back(Args.MakeArgString(Quoted));
295 }
296
297 if (A->getOption().matches(options::OPT_M) ||
298 A->getOption().matches(options::OPT_MD))
299 CmdArgs.push_back("-sys-header-deps");
300 }
301
302 if (Args.hasArg(options::OPT_MG)) {
303 if (!A || A->getOption().matches(options::OPT_MD) ||
304 A->getOption().matches(options::OPT_MMD))
305 D.Diag(diag::err_drv_mg_requires_m_or_mm);
306 CmdArgs.push_back("-MG");
307 }
308
309 Args.AddLastArg(CmdArgs, options::OPT_MP);
310
311 // Convert all -MQ <target> args to -MT <quoted target>
312 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
313 options::OPT_MQ),
314 ie = Args.filtered_end(); it != ie; ++it) {
315 const Arg *A = *it;
316 A->claim();
317
318 if (A->getOption().matches(options::OPT_MQ)) {
319 CmdArgs.push_back("-MT");
320 SmallString<128> Quoted;
321 QuoteTarget(A->getValue(), Quoted);
322 CmdArgs.push_back(Args.MakeArgString(Quoted));
323
324 // -MT flag - no change
325 } else {
326 A->render(Args, CmdArgs);
327 }
328 }
329
330 // Add -i* options, and automatically translate to
331 // -include-pch/-include-pth for transparent PCH support. It's
332 // wonky, but we include looking for .gch so we can support seamless
333 // replacement into a build system already set up to be generating
334 // .gch files.
335 bool RenderedImplicitInclude = false;
336 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
337 ie = Args.filtered_end(); it != ie; ++it) {
338 const Arg *A = it;
339
340 if (A->getOption().matches(options::OPT_include)) {
341 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
342 RenderedImplicitInclude = true;
343
344 // Use PCH if the user requested it.
345 bool UsePCH = D.CCCUsePCH;
346
347 bool FoundPTH = false;
348 bool FoundPCH = false;
349 SmallString<128> P(A->getValue());
350 // We want the files to have a name like foo.h.pch. Add a dummy extension
351 // so that replace_extension does the right thing.
352 P += ".dummy";
353 if (UsePCH) {
354 llvm::sys::path::replace_extension(P, "pch");
355 if (llvm::sys::fs::exists(P.str()))
356 FoundPCH = true;
357 }
358
359 if (!FoundPCH) {
360 llvm::sys::path::replace_extension(P, "pth");
361 if (llvm::sys::fs::exists(P.str()))
362 FoundPTH = true;
363 }
364
365 if (!FoundPCH && !FoundPTH) {
366 llvm::sys::path::replace_extension(P, "gch");
367 if (llvm::sys::fs::exists(P.str())) {
368 FoundPCH = UsePCH;
369 FoundPTH = !UsePCH;
370 }
371 }
372
373 if (FoundPCH || FoundPTH) {
374 if (IsFirstImplicitInclude) {
375 A->claim();
376 if (UsePCH)
377 CmdArgs.push_back("-include-pch");
378 else
379 CmdArgs.push_back("-include-pth");
380 CmdArgs.push_back(Args.MakeArgString(P.str()));
381 continue;
382 } else {
383 // Ignore the PCH if not first on command line and emit warning.
384 D.Diag(diag::warn_drv_pch_not_first_include)
385 << P.str() << A->getAsString(Args);
386 }
387 }
388 }
389
390 // Not translated, render as usual.
391 A->claim();
392 A->render(Args, CmdArgs);
393 }
394
395 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
396 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
397 options::OPT_index_header_map);
398
399 // Add -Wp, and -Xassembler if using the preprocessor.
400
401 // FIXME: There is a very unfortunate problem here, some troubled
402 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
403 // really support that we would have to parse and then translate
404 // those options. :(
405 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
406 options::OPT_Xpreprocessor);
407
408 // -I- is a deprecated GCC feature, reject it.
409 if (Arg *A = Args.getLastArg(options::OPT_I_))
410 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
411
412 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
413 // -isysroot to the CC1 invocation.
414 StringRef sysroot = C.getSysRoot();
415 if (sysroot != "") {
416 if (!Args.hasArg(options::OPT_isysroot)) {
417 CmdArgs.push_back("-isysroot");
418 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
419 }
420 }
421
422 // Parse additional include paths from environment variables.
423 // FIXME: We should probably sink the logic for handling these from the
424 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
425 // CPATH - included following the user specified includes (but prior to
426 // builtin and standard includes).
427 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
428 // C_INCLUDE_PATH - system includes enabled when compiling C.
429 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
430 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
431 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
432 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
433 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
434 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
435 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
436
437 // Add C++ include arguments, if needed.
438 if (types::isCXX(Inputs[0].getType()))
439 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
440
441 // Add system include arguments.
442 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
443}
444
445/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
446/// CPU.
447//
448// FIXME: This is redundant with -mcpu, why does LLVM use this.
449// FIXME: tblgen this, or kill it!
450static const char *getLLVMArchSuffixForARM(StringRef CPU) {
451 return llvm::StringSwitch<const char *>(CPU)
452 .Case("strongarm", "v4")
453 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
454 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
455 .Cases("arm920", "arm920t", "arm922t", "v4t")
456 .Cases("arm940t", "ep9312","v4t")
457 .Cases("arm10tdmi", "arm1020t", "v5")
458 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
459 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
460 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
461 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
462 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
463 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
464 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
465 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7")
466 .Cases("cortex-r4", "cortex-r5", "v7r")
467 .Case("cortex-m0", "v6m")
468 .Case("cortex-m3", "v7m")
469 .Case("cortex-m4", "v7em")
470 .Case("cortex-a9-mp", "v7f")
471 .Case("swift", "v7s")
472 .Cases("cortex-a53", "cortex-a57", "v8")
473 .Default("");
474}
475
476/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
477//
478// FIXME: tblgen this.
479static std::string getARMTargetCPU(const ArgList &Args,
480 const llvm::Triple &Triple) {
481 // FIXME: Warn on inconsistent use of -mcpu and -march.
482
483 // If we have -mcpu=, use that.
484 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
485 StringRef MCPU = A->getValue();
486 // Handle -mcpu=native.
487 if (MCPU == "native")
488 return llvm::sys::getHostCPUName();
489 else
490 return MCPU;
491 }
492
493 StringRef MArch;
494 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
495 // Otherwise, if we have -march= choose the base CPU for that arch.
496 MArch = A->getValue();
497 } else {
498 // Otherwise, use the Arch from the triple.
499 MArch = Triple.getArchName();
500 }
501
502 if (Triple.getOS() == llvm::Triple::NetBSD) {
503 if (MArch == "armv6")
504 return "arm1176jzf-s";
505 }
506
507 // Handle -march=native.
508 std::string NativeMArch;
509 if (MArch == "native") {
510 std::string CPU = llvm::sys::getHostCPUName();
511 if (CPU != "generic") {
512 // Translate the native cpu into the architecture. The switch below will
513 // then chose the minimum cpu for that arch.
514 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
515 MArch = NativeMArch;
516 }
517 }
518
519 return llvm::StringSwitch<const char *>(MArch)
520 .Cases("armv2", "armv2a","arm2")
521 .Case("armv3", "arm6")
522 .Case("armv3m", "arm7m")
523 .Case("armv4", "strongarm")
524 .Case("armv4t", "arm7tdmi")
525 .Cases("armv5", "armv5t", "arm10tdmi")
526 .Cases("armv5e", "armv5te", "arm1022e")
527 .Case("armv5tej", "arm926ej-s")
528 .Cases("armv6", "armv6k", "arm1136jf-s")
529 .Case("armv6j", "arm1136j-s")
530 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
531 .Case("armv6t2", "arm1156t2-s")
532 .Cases("armv6m", "armv6-m", "cortex-m0")
533 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
534 .Cases("armv7em", "armv7e-m", "cortex-m4")
535 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
536 .Cases("armv7s", "armv7-s", "swift")
537 .Cases("armv7r", "armv7-r", "cortex-r4")
538 .Cases("armv7m", "armv7-m", "cortex-m3")
539 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
540 .Case("ep9312", "ep9312")
541 .Case("iwmmxt", "iwmmxt")
542 .Case("xscale", "xscale")
543 // If all else failed, return the most base CPU with thumb interworking
544 // supported by LLVM.
545 .Default("arm7tdmi");
546}
547
548/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
549//
550// FIXME: tblgen this.
551static std::string getAArch64TargetCPU(const ArgList &Args,
552 const llvm::Triple &Triple) {
553 // FIXME: Warn on inconsistent use of -mcpu and -march.
554
555 // If we have -mcpu=, use that.
556 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
557 StringRef MCPU = A->getValue();
558 // Handle -mcpu=native.
559 if (MCPU == "native")
560 return llvm::sys::getHostCPUName();
561 else
562 return MCPU;
563 }
564
565 return "generic";
566}
567
568// FIXME: Move to target hook.
569static bool isSignedCharDefault(const llvm::Triple &Triple) {
570 switch (Triple.getArch()) {
571 default:
572 return true;
573
574 case llvm::Triple::aarch64:
575 case llvm::Triple::arm:
576 case llvm::Triple::ppc:
577 case llvm::Triple::ppc64:
578 if (Triple.isOSDarwin())
579 return true;
580 return false;
581
582 case llvm::Triple::ppc64le:
583 case llvm::Triple::systemz:
584 case llvm::Triple::xcore:
585 return false;
586 }
587}
588
589static bool isNoCommonDefault(const llvm::Triple &Triple) {
590 switch (Triple.getArch()) {
591 default:
592 return false;
593
594 case llvm::Triple::xcore:
595 return true;
596 }
597}
598
599// Handle -mfpu=.
600//
601// FIXME: Centralize feature selection, defaulting shouldn't be also in the
602// frontend target.
603static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
604 const ArgList &Args,
605 std::vector<const char *> &Features) {
606 StringRef FPU = A->getValue();
607 if (FPU == "fp-armv8") {
608 Features.push_back("+fp-armv8");
609 } else if (FPU == "neon-fp-armv8") {
610 Features.push_back("+fp-armv8");
611 Features.push_back("+neon");
612 } else if (FPU == "crypto-neon-fp-armv8") {
613 Features.push_back("+fp-armv8");
614 Features.push_back("+neon");
615 Features.push_back("+crypto");
616 } else if (FPU == "neon") {
617 Features.push_back("+neon");
618 } else if (FPU == "none") {
619 Features.push_back("-fp-armv8");
620 Features.push_back("-crypto");
621 Features.push_back("-neon");
622 } else
623 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
624}
625
626// Handle -mhwdiv=.
627static void getARMHWDivFeatures(const Driver &D, const Arg *A,
628 const ArgList &Args,
629 std::vector<const char *> &Features) {
630 StringRef HWDiv = A->getValue();
631 if (HWDiv == "arm") {
632 Features.push_back("+hwdiv-arm");
633 Features.push_back("-hwdiv");
634 } else if (HWDiv == "thumb") {
635 Features.push_back("-hwdiv-arm");
636 Features.push_back("+hwdiv");
637 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
638 Features.push_back("+hwdiv-arm");
639 Features.push_back("+hwdiv");
640 } else if (HWDiv == "none") {
641 Features.push_back("-hwdiv-arm");
642 Features.push_back("-hwdiv");
643 } else
644 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
645}
646
647// Handle -mfpu=.
648//
649// FIXME: Centralize feature selection, defaulting shouldn't be also in the
650// frontend target.
651static void getARMFPUFeatures(const Driver &D, const Arg *A,
652 const ArgList &Args,
653 std::vector<const char *> &Features) {
654 StringRef FPU = A->getValue();
655
656 // Set the target features based on the FPU.
657 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
658 // Disable any default FPU support.
659 Features.push_back("-vfp2");
660 Features.push_back("-vfp3");
661 Features.push_back("-neon");
662 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
663 Features.push_back("+vfp3");
664 Features.push_back("+d16");
665 Features.push_back("-neon");
666 } else if (FPU == "vfp") {
667 Features.push_back("+vfp2");
668 Features.push_back("-neon");
669 } else if (FPU == "vfp3" || FPU == "vfpv3") {
670 Features.push_back("+vfp3");
671 Features.push_back("-neon");
672 } else if (FPU == "fp-armv8") {
673 Features.push_back("+fp-armv8");
674 Features.push_back("-neon");
675 Features.push_back("-crypto");
676 } else if (FPU == "neon-fp-armv8") {
677 Features.push_back("+fp-armv8");
678 Features.push_back("+neon");
679 Features.push_back("-crypto");
680 } else if (FPU == "crypto-neon-fp-armv8") {
681 Features.push_back("+fp-armv8");
682 Features.push_back("+neon");
683 Features.push_back("+crypto");
684 } else if (FPU == "neon") {
685 Features.push_back("+neon");
686 } else if (FPU == "none") {
687 Features.push_back("-vfp2");
688 Features.push_back("-vfp3");
689 Features.push_back("-vfp4");
690 Features.push_back("-fp-armv8");
691 Features.push_back("-crypto");
692 Features.push_back("-neon");
693 } else
694 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
695}
696
697// Select the float ABI as determined by -msoft-float, -mhard-float, and
698// -mfloat-abi=.
699static StringRef getARMFloatABI(const Driver &D,
700 const ArgList &Args,
701 const llvm::Triple &Triple) {
702 StringRef FloatABI;
703 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
704 options::OPT_mhard_float,
705 options::OPT_mfloat_abi_EQ)) {
706 if (A->getOption().matches(options::OPT_msoft_float))
707 FloatABI = "soft";
708 else if (A->getOption().matches(options::OPT_mhard_float))
709 FloatABI = "hard";
710 else {
711 FloatABI = A->getValue();
712 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
713 D.Diag(diag::err_drv_invalid_mfloat_abi)
714 << A->getAsString(Args);
715 FloatABI = "soft";
716 }
717 }
718 }
719
720 // If unspecified, choose the default based on the platform.
721 if (FloatABI.empty()) {
722 switch (Triple.getOS()) {
723 case llvm::Triple::Darwin:
724 case llvm::Triple::MacOSX:
725 case llvm::Triple::IOS: {
726 // Darwin defaults to "softfp" for v6 and v7.
727 //
728 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
729 std::string ArchName =
730 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
731 if (StringRef(ArchName).startswith("v6") ||
732 StringRef(ArchName).startswith("v7"))
733 FloatABI = "softfp";
734 else
735 FloatABI = "soft";
736 break;
737 }
738
739 case llvm::Triple::FreeBSD:
740 // FreeBSD defaults to soft float
741 FloatABI = "soft";
742 break;
743
744 default:
745 switch(Triple.getEnvironment()) {
746 case llvm::Triple::GNUEABIHF:
747 FloatABI = "hard";
748 break;
749 case llvm::Triple::GNUEABI:
750 FloatABI = "softfp";
751 break;
752 case llvm::Triple::EABI:
753 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
754 FloatABI = "softfp";
755 break;
756 case llvm::Triple::Android: {
757 std::string ArchName =
758 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
759 if (StringRef(ArchName).startswith("v7"))
760 FloatABI = "softfp";
761 else
762 FloatABI = "soft";
763 break;
764 }
765 default:
766 // Assume "soft", but warn the user we are guessing.
767 FloatABI = "soft";
768 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
769 break;
770 }
771 }
772 }
773
774 return FloatABI;
775}
776
777static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
778 const ArgList &Args,
779 std::vector<const char *> &Features) {
780 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
781 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
782 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
783 // stripped out by the ARM target.
784 // Use software floating point operations?
785 if (FloatABI == "soft")
786 Features.push_back("+soft-float");
787
788 // Use software floating point argument passing?
789 if (FloatABI != "hard")
790 Features.push_back("+soft-float-abi");
791
792 // Honor -mfpu=.
793 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
794 getARMFPUFeatures(D, A, Args, Features);
795 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
796 getARMHWDivFeatures(D, A, Args, Features);
797
798 // Setting -msoft-float effectively disables NEON because of the GCC
799 // implementation, although the same isn't true of VFP or VFP3.
800 if (FloatABI == "soft")
801 Features.push_back("-neon");
802
803 // En/disable crc
804 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
805 options::OPT_mnocrc)) {
806 if (A->getOption().matches(options::OPT_mcrc))
807 Features.push_back("+crc");
808 else
809 Features.push_back("-crc");
810 }
811}
812
813void Clang::AddARMTargetArgs(const ArgList &Args,
814 ArgStringList &CmdArgs,
815 bool KernelOrKext) const {
816 const Driver &D = getToolChain().getDriver();
817 // Get the effective triple, which takes into account the deployment target.
818 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
819 llvm::Triple Triple(TripleStr);
820 std::string CPUName = getARMTargetCPU(Args, Triple);
821
822 // Select the ABI to use.
823 //
824 // FIXME: Support -meabi.
825 const char *ABIName = 0;
826 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
827 ABIName = A->getValue();
828 } else if (Triple.isOSDarwin()) {
829 // The backend is hardwired to assume AAPCS for M-class processors, ensure
830 // the frontend matches that.
831 if (Triple.getEnvironment() == llvm::Triple::EABI ||
832 StringRef(CPUName).startswith("cortex-m")) {
833 ABIName = "aapcs";
834 } else {
835 ABIName = "apcs-gnu";
836 }
837 } else {
838 // Select the default based on the platform.
839 switch(Triple.getEnvironment()) {
840 case llvm::Triple::Android:
841 case llvm::Triple::GNUEABI:
842 case llvm::Triple::GNUEABIHF:
843 ABIName = "aapcs-linux";
844 break;
845 case llvm::Triple::EABI:
846 ABIName = "aapcs";
847 break;
848 default:
849 ABIName = "apcs-gnu";
850 }
851 }
852 CmdArgs.push_back("-target-abi");
853 CmdArgs.push_back(ABIName);
854
855 // Determine floating point ABI from the options & target defaults.
856 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
857 if (FloatABI == "soft") {
858 // Floating point operations and argument passing are soft.
859 //
860 // FIXME: This changes CPP defines, we need -target-soft-float.
861 CmdArgs.push_back("-msoft-float");
862 CmdArgs.push_back("-mfloat-abi");
863 CmdArgs.push_back("soft");
864 } else if (FloatABI == "softfp") {
865 // Floating point operations are hard, but argument passing is soft.
866 CmdArgs.push_back("-mfloat-abi");
867 CmdArgs.push_back("soft");
868 } else {
869 // Floating point operations and argument passing are hard.
870 assert(FloatABI == "hard" && "Invalid float abi!");
871 CmdArgs.push_back("-mfloat-abi");
872 CmdArgs.push_back("hard");
873 }
874
875 // Kernel code has more strict alignment requirements.
876 if (KernelOrKext) {
877 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
878 CmdArgs.push_back("-backend-option");
879 CmdArgs.push_back("-arm-long-calls");
880 }
881
882 CmdArgs.push_back("-backend-option");
883 CmdArgs.push_back("-arm-strict-align");
884
885 // The kext linker doesn't know how to deal with movw/movt.
886 CmdArgs.push_back("-backend-option");
887 CmdArgs.push_back("-arm-use-movt=0");
888 }
889
890 // Setting -mno-global-merge disables the codegen global merge pass. Setting
891 // -mglobal-merge has no effect as the pass is enabled by default.
892 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
893 options::OPT_mno_global_merge)) {
894 if (A->getOption().matches(options::OPT_mno_global_merge))
895 CmdArgs.push_back("-mno-global-merge");
896 }
897
898 if (!Args.hasFlag(options::OPT_mimplicit_float,
899 options::OPT_mno_implicit_float,
900 true))
901 CmdArgs.push_back("-no-implicit-float");
902
903 // llvm does not support reserving registers in general. There is support
904 // for reserving r9 on ARM though (defined as a platform-specific register
905 // in ARM EABI).
906 if (Args.hasArg(options::OPT_ffixed_r9)) {
907 CmdArgs.push_back("-backend-option");
908 CmdArgs.push_back("-arm-reserve-r9");
909 }
910}
911
912// Get CPU and ABI names. They are not independent
913// so we have to calculate them together.
914static void getMipsCPUAndABI(const ArgList &Args,
915 const llvm::Triple &Triple,
916 StringRef &CPUName,
917 StringRef &ABIName) {
918 const char *DefMips32CPU = "mips32";
919 const char *DefMips64CPU = "mips64";
920
921 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
922 options::OPT_mcpu_EQ))
923 CPUName = A->getValue();
924
925 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
926 ABIName = A->getValue();
927 // Convert a GNU style Mips ABI name to the name
928 // accepted by LLVM Mips backend.
929 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
930 .Case("32", "o32")
931 .Case("64", "n64")
932 .Default(ABIName);
933 }
934
935 // Setup default CPU and ABI names.
936 if (CPUName.empty() && ABIName.empty()) {
937 switch (Triple.getArch()) {
938 default:
939 llvm_unreachable("Unexpected triple arch name");
940 case llvm::Triple::mips:
941 case llvm::Triple::mipsel:
942 CPUName = DefMips32CPU;
943 break;
944 case llvm::Triple::mips64:
945 case llvm::Triple::mips64el:
946 CPUName = DefMips64CPU;
947 break;
948 }
949 }
950
951 if (!ABIName.empty()) {
952 // Deduce CPU name from ABI name.
953 CPUName = llvm::StringSwitch<const char *>(ABIName)
954 .Cases("32", "o32", "eabi", DefMips32CPU)
955 .Cases("n32", "n64", "64", DefMips64CPU)
956 .Default("");
957 }
958 else if (!CPUName.empty()) {
959 // Deduce ABI name from CPU name.
960 ABIName = llvm::StringSwitch<const char *>(CPUName)
961 .Cases("mips32", "mips32r2", "o32")
962 .Cases("mips64", "mips64r2", "n64")
963 .Default("");
964 }
965
966 // FIXME: Warn on inconsistent cpu and abi usage.
967}
968
969// Convert ABI name to the GNU tools acceptable variant.
970static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
971 return llvm::StringSwitch<llvm::StringRef>(ABI)
972 .Case("o32", "32")
973 .Case("n64", "64")
974 .Default(ABI);
975}
976
977// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
978// and -mfloat-abi=.
979static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
980 StringRef FloatABI;
981 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
982 options::OPT_mhard_float,
983 options::OPT_mfloat_abi_EQ)) {
984 if (A->getOption().matches(options::OPT_msoft_float))
985 FloatABI = "soft";
986 else if (A->getOption().matches(options::OPT_mhard_float))
987 FloatABI = "hard";
988 else {
989 FloatABI = A->getValue();
990 if (FloatABI != "soft" && FloatABI != "hard") {
991 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
992 FloatABI = "hard";
993 }
994 }
995 }
996
997 // If unspecified, choose the default based on the platform.
998 if (FloatABI.empty()) {
999 // Assume "hard", because it's a default value used by gcc.
1000 // When we start to recognize specific target MIPS processors,
1001 // we will be able to select the default more correctly.
1002 FloatABI = "hard";
1003 }
1004
1005 return FloatABI;
1006}
1007
1008static void AddTargetFeature(const ArgList &Args,
1009 std::vector<const char *> &Features,
1010 OptSpecifier OnOpt, OptSpecifier OffOpt,
1011 StringRef FeatureName) {
1012 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1013 if (A->getOption().matches(OnOpt))
1014 Features.push_back(Args.MakeArgString("+" + FeatureName));
1015 else
1016 Features.push_back(Args.MakeArgString("-" + FeatureName));
1017 }
1018}
1019
1020static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1021 std::vector<const char *> &Features) {
1022 StringRef FloatABI = getMipsFloatABI(D, Args);
1023 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1024 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1025 // FIXME: Note, this is a hack. We need to pass the selected float
1026 // mode to the MipsTargetInfoBase to define appropriate macros there.
1027 // Now it is the only method.
1028 Features.push_back("+soft-float");
1029 }
1030
1031 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1032 if (StringRef(A->getValue()) == "2008")
1033 Features.push_back("+nan2008");
1034 }
1035
1036 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1037 options::OPT_mdouble_float, "single-float");
1038 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1039 "mips16");
1040 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1041 options::OPT_mno_micromips, "micromips");
1042 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1043 "dsp");
1044 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1045 "dspr2");
1046 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1047 "msa");
1048 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1049 "fp64");
1050}
1051
1052void Clang::AddMIPSTargetArgs(const ArgList &Args,
1053 ArgStringList &CmdArgs) const {
1054 const Driver &D = getToolChain().getDriver();
1055 StringRef CPUName;
1056 StringRef ABIName;
1057 const llvm::Triple &Triple = getToolChain().getTriple();
1058 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1059
1060 CmdArgs.push_back("-target-abi");
1061 CmdArgs.push_back(ABIName.data());
1062
1063 StringRef FloatABI = getMipsFloatABI(D, Args);
1064
1065 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1066
1067 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1068 // Floating point operations and argument passing are soft.
1069 CmdArgs.push_back("-msoft-float");
1070 CmdArgs.push_back("-mfloat-abi");
1071 CmdArgs.push_back("soft");
1072
1073 if (FloatABI == "hard" && IsMips16) {
1074 CmdArgs.push_back("-mllvm");
1075 CmdArgs.push_back("-mips16-hard-float");
1076 }
1077 }
1078 else {
1079 // Floating point operations and argument passing are hard.
1080 assert(FloatABI == "hard" && "Invalid float abi!");
1081 CmdArgs.push_back("-mfloat-abi");
1082 CmdArgs.push_back("hard");
1083 }
1084
1085 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1086 if (A->getOption().matches(options::OPT_mxgot)) {
1087 CmdArgs.push_back("-mllvm");
1088 CmdArgs.push_back("-mxgot");
1089 }
1090 }
1091
1092 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1093 options::OPT_mno_ldc1_sdc1)) {
1094 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1095 CmdArgs.push_back("-mllvm");
1096 CmdArgs.push_back("-mno-ldc1-sdc1");
1097 }
1098 }
1099
1100 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1101 options::OPT_mno_check_zero_division)) {
1102 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1103 CmdArgs.push_back("-mllvm");
1104 CmdArgs.push_back("-mno-check-zero-division");
1105 }
1106 }
1107
1108 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1109 StringRef v = A->getValue();
1110 CmdArgs.push_back("-mllvm");
1111 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1112 A->claim();
1113 }
1114}
1115
1116/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1117static std::string getPPCTargetCPU(const ArgList &Args) {
1118 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1119 StringRef CPUName = A->getValue();
1120
1121 if (CPUName == "native") {
1122 std::string CPU = llvm::sys::getHostCPUName();
1123 if (!CPU.empty() && CPU != "generic")
1124 return CPU;
1125 else
1126 return "";
1127 }
1128
1129 return llvm::StringSwitch<const char *>(CPUName)
1130 .Case("common", "generic")
1131 .Case("440", "440")
1132 .Case("440fp", "440")
1133 .Case("450", "450")
1134 .Case("601", "601")
1135 .Case("602", "602")
1136 .Case("603", "603")
1137 .Case("603e", "603e")
1138 .Case("603ev", "603ev")
1139 .Case("604", "604")
1140 .Case("604e", "604e")
1141 .Case("620", "620")
1142 .Case("630", "pwr3")
1143 .Case("G3", "g3")
1144 .Case("7400", "7400")
1145 .Case("G4", "g4")
1146 .Case("7450", "7450")
1147 .Case("G4+", "g4+")
1148 .Case("750", "750")
1149 .Case("970", "970")
1150 .Case("G5", "g5")
1151 .Case("a2", "a2")
1152 .Case("a2q", "a2q")
1153 .Case("e500mc", "e500mc")
1154 .Case("e5500", "e5500")
1155 .Case("power3", "pwr3")
1156 .Case("power4", "pwr4")
1157 .Case("power5", "pwr5")
1158 .Case("power5x", "pwr5x")
1159 .Case("power6", "pwr6")
1160 .Case("power6x", "pwr6x")
1161 .Case("power7", "pwr7")
1162 .Case("pwr3", "pwr3")
1163 .Case("pwr4", "pwr4")
1164 .Case("pwr5", "pwr5")
1165 .Case("pwr5x", "pwr5x")
1166 .Case("pwr6", "pwr6")
1167 .Case("pwr6x", "pwr6x")
1168 .Case("pwr7", "pwr7")
1169 .Case("powerpc", "ppc")
1170 .Case("powerpc64", "ppc64")
1171 .Case("powerpc64le", "ppc64le")
1172 .Default("");
1173 }
1174
1175 return "";
1176}
1177
1178static void getPPCTargetFeatures(const ArgList &Args,
1179 std::vector<const char *> &Features) {
1180 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1181 ie = Args.filtered_end();
1182 it != ie; ++it) {
1183 StringRef Name = (*it)->getOption().getName();
1184 (*it)->claim();
1185
1186 // Skip over "-m".
1187 assert(Name.startswith("m") && "Invalid feature name.");
1188 Name = Name.substr(1);
1189
1190 bool IsNegative = Name.startswith("no-");
1191 if (IsNegative)
1192 Name = Name.substr(3);
1193
1194 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1195 // pass the correct option to the backend while calling the frontend
1196 // option the same.
1197 // TODO: Change the LLVM backend option maybe?
1198 if (Name == "mfcrf")
1199 Name = "mfocrf";
1200
1201 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1202 }
1203
1204 // Altivec is a bit weird, allow overriding of the Altivec feature here.
1205 AddTargetFeature(Args, Features, options::OPT_faltivec,
1206 options::OPT_fno_altivec, "altivec");
1207}
1208
1209/// Get the (LLVM) name of the R600 gpu we are targeting.
1210static std::string getR600TargetGPU(const ArgList &Args) {
1211 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1212 const char *GPUName = A->getValue();
1213 return llvm::StringSwitch<const char *>(GPUName)
1214 .Cases("rv630", "rv635", "r600")
1215 .Cases("rv610", "rv620", "rs780", "rs880")
1216 .Case("rv740", "rv770")
1217 .Case("palm", "cedar")
1218 .Cases("sumo", "sumo2", "sumo")
1219 .Case("hemlock", "cypress")
1220 .Case("aruba", "cayman")
1221 .Default(GPUName);
1222 }
1223 return "";
1224}
1225
1226static void getSparcTargetFeatures(const ArgList &Args,
1227 std::vector<const char *> Features) {
1228 bool SoftFloatABI = true;
1229 if (Arg *A =
1230 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1231 if (A->getOption().matches(options::OPT_mhard_float))
1232 SoftFloatABI = false;
1233 }
1234 if (SoftFloatABI)
1235 Features.push_back("+soft-float");
1236}
1237
1238void Clang::AddSparcTargetArgs(const ArgList &Args,
1239 ArgStringList &CmdArgs) const {
1240 const Driver &D = getToolChain().getDriver();
1241
1242 // Select the float ABI as determined by -msoft-float, -mhard-float, and
1243 StringRef FloatABI;
1244 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1245 options::OPT_mhard_float)) {
1246 if (A->getOption().matches(options::OPT_msoft_float))
1247 FloatABI = "soft";
1248 else if (A->getOption().matches(options::OPT_mhard_float))
1249 FloatABI = "hard";
1250 }
1251
1252 // If unspecified, choose the default based on the platform.
1253 if (FloatABI.empty()) {
1254 // Assume "soft", but warn the user we are guessing.
1255 FloatABI = "soft";
1256 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1257 }
1258
1259 if (FloatABI == "soft") {
1260 // Floating point operations and argument passing are soft.
1261 //
1262 // FIXME: This changes CPP defines, we need -target-soft-float.
1263 CmdArgs.push_back("-msoft-float");
1264 } else {
1265 assert(FloatABI == "hard" && "Invalid float abi!");
1266 CmdArgs.push_back("-mhard-float");
1267 }
1268}
1269
1270static const char *getSystemZTargetCPU(const ArgList &Args) {
1271 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1272 return A->getValue();
1273 return "z10";
1274}
1275
1276static const char *getX86TargetCPU(const ArgList &Args,
1277 const llvm::Triple &Triple) {
1278 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1279 if (StringRef(A->getValue()) != "native") {
1280 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
1281 return "core-avx2";
1282
1283 return A->getValue();
1284 }
1285
1286 // FIXME: Reject attempts to use -march=native unless the target matches
1287 // the host.
1288 //
1289 // FIXME: We should also incorporate the detected target features for use
1290 // with -native.
1291 std::string CPU = llvm::sys::getHostCPUName();
1292 if (!CPU.empty() && CPU != "generic")
1293 return Args.MakeArgString(CPU);
1294 }
1295
1296 // Select the default CPU if none was given (or detection failed).
1297
1298 if (Triple.getArch() != llvm::Triple::x86_64 &&
1299 Triple.getArch() != llvm::Triple::x86)
1300 return 0; // This routine is only handling x86 targets.
1301
1302 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1303
1304 // FIXME: Need target hooks.
1305 if (Triple.isOSDarwin()) {
1306 if (Triple.getArchName() == "x86_64h")
1307 return "core-avx2";
1308 return Is64Bit ? "core2" : "yonah";
1309 }
1310
1311 // All x86 devices running Android have core2 as their common
1312 // denominator. This makes a better choice than pentium4.
1313 if (Triple.getEnvironment() == llvm::Triple::Android)
1314 return "core2";
1315
1316 // Everything else goes to x86-64 in 64-bit mode.
1317 if (Is64Bit)
1318 return "x86-64";
1319
1320 switch (Triple.getOS()) {
1321 case llvm::Triple::FreeBSD:
1322 case llvm::Triple::NetBSD:
1323 case llvm::Triple::OpenBSD:
1324 return "i486";
1325 case llvm::Triple::Haiku:
1326 return "i586";
1327 case llvm::Triple::Bitrig:
1328 return "i686";
1329 default:
1330 // Fallback to p4.
1331 return "pentium4";
1332 }
1333}
1334
1335static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1336 switch(T.getArch()) {
1337 default:
1338 return "";
1339
1340 case llvm::Triple::aarch64:
1341 return getAArch64TargetCPU(Args, T);
1342
1343 case llvm::Triple::arm:
1344 case llvm::Triple::thumb:
1345 return getARMTargetCPU(Args, T);
1346
1347 case llvm::Triple::mips:
1348 case llvm::Triple::mipsel:
1349 case llvm::Triple::mips64:
1350 case llvm::Triple::mips64el: {
1351 StringRef CPUName;
1352 StringRef ABIName;
1353 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1354 return CPUName;
1355 }
1356
1357 case llvm::Triple::ppc:
1358 case llvm::Triple::ppc64:
1359 case llvm::Triple::ppc64le: {
1360 std::string TargetCPUName = getPPCTargetCPU(Args);
1361 // LLVM may default to generating code for the native CPU,
1362 // but, like gcc, we default to a more generic option for
1363 // each architecture. (except on Darwin)
1364 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1365 if (T.getArch() == llvm::Triple::ppc64)
1366 TargetCPUName = "ppc64";
1367 else if (T.getArch() == llvm::Triple::ppc64le)
1368 TargetCPUName = "ppc64le";
1369 else
1370 TargetCPUName = "ppc";
1371 }
1372 return TargetCPUName;
1373 }
1374
1375 case llvm::Triple::sparc:
1376 case llvm::Triple::sparcv9:
1377 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1378 return A->getValue();
1379 return "";
1380
1381 case llvm::Triple::x86:
1382 case llvm::Triple::x86_64:
1383 return getX86TargetCPU(Args, T);
1384
1385 case llvm::Triple::hexagon:
1386 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1387
1388 case llvm::Triple::systemz:
1389 return getSystemZTargetCPU(Args);
1390
1391 case llvm::Triple::r600:
1392 return getR600TargetGPU(Args);
1393 }
1394}
1395
1396static void getX86TargetFeatures(const llvm::Triple &Triple,
1397 const ArgList &Args,
1398 std::vector<const char *> &Features) {
1399 if (Triple.getArchName() == "x86_64h") {
1400 // x86_64h implies quite a few of the more modern subtarget features
1401 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1402 Features.push_back("-rdrnd");
1403 Features.push_back("-aes");
1404 Features.push_back("-pclmul");
1405 Features.push_back("-rtm");
1406 Features.push_back("-hle");
1407 Features.push_back("-fsgsbase");
1408 }
1409
1410 // Now add any that the user explicitly requested on the command line,
1411 // which may override the defaults.
1412 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1413 ie = Args.filtered_end();
1414 it != ie; ++it) {
1415 StringRef Name = (*it)->getOption().getName();
1416 (*it)->claim();
1417
1418 // Skip over "-m".
1419 assert(Name.startswith("m") && "Invalid feature name.");
1420 Name = Name.substr(1);
1421
1422 bool IsNegative = Name.startswith("no-");
1423 if (IsNegative)
1424 Name = Name.substr(3);
1425
1426 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1427 }
1428}
1429
1430void Clang::AddX86TargetArgs(const ArgList &Args,
1431 ArgStringList &CmdArgs) const {
1432 if (!Args.hasFlag(options::OPT_mred_zone,
1433 options::OPT_mno_red_zone,
1434 true) ||
1435 Args.hasArg(options::OPT_mkernel) ||
1436 Args.hasArg(options::OPT_fapple_kext))
1437 CmdArgs.push_back("-disable-red-zone");
1438
1439 // Default to avoid implicit floating-point for kernel/kext code, but allow
1440 // that to be overridden with -mno-soft-float.
1441 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1442 Args.hasArg(options::OPT_fapple_kext));
1443 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1444 options::OPT_mno_soft_float,
1445 options::OPT_mimplicit_float,
1446 options::OPT_mno_implicit_float)) {
1447 const Option &O = A->getOption();
1448 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1449 O.matches(options::OPT_msoft_float));
1450 }
1451 if (NoImplicitFloat)
1452 CmdArgs.push_back("-no-implicit-float");
1453}
1454
1455static inline bool HasPICArg(const ArgList &Args) {
1456 return Args.hasArg(options::OPT_fPIC)
1457 || Args.hasArg(options::OPT_fpic);
1458}
1459
1460static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1461 return Args.getLastArg(options::OPT_G,
1462 options::OPT_G_EQ,
1463 options::OPT_msmall_data_threshold_EQ);
1464}
1465
1466static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1467 std::string value;
1468 if (HasPICArg(Args))
1469 value = "0";
1470 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1471 value = A->getValue();
1472 A->claim();
1473 }
1474 return value;
1475}
1476
1477void Clang::AddHexagonTargetArgs(const ArgList &Args,
1478 ArgStringList &CmdArgs) const {
1479 CmdArgs.push_back("-fno-signed-char");
1480 CmdArgs.push_back("-mqdsp6-compat");
1481 CmdArgs.push_back("-Wreturn-type");
1482
1483 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1484 if (!SmallDataThreshold.empty()) {
1485 CmdArgs.push_back ("-mllvm");
1486 CmdArgs.push_back(Args.MakeArgString(
1487 "-hexagon-small-data-threshold=" + SmallDataThreshold));
1488 }
1489
1490 if (!Args.hasArg(options::OPT_fno_short_enums))
1491 CmdArgs.push_back("-fshort-enums");
1492 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1493 CmdArgs.push_back ("-mllvm");
1494 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1495 }
1496 CmdArgs.push_back ("-mllvm");
1497 CmdArgs.push_back ("-machine-sink-split=0");
1498}
1499
1500static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1501 std::vector<const char *> &Features) {
1502 // Honor -mfpu=.
1503 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
1504 getAArch64FPUFeatures(D, A, Args, Features);
1505}
1506
1507static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1508 const ArgList &Args, ArgStringList &CmdArgs) {
1509 std::vector<const char *> Features;
1510 switch (Triple.getArch()) {
1511 default:
1512 break;
1513 case llvm::Triple::mips:
1514 case llvm::Triple::mipsel:
1515 case llvm::Triple::mips64:
1516 case llvm::Triple::mips64el:
1517 getMIPSTargetFeatures(D, Args, Features);
1518 break;
1519
1520 case llvm::Triple::arm:
1521 case llvm::Triple::thumb:
1522 getARMTargetFeatures(D, Triple, Args, Features);
1523 break;
1524
1525 case llvm::Triple::ppc:
1526 case llvm::Triple::ppc64:
1527 case llvm::Triple::ppc64le:
1528 getPPCTargetFeatures(Args, Features);
1529 break;
1530 case llvm::Triple::sparc:
1531 getSparcTargetFeatures(Args, Features);
1532 break;
1533 case llvm::Triple::aarch64:
1534 getAArch64TargetFeatures(D, Args, Features);
1535 break;
1536 case llvm::Triple::x86:
1537 case llvm::Triple::x86_64:
1538 getX86TargetFeatures(Triple, Args, Features);
1539 break;
1540 }
1541
1542 // Find the last of each feature.
1543 llvm::StringMap<unsigned> LastOpt;
1544 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1545 const char *Name = Features[I];
1546 assert(Name[0] == '-' || Name[0] == '+');
1547 LastOpt[Name + 1] = I;
1548 }
1549
1550 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1551 // If this feature was overridden, ignore it.
1552 const char *Name = Features[I];
1553 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1554 assert(LastI != LastOpt.end());
1555 unsigned Last = LastI->second;
1556 if (Last != I)
1557 continue;
1558
1559 CmdArgs.push_back("-target-feature");
1560 CmdArgs.push_back(Name);
1561 }
1562}
1563
1564static bool
1565shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1566 const llvm::Triple &Triple) {
1567 // We use the zero-cost exception tables for Objective-C if the non-fragile
1568 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1569 // later.
1570 if (runtime.isNonFragile())
1571 return true;
1572
1573 if (!Triple.isOSDarwin())
1574 return false;
1575
1576 return (!Triple.isMacOSXVersionLT(10,5) &&
1577 (Triple.getArch() == llvm::Triple::x86_64 ||
1578 Triple.getArch() == llvm::Triple::arm));
1579}
1580
1581/// addExceptionArgs - Adds exception related arguments to the driver command
1582/// arguments. There's a master flag, -fexceptions and also language specific
1583/// flags to enable/disable C++ and Objective-C exceptions.
1584/// This makes it possible to for example disable C++ exceptions but enable
1585/// Objective-C exceptions.
1586static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1587 const llvm::Triple &Triple,
1588 bool KernelOrKext,
1589 const ObjCRuntime &objcRuntime,
1590 ArgStringList &CmdArgs) {
1591 if (KernelOrKext) {
1592 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1593 // arguments now to avoid warnings about unused arguments.
1594 Args.ClaimAllArgs(options::OPT_fexceptions);
1595 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1596 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1599 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1600 return;
1601 }
1602
1603 // Exceptions are enabled by default.
1604 bool ExceptionsEnabled = true;
1605
1606 // This keeps track of whether exceptions were explicitly turned on or off.
1607 bool DidHaveExplicitExceptionFlag = false;
1608
1609 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1610 options::OPT_fno_exceptions)) {
1611 if (A->getOption().matches(options::OPT_fexceptions))
1612 ExceptionsEnabled = true;
1613 else
1614 ExceptionsEnabled = false;
1615
1616 DidHaveExplicitExceptionFlag = true;
1617 }
1618
1619 bool ShouldUseExceptionTables = false;
1620
1621 // Exception tables and cleanups can be enabled with -fexceptions even if the
1622 // language itself doesn't support exceptions.
1623 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1624 ShouldUseExceptionTables = true;
1625
1626 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1627 // is not necessarily sensible, but follows GCC.
1628 if (types::isObjC(InputType) &&
1629 Args.hasFlag(options::OPT_fobjc_exceptions,
1630 options::OPT_fno_objc_exceptions,
1631 true)) {
1632 CmdArgs.push_back("-fobjc-exceptions");
1633
1634 ShouldUseExceptionTables |=
1635 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1636 }
1637
1638 if (types::isCXX(InputType)) {
1639 bool CXXExceptionsEnabled = ExceptionsEnabled;
1640
1641 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1642 options::OPT_fno_cxx_exceptions,
1643 options::OPT_fexceptions,
1644 options::OPT_fno_exceptions)) {
1645 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1646 CXXExceptionsEnabled = true;
1647 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1648 CXXExceptionsEnabled = false;
1649 }
1650
1651 if (CXXExceptionsEnabled) {
1652 CmdArgs.push_back("-fcxx-exceptions");
1653
1654 ShouldUseExceptionTables = true;
1655 }
1656 }
1657
1658 if (ShouldUseExceptionTables)
1659 CmdArgs.push_back("-fexceptions");
1660}
1661
1662static bool ShouldDisableAutolink(const ArgList &Args,
1663 const ToolChain &TC) {
1664 bool Default = true;
1665 if (TC.getTriple().isOSDarwin()) {
1666 // The native darwin assembler doesn't support the linker_option directives,
1667 // so we disable them if we think the .s file will be passed to it.
1668 Default = TC.useIntegratedAs();
1669 }
1670 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1671 Default);
1672}
1673
1674static bool ShouldDisableCFI(const ArgList &Args,
1675 const ToolChain &TC) {
1676 bool Default = true;
1677 if (TC.getTriple().isOSDarwin()) {
1678 // The native darwin assembler doesn't support cfi directives, so
1679 // we disable them if we think the .s file will be passed to it.
1680 Default = TC.useIntegratedAs();
1681 }
1682 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1683 options::OPT_fno_dwarf2_cfi_asm,
1684 Default);
1685}
1686
1687static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1688 const ToolChain &TC) {
1689 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1690 options::OPT_fno_dwarf_directory_asm,
1691 TC.useIntegratedAs());
1692 return !UseDwarfDirectory;
1693}
1694
1695/// \brief Check whether the given input tree contains any compilation actions.
1696static bool ContainsCompileAction(const Action *A) {
1697 if (isa<CompileJobAction>(A))
1698 return true;
1699
1700 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1701 if (ContainsCompileAction(*it))
1702 return true;
1703
1704 return false;
1705}
1706
1707/// \brief Check if -relax-all should be passed to the internal assembler.
1708/// This is done by default when compiling non-assembler source with -O0.
1709static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1710 bool RelaxDefault = true;
1711
1712 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1713 RelaxDefault = A->getOption().matches(options::OPT_O0);
1714
1715 if (RelaxDefault) {
1716 RelaxDefault = false;
1717 for (ActionList::const_iterator it = C.getActions().begin(),
1718 ie = C.getActions().end(); it != ie; ++it) {
1719 if (ContainsCompileAction(*it)) {
1720 RelaxDefault = true;
1721 break;
1722 }
1723 }
1724 }
1725
1726 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1727 RelaxDefault);
1728}
1729
1730static void CollectArgsForIntegratedAssembler(Compilation &C,
1731 const ArgList &Args,
1732 ArgStringList &CmdArgs,
1733 const Driver &D) {
1734 if (UseRelaxAll(C, Args))
1735 CmdArgs.push_back("-mrelax-all");
1736
1737 // When passing -I arguments to the assembler we sometimes need to
1738 // unconditionally take the next argument. For example, when parsing
1739 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1740 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1741 // arg after parsing the '-I' arg.
1742 bool TakeNextArg = false;
1743
1744 // When using an integrated assembler, translate -Wa, and -Xassembler
1745 // options.
1746 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1747 options::OPT_Xassembler),
1748 ie = Args.filtered_end(); it != ie; ++it) {
1749 const Arg *A = *it;
1750 A->claim();
1751
1752 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1753 StringRef Value = A->getValue(i);
1754 if (TakeNextArg) {
1755 CmdArgs.push_back(Value.data());
1756 TakeNextArg = false;
1757 continue;
1758 }
1759
1760 if (Value == "-force_cpusubtype_ALL") {
1761 // Do nothing, this is the default and we don't support anything else.
1762 } else if (Value == "-L") {
1763 CmdArgs.push_back("-msave-temp-labels");
1764 } else if (Value == "--fatal-warnings") {
1765 CmdArgs.push_back("-mllvm");
1766 CmdArgs.push_back("-fatal-assembler-warnings");
1767 } else if (Value == "--noexecstack") {
1768 CmdArgs.push_back("-mnoexecstack");
1769 } else if (Value.startswith("-I")) {
1770 CmdArgs.push_back(Value.data());
1771 // We need to consume the next argument if the current arg is a plain
1772 // -I. The next arg will be the include directory.
1773 if (Value == "-I")
1774 TakeNextArg = true;
1775 } else {
1776 D.Diag(diag::err_drv_unsupported_option_argument)
1777 << A->getOption().getName() << Value;
1778 }
1779 }
1780 }
1781}
1782
1783static void addProfileRTLinux(
1784 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1785 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1786 Args.hasArg(options::OPT_fprofile_generate) ||
1787 Args.hasArg(options::OPT_fcreate_profile) ||
1788 Args.hasArg(options::OPT_coverage)))
1789 return;
1790
1791 // The profile runtime is located in the Linux library directory and has name
1792 // "libclang_rt.profile-<ArchName>.a".
1793 SmallString<128> LibProfile(TC.getDriver().ResourceDir);
1794 llvm::sys::path::append(
1795 LibProfile, "lib", "linux",
1796 Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
1797
1798 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1799}
1800
1801static void addSanitizerRTLinkFlagsLinux(
1802 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
1803 const StringRef Sanitizer, bool BeforeLibStdCXX,
1804 bool ExportSymbols = true) {
1805 // Sanitizer runtime is located in the Linux library directory and
1806 // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1807 SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1808 llvm::sys::path::append(
1809 LibSanitizer, "lib", "linux",
1810 (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
1811
1812 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1813 // etc.) so that the linker picks custom versions of the global 'operator
1814 // new' and 'operator delete' symbols. We take the extreme (but simple)
1815 // strategy of inserting it at the front of the link command. It also
1816 // needs to be forced to end up in the executable, so wrap it in
1817 // whole-archive.
1818 SmallVector<const char *, 3> LibSanitizerArgs;
1819 LibSanitizerArgs.push_back("-whole-archive");
1820 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1821 LibSanitizerArgs.push_back("-no-whole-archive");
1822
1823 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1824 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1825
1826 CmdArgs.push_back("-lpthread");
1827 CmdArgs.push_back("-lrt");
1828 CmdArgs.push_back("-ldl");
1829 CmdArgs.push_back("-lm");
1830
1831 // If possible, use a dynamic symbols file to export the symbols from the
1832 // runtime library. If we can't do so, use -export-dynamic instead to export
1833 // all symbols from the binary.
1834 if (ExportSymbols) {
1835 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1836 CmdArgs.push_back(
1837 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1838 else
1839 CmdArgs.push_back("-export-dynamic");
1840 }
1841}
1842
1843/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1844/// This needs to be called before we add the C run-time (malloc, etc).
1845static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1846 ArgStringList &CmdArgs) {
1847 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
1848 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1849 llvm::sys::path::append(LibAsan, "lib", "linux",
1850 (Twine("libclang_rt.asan-") +
1851 TC.getArchName() + "-android.so"));
1852 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
1853 } else {
1854 if (!Args.hasArg(options::OPT_shared))
1855 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
1856 }
1857}
1858
1859/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1860/// This needs to be called before we add the C run-time (malloc, etc).
1861static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1862 ArgStringList &CmdArgs) {
1863 if (!Args.hasArg(options::OPT_shared))
1864 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
1865}
1866
1867/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1868/// This needs to be called before we add the C run-time (malloc, etc).
1869static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1870 ArgStringList &CmdArgs) {
1871 if (!Args.hasArg(options::OPT_shared))
1872 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
1873}
1874
1875/// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1876/// This needs to be called before we add the C run-time (malloc, etc).
1877static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args,
1878 ArgStringList &CmdArgs) {
1879 if (!Args.hasArg(options::OPT_shared))
1880 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true);
1881}
1882
1883/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1884/// (Linux).
1885static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1886 ArgStringList &CmdArgs, bool IsCXX,
1887 bool HasOtherSanitizerRt) {
1888 // Need a copy of sanitizer_common. This could come from another sanitizer
1889 // runtime; if we're not including one, include our own copy.
1890 if (!HasOtherSanitizerRt)
1891 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false);
1892
1893 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
1894
1895 // Only include the bits of the runtime which need a C++ ABI library if
1896 // we're linking in C++ mode.
1897 if (IsCXX)
1898 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false);
1899}
1900
1901static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
1902 ArgStringList &CmdArgs) {
1903 if (!Args.hasArg(options::OPT_shared))
1904 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
1905}
1906
1907static bool shouldUseFramePointerForTarget(const ArgList &Args,
1908 const llvm::Triple &Triple) {
1909 switch (Triple.getArch()) {
1910 // Don't use a frame pointer on linux if optimizing for certain targets.
1911 case llvm::Triple::mips64:
1912 case llvm::Triple::mips64el:
1913 case llvm::Triple::mips:
1914 case llvm::Triple::mipsel:
1915 case llvm::Triple::systemz:
1916 case llvm::Triple::x86:
1917 case llvm::Triple::x86_64:
1918 if (Triple.isOSLinux())
1919 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1920 if (!A->getOption().matches(options::OPT_O0))
1921 return false;
1922 return true;
1923 case llvm::Triple::xcore:
1924 return false;
1925 default:
1926 return true;
1927 }
1928}
1929
1930static bool shouldUseFramePointer(const ArgList &Args,
1931 const llvm::Triple &Triple) {
1932 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1933 options::OPT_fomit_frame_pointer))
1934 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1935
1936 return shouldUseFramePointerForTarget(Args, Triple);
1937}
1938
1939static bool shouldUseLeafFramePointer(const ArgList &Args,
1940 const llvm::Triple &Triple) {
1941 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1942 options::OPT_momit_leaf_frame_pointer))
1943 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1944
1945 return shouldUseFramePointerForTarget(Args, Triple);
1946}
1947
1948/// Add a CC1 option to specify the debug compilation directory.
1949static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1950 SmallString<128> cwd;
1951 if (!llvm::sys::fs::current_path(cwd)) {
1952 CmdArgs.push_back("-fdebug-compilation-dir");
1953 CmdArgs.push_back(Args.MakeArgString(cwd));
1954 }
1955}
1956
1957static const char *SplitDebugName(const ArgList &Args,
1958 const InputInfoList &Inputs) {
1959 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1960 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1961 SmallString<128> T(FinalOutput->getValue());
1962 llvm::sys::path::replace_extension(T, "dwo");
1963 return Args.MakeArgString(T);
1964 } else {
1965 // Use the compilation dir.
1966 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1967 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1968 llvm::sys::path::replace_extension(F, "dwo");
1969 T += F;
1970 return Args.MakeArgString(F);
1971 }
1972}
1973
1974static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1975 const Tool &T, const JobAction &JA,
1976 const ArgList &Args, const InputInfo &Output,
1977 const char *OutFile) {
1978 ArgStringList ExtractArgs;
1979 ExtractArgs.push_back("--extract-dwo");
1980
1981 ArgStringList StripArgs;
1982 StripArgs.push_back("--strip-dwo");
1983
1984 // Grabbing the output of the earlier compile step.
1985 StripArgs.push_back(Output.getFilename());
1986 ExtractArgs.push_back(Output.getFilename());
1987 ExtractArgs.push_back(OutFile);
1988
1989 const char *Exec =
1990 Args.MakeArgString(TC.GetProgramPath("objcopy"));
1991
1992 // First extract the dwo sections.
1993 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
1994
1995 // Then remove them from the original .o file.
1996 C.addCommand(new Command(JA, T, Exec, StripArgs));
1997}
1998
|
1999static bool isOptimizationLevelFast(const ArgList &Args) {
2000 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2001 if (A->getOption().matches(options::OPT_Ofast))
2002 return true;
2003 return false;
2004}
2005
| |
2006/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2007static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2008 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2009 if (A->getOption().matches(options::OPT_O4) ||
2010 A->getOption().matches(options::OPT_Ofast))
2011 return true;
2012
2013 if (A->getOption().matches(options::OPT_O0))
2014 return false;
2015
2016 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2017
2018 // Vectorize -Os.
2019 StringRef S(A->getValue());
2020 if (S == "s")
2021 return true;
2022
2023 // Don't vectorize -Oz.
2024 if (S == "z")
2025 return false;
2026
2027 unsigned OptLevel = 0;
2028 if (S.getAsInteger(10, OptLevel))
2029 return false;
2030
2031 return OptLevel > 1;
2032 }
2033
2034 return false;
2035}
2036
2037void Clang::ConstructJob(Compilation &C, const JobAction &JA,
2038 const InputInfo &Output,
2039 const InputInfoList &Inputs,
2040 const ArgList &Args,
2041 const char *LinkingOutput) const {
2042 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2043 options::OPT_fapple_kext);
2044 const Driver &D = getToolChain().getDriver();
2045 ArgStringList CmdArgs;
2046
2047 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2048
2049 // Invoke ourselves in -cc1 mode.
2050 //
2051 // FIXME: Implement custom jobs for internal actions.
2052 CmdArgs.push_back("-cc1");
2053
2054 // Add the "effective" target triple.
2055 CmdArgs.push_back("-triple");
2056 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2057 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2058
2059 // Select the appropriate action.
2060 RewriteKind rewriteKind = RK_None;
2061
2062 if (isa<AnalyzeJobAction>(JA)) {
2063 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2064 CmdArgs.push_back("-analyze");
2065 } else if (isa<MigrateJobAction>(JA)) {
2066 CmdArgs.push_back("-migrate");
2067 } else if (isa<PreprocessJobAction>(JA)) {
2068 if (Output.getType() == types::TY_Dependencies)
2069 CmdArgs.push_back("-Eonly");
2070 else {
2071 CmdArgs.push_back("-E");
2072 if (Args.hasArg(options::OPT_rewrite_objc) &&
2073 !Args.hasArg(options::OPT_g_Group))
2074 CmdArgs.push_back("-P");
2075 }
2076 } else if (isa<AssembleJobAction>(JA)) {
2077 CmdArgs.push_back("-emit-obj");
2078
2079 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2080
2081 // Also ignore explicit -force_cpusubtype_ALL option.
2082 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2083 } else if (isa<PrecompileJobAction>(JA)) {
2084 // Use PCH if the user requested it.
2085 bool UsePCH = D.CCCUsePCH;
2086
2087 if (JA.getType() == types::TY_Nothing)
2088 CmdArgs.push_back("-fsyntax-only");
2089 else if (UsePCH)
2090 CmdArgs.push_back("-emit-pch");
2091 else
2092 CmdArgs.push_back("-emit-pth");
2093 } else {
2094 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
2095
2096 if (JA.getType() == types::TY_Nothing) {
2097 CmdArgs.push_back("-fsyntax-only");
2098 } else if (JA.getType() == types::TY_LLVM_IR ||
2099 JA.getType() == types::TY_LTO_IR) {
2100 CmdArgs.push_back("-emit-llvm");
2101 } else if (JA.getType() == types::TY_LLVM_BC ||
2102 JA.getType() == types::TY_LTO_BC) {
2103 CmdArgs.push_back("-emit-llvm-bc");
2104 } else if (JA.getType() == types::TY_PP_Asm) {
2105 CmdArgs.push_back("-S");
2106 } else if (JA.getType() == types::TY_AST) {
2107 CmdArgs.push_back("-emit-pch");
2108 } else if (JA.getType() == types::TY_ModuleFile) {
2109 CmdArgs.push_back("-module-file-info");
2110 } else if (JA.getType() == types::TY_RewrittenObjC) {
2111 CmdArgs.push_back("-rewrite-objc");
2112 rewriteKind = RK_NonFragile;
2113 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2114 CmdArgs.push_back("-rewrite-objc");
2115 rewriteKind = RK_Fragile;
2116 } else {
2117 assert(JA.getType() == types::TY_PP_Asm &&
2118 "Unexpected output type!");
2119 }
2120 }
2121
2122 // The make clang go fast button.
2123 CmdArgs.push_back("-disable-free");
2124
2125 // Disable the verification pass in -asserts builds.
2126#ifdef NDEBUG
2127 CmdArgs.push_back("-disable-llvm-verifier");
2128#endif
2129
2130 // Set the main file name, so that debug info works even with
2131 // -save-temps.
2132 CmdArgs.push_back("-main-file-name");
2133 CmdArgs.push_back(getBaseInputName(Args, Inputs));
2134
2135 // Some flags which affect the language (via preprocessor
2136 // defines).
2137 if (Args.hasArg(options::OPT_static))
2138 CmdArgs.push_back("-static-define");
2139
2140 if (isa<AnalyzeJobAction>(JA)) {
2141 // Enable region store model by default.
2142 CmdArgs.push_back("-analyzer-store=region");
2143
2144 // Treat blocks as analysis entry points.
2145 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2146
2147 CmdArgs.push_back("-analyzer-eagerly-assume");
2148
2149 // Add default argument set.
2150 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2151 CmdArgs.push_back("-analyzer-checker=core");
2152
2153 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2154 CmdArgs.push_back("-analyzer-checker=unix");
2155
2156 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2157 CmdArgs.push_back("-analyzer-checker=osx");
2158
2159 CmdArgs.push_back("-analyzer-checker=deadcode");
2160
2161 if (types::isCXX(Inputs[0].getType()))
2162 CmdArgs.push_back("-analyzer-checker=cplusplus");
2163
2164 // Enable the following experimental checkers for testing.
2165 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2166 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2167 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2168 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2169 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2170 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2171 }
2172
2173 // Set the output format. The default is plist, for (lame) historical
2174 // reasons.
2175 CmdArgs.push_back("-analyzer-output");
2176 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2177 CmdArgs.push_back(A->getValue());
2178 else
2179 CmdArgs.push_back("plist");
2180
2181 // Disable the presentation of standard compiler warnings when
2182 // using --analyze. We only want to show static analyzer diagnostics
2183 // or frontend errors.
2184 CmdArgs.push_back("-w");
2185
2186 // Add -Xanalyzer arguments when running as analyzer.
2187 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2188 }
2189
2190 CheckCodeGenerationOptions(D, Args);
2191
2192 bool PIE = getToolChain().isPIEDefault();
2193 bool PIC = PIE || getToolChain().isPICDefault();
2194 bool IsPICLevelTwo = PIC;
2195
2196 // For the PIC and PIE flag options, this logic is different from the
2197 // legacy logic in very old versions of GCC, as that logic was just
2198 // a bug no one had ever fixed. This logic is both more rational and
2199 // consistent with GCC's new logic now that the bugs are fixed. The last
2200 // argument relating to either PIC or PIE wins, and no other argument is
2201 // used. If the last argument is any flavor of the '-fno-...' arguments,
2202 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2203 // at the same level.
2204 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2205 options::OPT_fpic, options::OPT_fno_pic,
2206 options::OPT_fPIE, options::OPT_fno_PIE,
2207 options::OPT_fpie, options::OPT_fno_pie);
2208 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2209 // is forced, then neither PIC nor PIE flags will have no effect.
2210 if (!getToolChain().isPICDefaultForced()) {
2211 if (LastPICArg) {
2212 Option O = LastPICArg->getOption();
2213 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2214 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2215 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2216 PIC = PIE || O.matches(options::OPT_fPIC) ||
2217 O.matches(options::OPT_fpic);
2218 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2219 O.matches(options::OPT_fPIC);
2220 } else {
2221 PIE = PIC = false;
2222 }
2223 }
2224 }
2225
2226 // Introduce a Darwin-specific hack. If the default is PIC but the flags
2227 // specified while enabling PIC enabled level 1 PIC, just force it back to
2228 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2229 // informal testing).
2230 if (PIC && getToolChain().getTriple().isOSDarwin())
2231 IsPICLevelTwo |= getToolChain().isPICDefault();
2232
2233 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2234 // PIC or PIE options above, if these show up, PIC is disabled.
2235 llvm::Triple Triple(TripleStr);
2236 if (KernelOrKext &&
2237 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
2238 PIC = PIE = false;
2239 if (Args.hasArg(options::OPT_static))
2240 PIC = PIE = false;
2241
2242 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2243 // This is a very special mode. It trumps the other modes, almost no one
2244 // uses it, and it isn't even valid on any OS but Darwin.
2245 if (!getToolChain().getTriple().isOSDarwin())
2246 D.Diag(diag::err_drv_unsupported_opt_for_target)
2247 << A->getSpelling() << getToolChain().getTriple().str();
2248
2249 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2250
2251 CmdArgs.push_back("-mrelocation-model");
2252 CmdArgs.push_back("dynamic-no-pic");
2253
2254 // Only a forced PIC mode can cause the actual compile to have PIC defines
2255 // etc., no flags are sufficient. This behavior was selected to closely
2256 // match that of llvm-gcc and Apple GCC before that.
2257 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2258 CmdArgs.push_back("-pic-level");
2259 CmdArgs.push_back("2");
2260 }
2261 } else {
2262 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2263 // handled in Clang's IRGen by the -pie-level flag.
2264 CmdArgs.push_back("-mrelocation-model");
2265 CmdArgs.push_back(PIC ? "pic" : "static");
2266
2267 if (PIC) {
2268 CmdArgs.push_back("-pic-level");
2269 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2270 if (PIE) {
2271 CmdArgs.push_back("-pie-level");
2272 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2273 }
2274 }
2275 }
2276
2277 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2278 options::OPT_fno_merge_all_constants))
2279 CmdArgs.push_back("-fno-merge-all-constants");
2280
2281 // LLVM Code Generator Options.
2282
2283 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2284 CmdArgs.push_back("-mregparm");
2285 CmdArgs.push_back(A->getValue());
2286 }
2287
2288 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2289 options::OPT_freg_struct_return)) {
2290 if (getToolChain().getArch() != llvm::Triple::x86) {
2291 D.Diag(diag::err_drv_unsupported_opt_for_target)
2292 << A->getSpelling() << getToolChain().getTriple().str();
2293 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2294 CmdArgs.push_back("-fpcc-struct-return");
2295 } else {
2296 assert(A->getOption().matches(options::OPT_freg_struct_return));
2297 CmdArgs.push_back("-freg-struct-return");
2298 }
2299 }
2300
2301 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2302 CmdArgs.push_back("-mrtd");
2303
2304 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2305 CmdArgs.push_back("-mdisable-fp-elim");
2306 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2307 options::OPT_fno_zero_initialized_in_bss))
2308 CmdArgs.push_back("-mno-zero-initialized-in-bss");
2309
2310 bool OFastEnabled = isOptimizationLevelFast(Args);
2311 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2312 // enabled. This alias option is being used to simplify the hasFlag logic.
2313 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2314 options::OPT_fstrict_aliasing;
2315 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2316 options::OPT_fno_strict_aliasing, true))
2317 CmdArgs.push_back("-relaxed-aliasing");
2318 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2319 options::OPT_fno_struct_path_tbaa))
2320 CmdArgs.push_back("-no-struct-path-tbaa");
2321 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2322 false))
2323 CmdArgs.push_back("-fstrict-enums");
2324 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2325 options::OPT_fno_optimize_sibling_calls))
2326 CmdArgs.push_back("-mdisable-tail-calls");
2327
2328 // Handle segmented stacks.
2329 if (Args.hasArg(options::OPT_fsplit_stack))
2330 CmdArgs.push_back("-split-stacks");
2331
2332 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2333 // This alias option is being used to simplify the getLastArg logic.
2334 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2335 options::OPT_ffast_math;
2336
2337 // Handle various floating point optimization flags, mapping them to the
2338 // appropriate LLVM code generation flags. The pattern for all of these is to
2339 // default off the codegen optimizations, and if any flag enables them and no
2340 // flag disables them after the flag enabling them, enable the codegen
2341 // optimization. This is complicated by several "umbrella" flags.
2342 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2343 options::OPT_fno_fast_math,
2344 options::OPT_ffinite_math_only,
2345 options::OPT_fno_finite_math_only,
2346 options::OPT_fhonor_infinities,
2347 options::OPT_fno_honor_infinities))
2348 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2349 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2350 A->getOption().getID() != options::OPT_fhonor_infinities)
2351 CmdArgs.push_back("-menable-no-infs");
2352 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2353 options::OPT_fno_fast_math,
2354 options::OPT_ffinite_math_only,
2355 options::OPT_fno_finite_math_only,
2356 options::OPT_fhonor_nans,
2357 options::OPT_fno_honor_nans))
2358 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2359 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2360 A->getOption().getID() != options::OPT_fhonor_nans)
2361 CmdArgs.push_back("-menable-no-nans");
2362
2363 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2364 bool MathErrno = getToolChain().IsMathErrnoDefault();
2365 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2366 options::OPT_fno_fast_math,
2367 options::OPT_fmath_errno,
2368 options::OPT_fno_math_errno)) {
2369 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2370 // However, turning *off* -ffast_math merely restores the toolchain default
2371 // (which may be false).
2372 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2373 A->getOption().getID() == options::OPT_ffast_math ||
2374 A->getOption().getID() == options::OPT_Ofast)
2375 MathErrno = false;
2376 else if (A->getOption().getID() == options::OPT_fmath_errno)
2377 MathErrno = true;
2378 }
2379 if (MathErrno)
2380 CmdArgs.push_back("-fmath-errno");
2381
2382 // There are several flags which require disabling very specific
2383 // optimizations. Any of these being disabled forces us to turn off the
2384 // entire set of LLVM optimizations, so collect them through all the flag
2385 // madness.
2386 bool AssociativeMath = false;
2387 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2388 options::OPT_fno_fast_math,
2389 options::OPT_funsafe_math_optimizations,
2390 options::OPT_fno_unsafe_math_optimizations,
2391 options::OPT_fassociative_math,
2392 options::OPT_fno_associative_math))
2393 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2394 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2395 A->getOption().getID() != options::OPT_fno_associative_math)
2396 AssociativeMath = true;
2397 bool ReciprocalMath = false;
2398 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2399 options::OPT_fno_fast_math,
2400 options::OPT_funsafe_math_optimizations,
2401 options::OPT_fno_unsafe_math_optimizations,
2402 options::OPT_freciprocal_math,
2403 options::OPT_fno_reciprocal_math))
2404 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2405 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2406 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2407 ReciprocalMath = true;
2408 bool SignedZeros = true;
2409 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2410 options::OPT_fno_fast_math,
2411 options::OPT_funsafe_math_optimizations,
2412 options::OPT_fno_unsafe_math_optimizations,
2413 options::OPT_fsigned_zeros,
2414 options::OPT_fno_signed_zeros))
2415 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2416 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2417 A->getOption().getID() != options::OPT_fsigned_zeros)
2418 SignedZeros = false;
2419 bool TrappingMath = true;
2420 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2421 options::OPT_fno_fast_math,
2422 options::OPT_funsafe_math_optimizations,
2423 options::OPT_fno_unsafe_math_optimizations,
2424 options::OPT_ftrapping_math,
2425 options::OPT_fno_trapping_math))
2426 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2427 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2428 A->getOption().getID() != options::OPT_ftrapping_math)
2429 TrappingMath = false;
2430 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2431 !TrappingMath)
2432 CmdArgs.push_back("-menable-unsafe-fp-math");
2433
2434
2435 // Validate and pass through -fp-contract option.
2436 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2437 options::OPT_fno_fast_math,
2438 options::OPT_ffp_contract)) {
2439 if (A->getOption().getID() == options::OPT_ffp_contract) {
2440 StringRef Val = A->getValue();
2441 if (Val == "fast" || Val == "on" || Val == "off") {
2442 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2443 } else {
2444 D.Diag(diag::err_drv_unsupported_option_argument)
2445 << A->getOption().getName() << Val;
2446 }
2447 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2448 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
2449 // If fast-math is set then set the fp-contract mode to fast.
2450 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2451 }
2452 }
2453
2454 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2455 // and if we find them, tell the frontend to provide the appropriate
2456 // preprocessor macros. This is distinct from enabling any optimizations as
2457 // these options induce language changes which must survive serialization
2458 // and deserialization, etc.
2459 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2460 options::OPT_fno_fast_math))
2461 if (!A->getOption().matches(options::OPT_fno_fast_math))
2462 CmdArgs.push_back("-ffast-math");
2463 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2464 if (A->getOption().matches(options::OPT_ffinite_math_only))
2465 CmdArgs.push_back("-ffinite-math-only");
2466
2467 // Decide whether to use verbose asm. Verbose assembly is the default on
2468 // toolchains which have the integrated assembler on by default.
2469 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2470 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2471 IsVerboseAsmDefault) ||
2472 Args.hasArg(options::OPT_dA))
2473 CmdArgs.push_back("-masm-verbose");
2474
2475 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2476 CmdArgs.push_back("-mdebug-pass");
2477 CmdArgs.push_back("Structure");
2478 }
2479 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2480 CmdArgs.push_back("-mdebug-pass");
2481 CmdArgs.push_back("Arguments");
2482 }
2483
2484 // Enable -mconstructor-aliases except on darwin, where we have to
2485 // work around a linker bug; see <rdar://problem/7651567>.
2486 if (!getToolChain().getTriple().isOSDarwin())
2487 CmdArgs.push_back("-mconstructor-aliases");
2488
2489 // Darwin's kernel doesn't support guard variables; just die if we
2490 // try to use them.
2491 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2492 CmdArgs.push_back("-fforbid-guard-variables");
2493
2494 if (Args.hasArg(options::OPT_mms_bitfields)) {
2495 CmdArgs.push_back("-mms-bitfields");
2496 }
2497
2498 // This is a coarse approximation of what llvm-gcc actually does, both
2499 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2500 // complicated ways.
2501 bool AsynchronousUnwindTables =
2502 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2503 options::OPT_fno_asynchronous_unwind_tables,
2504 getToolChain().IsUnwindTablesDefault() &&
2505 !KernelOrKext);
2506 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2507 AsynchronousUnwindTables))
2508 CmdArgs.push_back("-munwind-tables");
2509
2510 getToolChain().addClangTargetOptions(Args, CmdArgs);
2511
2512 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2513 CmdArgs.push_back("-mlimit-float-precision");
2514 CmdArgs.push_back(A->getValue());
2515 }
2516
2517 // FIXME: Handle -mtune=.
2518 (void) Args.hasArg(options::OPT_mtune_EQ);
2519
2520 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2521 CmdArgs.push_back("-mcode-model");
2522 CmdArgs.push_back(A->getValue());
2523 }
2524
2525 // Add the target cpu
2526 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2527 llvm::Triple ETriple(ETripleStr);
2528 std::string CPU = getCPUName(Args, ETriple);
2529 if (!CPU.empty()) {
2530 CmdArgs.push_back("-target-cpu");
2531 CmdArgs.push_back(Args.MakeArgString(CPU));
2532 }
2533
2534 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2535 CmdArgs.push_back("-mfpmath");
2536 CmdArgs.push_back(A->getValue());
2537 }
2538
2539 // Add the target features
2540 getTargetFeatures(D, ETriple, Args, CmdArgs);
2541
2542 // Add target specific flags.
2543 switch(getToolChain().getArch()) {
2544 default:
2545 break;
2546
2547 case llvm::Triple::arm:
2548 case llvm::Triple::thumb:
2549 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2550 break;
2551
2552 case llvm::Triple::mips:
2553 case llvm::Triple::mipsel:
2554 case llvm::Triple::mips64:
2555 case llvm::Triple::mips64el:
2556 AddMIPSTargetArgs(Args, CmdArgs);
2557 break;
2558
2559 case llvm::Triple::sparc:
2560 AddSparcTargetArgs(Args, CmdArgs);
2561 break;
2562
2563 case llvm::Triple::x86:
2564 case llvm::Triple::x86_64:
2565 AddX86TargetArgs(Args, CmdArgs);
2566 break;
2567
2568 case llvm::Triple::hexagon:
2569 AddHexagonTargetArgs(Args, CmdArgs);
2570 break;
2571 }
2572
2573 // Add clang-cl arguments.
2574 if (getToolChain().getDriver().IsCLMode())
2575 AddClangCLArgs(Args, CmdArgs);
2576
2577 // Pass the linker version in use.
2578 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2579 CmdArgs.push_back("-target-linker-version");
2580 CmdArgs.push_back(A->getValue());
2581 }
2582
2583 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
2584 CmdArgs.push_back("-momit-leaf-frame-pointer");
2585
2586 // Explicitly error on some things we know we don't support and can't just
2587 // ignore.
2588 types::ID InputType = Inputs[0].getType();
2589 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2590 Arg *Unsupported;
2591 if (types::isCXX(InputType) &&
2592 getToolChain().getTriple().isOSDarwin() &&
2593 getToolChain().getArch() == llvm::Triple::x86) {
2594 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2595 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2596 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2597 << Unsupported->getOption().getName();
2598 }
2599 }
2600
2601 Args.AddAllArgs(CmdArgs, options::OPT_v);
2602 Args.AddLastArg(CmdArgs, options::OPT_H);
2603 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
2604 CmdArgs.push_back("-header-include-file");
2605 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2606 D.CCPrintHeadersFilename : "-");
2607 }
2608 Args.AddLastArg(CmdArgs, options::OPT_P);
2609 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2610
2611 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
2612 CmdArgs.push_back("-diagnostic-log-file");
2613 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2614 D.CCLogDiagnosticsFilename : "-");
2615 }
2616
2617 // Use the last option from "-g" group. "-gline-tables-only"
2618 // is preserved, all other debug options are substituted with "-g".
2619 Args.ClaimAllArgs(options::OPT_g_Group);
2620 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2621 if (A->getOption().matches(options::OPT_gline_tables_only))
2622 CmdArgs.push_back("-gline-tables-only");
2623 else if (A->getOption().matches(options::OPT_gdwarf_2))
2624 CmdArgs.push_back("-gdwarf-2");
2625 else if (A->getOption().matches(options::OPT_gdwarf_3))
2626 CmdArgs.push_back("-gdwarf-3");
2627 else if (A->getOption().matches(options::OPT_gdwarf_4))
2628 CmdArgs.push_back("-gdwarf-4");
2629 else if (!A->getOption().matches(options::OPT_g0) &&
2630 !A->getOption().matches(options::OPT_ggdb0)) {
2631 // Default is dwarf-2 for darwin and FreeBSD.
2632 const llvm::Triple &Triple = getToolChain().getTriple();
2633 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::FreeBSD)
2634 CmdArgs.push_back("-gdwarf-2");
2635 else
2636 CmdArgs.push_back("-g");
2637 }
2638 }
2639
2640 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2641 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2642 if (Args.hasArg(options::OPT_gcolumn_info))
2643 CmdArgs.push_back("-dwarf-column-info");
2644
2645 // FIXME: Move backend command line options to the module.
2646 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2647 // splitting and extraction.
2648 // FIXME: Currently only works on Linux.
2649 if (getToolChain().getTriple().isOSLinux() &&
2650 Args.hasArg(options::OPT_gsplit_dwarf)) {
2651 CmdArgs.push_back("-g");
2652 CmdArgs.push_back("-backend-option");
2653 CmdArgs.push_back("-split-dwarf=Enable");
2654 }
2655
2656 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2657 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2658 CmdArgs.push_back("-backend-option");
2659 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2660 }
2661
2662 Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2663
2664 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2665 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2666
2667 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2668
2669 if (Args.hasArg(options::OPT_ftest_coverage) ||
2670 Args.hasArg(options::OPT_coverage))
2671 CmdArgs.push_back("-femit-coverage-notes");
2672 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2673 Args.hasArg(options::OPT_coverage))
2674 CmdArgs.push_back("-femit-coverage-data");
2675
2676 if (C.getArgs().hasArg(options::OPT_c) ||
2677 C.getArgs().hasArg(options::OPT_S)) {
2678 if (Output.isFilename()) {
2679 CmdArgs.push_back("-coverage-file");
2680 SmallString<128> CoverageFilename(Output.getFilename());
2681 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2682 SmallString<128> Pwd;
2683 if (!llvm::sys::fs::current_path(Pwd)) {
2684 llvm::sys::path::append(Pwd, CoverageFilename.str());
2685 CoverageFilename.swap(Pwd);
2686 }
2687 }
2688 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2689 }
2690 }
2691
2692 // Pass options for controlling the default header search paths.
2693 if (Args.hasArg(options::OPT_nostdinc)) {
2694 CmdArgs.push_back("-nostdsysteminc");
2695 CmdArgs.push_back("-nobuiltininc");
2696 } else {
2697 if (Args.hasArg(options::OPT_nostdlibinc))
2698 CmdArgs.push_back("-nostdsysteminc");
2699 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2700 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2701 }
2702
2703 // Pass the path to compiler resource files.
2704 CmdArgs.push_back("-resource-dir");
2705 CmdArgs.push_back(D.ResourceDir.c_str());
2706
2707 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2708
2709 bool ARCMTEnabled = false;
2710 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2711 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2712 options::OPT_ccc_arcmt_modify,
2713 options::OPT_ccc_arcmt_migrate)) {
2714 ARCMTEnabled = true;
2715 switch (A->getOption().getID()) {
2716 default:
2717 llvm_unreachable("missed a case");
2718 case options::OPT_ccc_arcmt_check:
2719 CmdArgs.push_back("-arcmt-check");
2720 break;
2721 case options::OPT_ccc_arcmt_modify:
2722 CmdArgs.push_back("-arcmt-modify");
2723 break;
2724 case options::OPT_ccc_arcmt_migrate:
2725 CmdArgs.push_back("-arcmt-migrate");
2726 CmdArgs.push_back("-mt-migrate-directory");
2727 CmdArgs.push_back(A->getValue());
2728
2729 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2730 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2731 break;
2732 }
2733 }
2734 } else {
2735 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2736 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2737 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2738 }
2739
2740 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2741 if (ARCMTEnabled) {
2742 D.Diag(diag::err_drv_argument_not_allowed_with)
2743 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2744 }
2745 CmdArgs.push_back("-mt-migrate-directory");
2746 CmdArgs.push_back(A->getValue());
2747
2748 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2749 options::OPT_objcmt_migrate_subscripting,
2750 options::OPT_objcmt_migrate_property)) {
2751 // None specified, means enable them all.
2752 CmdArgs.push_back("-objcmt-migrate-literals");
2753 CmdArgs.push_back("-objcmt-migrate-subscripting");
2754 CmdArgs.push_back("-objcmt-migrate-property");
2755 } else {
2756 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2757 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2758 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2759 }
2760 } else {
2761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2762 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2763 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2768 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2769 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2770 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2771 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2772 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2773 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2774 Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path);
2775 }
2776
2777 // Add preprocessing options like -I, -D, etc. if we are using the
2778 // preprocessor.
2779 //
2780 // FIXME: Support -fpreprocessed
2781 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2782 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2783
2784 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2785 // that "The compiler can only warn and ignore the option if not recognized".
2786 // When building with ccache, it will pass -D options to clang even on
2787 // preprocessed inputs and configure concludes that -fPIC is not supported.
2788 Args.ClaimAllArgs(options::OPT_D);
2789
2790 // Manually translate -O4 to -O3; let clang reject others.
2791 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2792 if (A->getOption().matches(options::OPT_O4)) {
2793 CmdArgs.push_back("-O3");
2794 D.Diag(diag::warn_O4_is_O3);
2795 } else {
2796 A->render(Args, CmdArgs);
2797 }
2798 }
2799
2800 // Don't warn about unused -flto. This can happen when we're preprocessing or
2801 // precompiling.
2802 Args.ClaimAllArgs(options::OPT_flto);
2803
2804 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2805 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2806 CmdArgs.push_back("-pedantic");
2807 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2808 Args.AddLastArg(CmdArgs, options::OPT_w);
2809
2810 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2811 // (-ansi is equivalent to -std=c89 or -std=c++98).
2812 //
2813 // If a std is supplied, only add -trigraphs if it follows the
2814 // option.
2815 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2816 if (Std->getOption().matches(options::OPT_ansi))
2817 if (types::isCXX(InputType))
2818 CmdArgs.push_back("-std=c++98");
2819 else
2820 CmdArgs.push_back("-std=c89");
2821 else
2822 Std->render(Args, CmdArgs);
2823
2824 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2825 options::OPT_trigraphs))
2826 if (A != Std)
2827 A->render(Args, CmdArgs);
2828 } else {
2829 // Honor -std-default.
2830 //
2831 // FIXME: Clang doesn't correctly handle -std= when the input language
2832 // doesn't match. For the time being just ignore this for C++ inputs;
2833 // eventually we want to do all the standard defaulting here instead of
2834 // splitting it between the driver and clang -cc1.
2835 if (!types::isCXX(InputType))
2836 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2837 "-std=", /*Joined=*/true);
2838 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2839 CmdArgs.push_back("-std=c++11");
2840
2841 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2842 }
2843
2844 // GCC's behavior for -Wwrite-strings is a bit strange:
2845 // * In C, this "warning flag" changes the types of string literals from
2846 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2847 // for the discarded qualifier.
2848 // * In C++, this is just a normal warning flag.
2849 //
2850 // Implementing this warning correctly in C is hard, so we follow GCC's
2851 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2852 // a non-const char* in C, rather than using this crude hack.
2853 if (!types::isCXX(InputType)) {
2854 DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel(
2855 diag::warn_deprecated_string_literal_conversion_c, SourceLocation());
2856 if (DiagLevel > DiagnosticsEngine::Ignored)
2857 CmdArgs.push_back("-fconst-strings");
2858 }
2859
2860 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2861 // during C++ compilation, which it is by default. GCC keeps this define even
2862 // in the presence of '-w', match this behavior bug-for-bug.
2863 if (types::isCXX(InputType) &&
2864 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2865 true)) {
2866 CmdArgs.push_back("-fdeprecated-macro");
2867 }
2868
2869 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2870 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2871 if (Asm->getOption().matches(options::OPT_fasm))
2872 CmdArgs.push_back("-fgnu-keywords");
2873 else
2874 CmdArgs.push_back("-fno-gnu-keywords");
2875 }
2876
2877 if (ShouldDisableCFI(Args, getToolChain()))
2878 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2879
2880 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2881 CmdArgs.push_back("-fno-dwarf-directory-asm");
2882
2883 if (ShouldDisableAutolink(Args, getToolChain()))
2884 CmdArgs.push_back("-fno-autolink");
2885
2886 // Add in -fdebug-compilation-dir if necessary.
2887 addDebugCompDirArg(Args, CmdArgs);
2888
2889 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2890 options::OPT_ftemplate_depth_EQ)) {
2891 CmdArgs.push_back("-ftemplate-depth");
2892 CmdArgs.push_back(A->getValue());
2893 }
2894
2895 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
2896 CmdArgs.push_back("-foperator-arrow-depth");
2897 CmdArgs.push_back(A->getValue());
2898 }
2899
2900 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2901 CmdArgs.push_back("-fconstexpr-depth");
2902 CmdArgs.push_back(A->getValue());
2903 }
2904
2905 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2906 CmdArgs.push_back("-fconstexpr-steps");
2907 CmdArgs.push_back(A->getValue());
2908 }
2909
2910 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2911 CmdArgs.push_back("-fbracket-depth");
2912 CmdArgs.push_back(A->getValue());
2913 }
2914
2915 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2916 options::OPT_Wlarge_by_value_copy_def)) {
2917 if (A->getNumValues()) {
2918 StringRef bytes = A->getValue();
2919 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2920 } else
2921 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2922 }
2923
2924
2925 if (Args.hasArg(options::OPT_relocatable_pch))
2926 CmdArgs.push_back("-relocatable-pch");
2927
2928 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2929 CmdArgs.push_back("-fconstant-string-class");
2930 CmdArgs.push_back(A->getValue());
2931 }
2932
2933 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2934 CmdArgs.push_back("-ftabstop");
2935 CmdArgs.push_back(A->getValue());
2936 }
2937
2938 CmdArgs.push_back("-ferror-limit");
2939 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2940 CmdArgs.push_back(A->getValue());
2941 else
2942 CmdArgs.push_back("19");
2943
2944 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2945 CmdArgs.push_back("-fmacro-backtrace-limit");
2946 CmdArgs.push_back(A->getValue());
2947 }
2948
2949 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2950 CmdArgs.push_back("-ftemplate-backtrace-limit");
2951 CmdArgs.push_back(A->getValue());
2952 }
2953
2954 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2955 CmdArgs.push_back("-fconstexpr-backtrace-limit");
2956 CmdArgs.push_back(A->getValue());
2957 }
2958
2959 // Pass -fmessage-length=.
2960 CmdArgs.push_back("-fmessage-length");
2961 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2962 CmdArgs.push_back(A->getValue());
2963 } else {
2964 // If -fmessage-length=N was not specified, determine whether this is a
2965 // terminal and, if so, implicitly define -fmessage-length appropriately.
2966 unsigned N = llvm::sys::Process::StandardErrColumns();
2967 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2968 }
2969
2970 // -fvisibility= and -fvisibility-ms-compat are of a piece.
2971 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2972 options::OPT_fvisibility_ms_compat)) {
2973 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2974 CmdArgs.push_back("-fvisibility");
2975 CmdArgs.push_back(A->getValue());
2976 } else {
2977 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2978 CmdArgs.push_back("-fvisibility");
2979 CmdArgs.push_back("hidden");
2980 CmdArgs.push_back("-ftype-visibility");
2981 CmdArgs.push_back("default");
2982 }
2983 }
2984
2985 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2986
2987 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2988
2989 // -fhosted is default.
2990 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2991 KernelOrKext)
2992 CmdArgs.push_back("-ffreestanding");
2993
2994 // Forward -f (flag) options which we can pass directly.
2995 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2996 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2997 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2998 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2999 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
3000 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3001 // AltiVec language extensions aren't relevant for assembling.
3002 if (!isa<PreprocessJobAction>(JA) ||
3003 Output.getType() != types::TY_PP_Asm)
3004 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
3005 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3006 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3007
3008 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3009 Sanitize.addArgs(Args, CmdArgs);
3010
3011 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3012 options::OPT_fno_sanitize_recover,
3013 true))
3014 CmdArgs.push_back("-fno-sanitize-recover");
3015
3016 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3017 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3018 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3019 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3020
3021 // Report an error for -faltivec on anything other than PowerPC.
3022 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3023 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
3024 getToolChain().getArch() == llvm::Triple::ppc64 ||
3025 getToolChain().getArch() == llvm::Triple::ppc64le))
3026 D.Diag(diag::err_drv_argument_only_allowed_with)
3027 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3028
3029 if (getToolChain().SupportsProfiling())
3030 Args.AddLastArg(CmdArgs, options::OPT_pg);
3031
3032 // -flax-vector-conversions is default.
3033 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3034 options::OPT_fno_lax_vector_conversions))
3035 CmdArgs.push_back("-fno-lax-vector-conversions");
3036
3037 if (Args.getLastArg(options::OPT_fapple_kext))
3038 CmdArgs.push_back("-fapple-kext");
3039
3040 if (Args.hasFlag(options::OPT_frewrite_includes,
3041 options::OPT_fno_rewrite_includes, false))
3042 CmdArgs.push_back("-frewrite-includes");
3043
3044 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3045 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3046 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3047 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3048 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3049
3050 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3051 CmdArgs.push_back("-ftrapv-handler");
3052 CmdArgs.push_back(A->getValue());
3053 }
3054
3055 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3056
3057 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3058 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3059 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3060 options::OPT_fno_wrapv)) {
3061 if (A->getOption().matches(options::OPT_fwrapv))
3062 CmdArgs.push_back("-fwrapv");
3063 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3064 options::OPT_fno_strict_overflow)) {
3065 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3066 CmdArgs.push_back("-fwrapv");
3067 }
3068
3069 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3070 options::OPT_fno_reroll_loops))
3071 if (A->getOption().matches(options::OPT_freroll_loops))
3072 CmdArgs.push_back("-freroll-loops");
3073
3074 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3075 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3076 options::OPT_fno_unroll_loops);
3077
3078 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3079
3080
3081 // -stack-protector=0 is default.
3082 unsigned StackProtectorLevel = 0;
3083 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3084 options::OPT_fstack_protector_all,
3085 options::OPT_fstack_protector)) {
3086 if (A->getOption().matches(options::OPT_fstack_protector))
3087 StackProtectorLevel = 1;
3088 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3089 StackProtectorLevel = 2;
3090 } else {
3091 StackProtectorLevel =
3092 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3093 }
3094 if (StackProtectorLevel) {
3095 CmdArgs.push_back("-stack-protector");
3096 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3097 }
3098
3099 // --param ssp-buffer-size=
3100 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3101 ie = Args.filtered_end(); it != ie; ++it) {
3102 StringRef Str((*it)->getValue());
3103 if (Str.startswith("ssp-buffer-size=")) {
3104 if (StackProtectorLevel) {
3105 CmdArgs.push_back("-stack-protector-buffer-size");
3106 // FIXME: Verify the argument is a valid integer.
3107 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3108 }
3109 (*it)->claim();
3110 }
3111 }
3112
3113 // Translate -mstackrealign
3114 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3115 false)) {
3116 CmdArgs.push_back("-backend-option");
3117 CmdArgs.push_back("-force-align-stack");
3118 }
3119 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3120 false)) {
3121 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3122 }
3123
3124 if (Args.hasArg(options::OPT_mstack_alignment)) {
3125 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3126 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3127 }
3128 // -mkernel implies -mstrict-align; don't add the redundant option.
3129 if (!KernelOrKext) {
3130 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3131 options::OPT_munaligned_access)) {
3132 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3133 CmdArgs.push_back("-backend-option");
3134 CmdArgs.push_back("-arm-strict-align");
3135 } else {
3136 CmdArgs.push_back("-backend-option");
3137 CmdArgs.push_back("-arm-no-strict-align");
3138 }
3139 }
3140 }
3141
3142 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3143 options::OPT_mno_restrict_it)) {
3144 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3145 CmdArgs.push_back("-backend-option");
3146 CmdArgs.push_back("-arm-restrict-it");
3147 } else {
3148 CmdArgs.push_back("-backend-option");
3149 CmdArgs.push_back("-arm-no-restrict-it");
3150 }
3151 }
3152
3153 // Forward -f options with positive and negative forms; we translate
3154 // these by hand.
3155 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3156 StringRef fname = A->getValue();
3157 if (!llvm::sys::fs::exists(fname))
3158 D.Diag(diag::err_drv_no_such_file) << fname;
3159 else
3160 A->render(Args, CmdArgs);
3161 }
3162
3163 if (Args.hasArg(options::OPT_mkernel)) {
3164 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3165 CmdArgs.push_back("-fapple-kext");
3166 if (!Args.hasArg(options::OPT_fbuiltin))
3167 CmdArgs.push_back("-fno-builtin");
3168 Args.ClaimAllArgs(options::OPT_fno_builtin);
3169 }
3170 // -fbuiltin is default.
3171 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3172 CmdArgs.push_back("-fno-builtin");
3173
3174 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3175 options::OPT_fno_assume_sane_operator_new))
3176 CmdArgs.push_back("-fno-assume-sane-operator-new");
3177
3178 // -fblocks=0 is default.
3179 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3180 getToolChain().IsBlocksDefault()) ||
3181 (Args.hasArg(options::OPT_fgnu_runtime) &&
3182 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3183 !Args.hasArg(options::OPT_fno_blocks))) {
3184 CmdArgs.push_back("-fblocks");
3185
3186 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3187 !getToolChain().hasBlocksRuntime())
3188 CmdArgs.push_back("-fblocks-runtime-optional");
3189 }
3190
3191 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3192 // users must also pass -fcxx-modules. The latter flag will disappear once the
3193 // modules implementation is solid for C++/Objective-C++ programs as well.
3194 bool HaveModules = false;
3195 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3196 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3197 options::OPT_fno_cxx_modules,
3198 false);
3199 if (AllowedInCXX || !types::isCXX(InputType)) {
3200 CmdArgs.push_back("-fmodules");
3201 HaveModules = true;
3202 }
3203 }
3204
3205 // -fmodule-maps enables module map processing (off by default) for header
3206 // checking. It is implied by -fmodules.
3207 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3208 false)) {
3209 CmdArgs.push_back("-fmodule-maps");
3210 }
3211
3212 // -fmodules-decluse checks that modules used are declared so (off by
3213 // default).
3214 if (Args.hasFlag(options::OPT_fmodules_decluse,
3215 options::OPT_fno_modules_decluse,
3216 false)) {
3217 CmdArgs.push_back("-fmodules-decluse");
3218 }
3219
3220 // -fmodule-name specifies the module that is currently being built (or
3221 // used for header checking by -fmodule-maps).
3222 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3223 A->claim();
3224 A->render(Args, CmdArgs);
3225 }
3226
3227 // -fmodule-map-file can be used to specify a file containing module
3228 // definitions.
3229 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3230 A->claim();
3231 A->render(Args, CmdArgs);
3232 }
3233
3234 // If a module path was provided, pass it along. Otherwise, use a temporary
3235 // directory.
3236 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3237 A->claim();
3238 if (HaveModules) {
3239 A->render(Args, CmdArgs);
3240 }
3241 } else if (HaveModules) {
3242 SmallString<128> DefaultModuleCache;
3243 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3244 DefaultModuleCache);
3245 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3246 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
3247 const char Arg[] = "-fmodules-cache-path=";
3248 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3249 Arg, Arg + strlen(Arg));
3250 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3251 }
3252
3253 // Pass through all -fmodules-ignore-macro arguments.
3254 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3255 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3256 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3257
3258 // -faccess-control is default.
3259 if (Args.hasFlag(options::OPT_fno_access_control,
3260 options::OPT_faccess_control,
3261 false))
3262 CmdArgs.push_back("-fno-access-control");
3263
3264 // -felide-constructors is the default.
3265 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3266 options::OPT_felide_constructors,
3267 false))
3268 CmdArgs.push_back("-fno-elide-constructors");
3269
3270 // -frtti is default.
3271 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3272 KernelOrKext) {
3273 CmdArgs.push_back("-fno-rtti");
3274
3275 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
3276 if (Sanitize.sanitizesVptr()) {
3277 std::string NoRttiArg =
3278 Args.getLastArg(options::OPT_mkernel,
3279 options::OPT_fapple_kext,
3280 options::OPT_fno_rtti)->getAsString(Args);
3281 D.Diag(diag::err_drv_argument_not_allowed_with)
3282 << "-fsanitize=vptr" << NoRttiArg;
3283 }
3284 }
3285
3286 // -fshort-enums=0 is default for all architectures except Hexagon.
3287 if (Args.hasFlag(options::OPT_fshort_enums,
3288 options::OPT_fno_short_enums,
3289 getToolChain().getArch() ==
3290 llvm::Triple::hexagon))
3291 CmdArgs.push_back("-fshort-enums");
3292
3293 // -fsigned-char is default.
3294 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3295 isSignedCharDefault(getToolChain().getTriple())))
3296 CmdArgs.push_back("-fno-signed-char");
3297
3298 // -fthreadsafe-static is default.
3299 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3300 options::OPT_fno_threadsafe_statics))
3301 CmdArgs.push_back("-fno-threadsafe-statics");
3302
3303 // -fuse-cxa-atexit is default.
3304 if (!Args.hasFlag(
3305 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3306 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3307 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
3308 getToolChain().getArch() != llvm::Triple::hexagon &&
3309 getToolChain().getArch() != llvm::Triple::xcore) ||
3310 KernelOrKext)
3311 CmdArgs.push_back("-fno-use-cxa-atexit");
3312
3313 // -fms-extensions=0 is default.
3314 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3315 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3316 CmdArgs.push_back("-fms-extensions");
3317
3318 // -fms-compatibility=0 is default.
3319 if (Args.hasFlag(options::OPT_fms_compatibility,
3320 options::OPT_fno_ms_compatibility,
3321 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3322 Args.hasFlag(options::OPT_fms_extensions,
3323 options::OPT_fno_ms_extensions,
3324 true))))
3325 CmdArgs.push_back("-fms-compatibility");
3326
3327 // -fmsc-version=1700 is default.
3328 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3329 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3330 Args.hasArg(options::OPT_fmsc_version)) {
3331 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3332 if (msc_ver.empty())
3333 CmdArgs.push_back("-fmsc-version=1700");
3334 else
3335 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3336 }
3337
3338
3339 // -fno-borland-extensions is default.
3340 if (Args.hasFlag(options::OPT_fborland_extensions,
3341 options::OPT_fno_borland_extensions, false))
3342 CmdArgs.push_back("-fborland-extensions");
3343
3344 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3345 // needs it.
3346 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3347 options::OPT_fno_delayed_template_parsing,
3348 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3349 CmdArgs.push_back("-fdelayed-template-parsing");
3350
3351 // -fgnu-keywords default varies depending on language; only pass if
3352 // specified.
3353 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3354 options::OPT_fno_gnu_keywords))
3355 A->render(Args, CmdArgs);
3356
3357 if (Args.hasFlag(options::OPT_fgnu89_inline,
3358 options::OPT_fno_gnu89_inline,
3359 false))
3360 CmdArgs.push_back("-fgnu89-inline");
3361
3362 if (Args.hasArg(options::OPT_fno_inline))
3363 CmdArgs.push_back("-fno-inline");
3364
3365 if (Args.hasArg(options::OPT_fno_inline_functions))
3366 CmdArgs.push_back("-fno-inline-functions");
3367
3368 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3369
3370 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3371 // legacy is the default. Next runtime is always legacy dispatch and
3372 // -fno-objc-legacy-dispatch gets ignored silently.
3373 if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) {
3374 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3375 options::OPT_fno_objc_legacy_dispatch,
3376 objcRuntime.isLegacyDispatchDefaultForArch(
3377 getToolChain().getArch()))) {
3378 if (getToolChain().UseObjCMixedDispatch())
3379 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3380 else
3381 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3382 }
3383 }
3384
3385 // When ObjectiveC legacy runtime is in effect on MacOSX,
3386 // turn on the option to do Array/Dictionary subscripting
3387 // by default.
3388 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3389 getToolChain().getTriple().isMacOSX() &&
3390 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3391 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
3392 objcRuntime.isNeXTFamily())
3393 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3394
3395 // -fencode-extended-block-signature=1 is default.
3396 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3397 CmdArgs.push_back("-fencode-extended-block-signature");
3398 }
3399
3400 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3401 // NOTE: This logic is duplicated in ToolChains.cpp.
3402 bool ARC = isObjCAutoRefCount(Args);
3403 if (ARC) {
3404 getToolChain().CheckObjCARC();
3405
3406 CmdArgs.push_back("-fobjc-arc");
3407
3408 // FIXME: It seems like this entire block, and several around it should be
3409 // wrapped in isObjC, but for now we just use it here as this is where it
3410 // was being used previously.
3411 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3412 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3413 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3414 else
3415 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3416 }
3417
3418 // Allow the user to enable full exceptions code emission.
3419 // We define off for Objective-CC, on for Objective-C++.
3420 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3421 options::OPT_fno_objc_arc_exceptions,
3422 /*default*/ types::isCXX(InputType)))
3423 CmdArgs.push_back("-fobjc-arc-exceptions");
3424 }
3425
3426 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3427 // rewriter.
3428 if (rewriteKind != RK_None)
3429 CmdArgs.push_back("-fno-objc-infer-related-result-type");
3430
3431 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3432 // takes precedence.
3433 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3434 if (!GCArg)
3435 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3436 if (GCArg) {
3437 if (ARC) {
3438 D.Diag(diag::err_drv_objc_gc_arr)
3439 << GCArg->getAsString(Args);
3440 } else if (getToolChain().SupportsObjCGC()) {
3441 GCArg->render(Args, CmdArgs);
3442 } else {
3443 // FIXME: We should move this to a hard error.
3444 D.Diag(diag::warn_drv_objc_gc_unsupported)
3445 << GCArg->getAsString(Args);
3446 }
3447 }
3448
3449 // Add exception args.
3450 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3451 KernelOrKext, objcRuntime, CmdArgs);
3452
3453 if (getToolChain().UseSjLjExceptions())
3454 CmdArgs.push_back("-fsjlj-exceptions");
3455
3456 // C++ "sane" operator new.
3457 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3458 options::OPT_fno_assume_sane_operator_new))
3459 CmdArgs.push_back("-fno-assume-sane-operator-new");
3460
3461 // -fconstant-cfstrings is default, and may be subject to argument translation
3462 // on Darwin.
3463 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3464 options::OPT_fno_constant_cfstrings) ||
3465 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3466 options::OPT_mno_constant_cfstrings))
3467 CmdArgs.push_back("-fno-constant-cfstrings");
3468
3469 // -fshort-wchar default varies depending on platform; only
3470 // pass if specified.
3471 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3472 A->render(Args, CmdArgs);
3473
3474 // -fno-pascal-strings is default, only pass non-default.
3475 if (Args.hasFlag(options::OPT_fpascal_strings,
3476 options::OPT_fno_pascal_strings,
3477 false))
3478 CmdArgs.push_back("-fpascal-strings");
3479
3480 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3481 // -fno-pack-struct doesn't apply to -fpack-struct=.
3482 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3483 std::string PackStructStr = "-fpack-struct=";
3484 PackStructStr += A->getValue();
3485 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3486 } else if (Args.hasFlag(options::OPT_fpack_struct,
3487 options::OPT_fno_pack_struct, false)) {
3488 CmdArgs.push_back("-fpack-struct=1");
3489 }
3490
3491 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
3492 if (!Args.hasArg(options::OPT_fcommon))
3493 CmdArgs.push_back("-fno-common");
3494 Args.ClaimAllArgs(options::OPT_fno_common);
3495 }
3496
3497 // -fcommon is default, only pass non-default.
3498 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3499 CmdArgs.push_back("-fno-common");
3500
3501 // -fsigned-bitfields is default, and clang doesn't yet support
3502 // -funsigned-bitfields.
3503 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3504 options::OPT_funsigned_bitfields))
3505 D.Diag(diag::warn_drv_clang_unsupported)
3506 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3507
3508 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3509 if (!Args.hasFlag(options::OPT_ffor_scope,
3510 options::OPT_fno_for_scope))
3511 D.Diag(diag::err_drv_clang_unsupported)
3512 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3513
3514 // -fcaret-diagnostics is default.
3515 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3516 options::OPT_fno_caret_diagnostics, true))
3517 CmdArgs.push_back("-fno-caret-diagnostics");
3518
3519 // -fdiagnostics-fixit-info is default, only pass non-default.
3520 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3521 options::OPT_fno_diagnostics_fixit_info))
3522 CmdArgs.push_back("-fno-diagnostics-fixit-info");
3523
3524 // Enable -fdiagnostics-show-option by default.
3525 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3526 options::OPT_fno_diagnostics_show_option))
3527 CmdArgs.push_back("-fdiagnostics-show-option");
3528
3529 if (const Arg *A =
3530 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3531 CmdArgs.push_back("-fdiagnostics-show-category");
3532 CmdArgs.push_back(A->getValue());
3533 }
3534
3535 if (const Arg *A =
3536 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3537 CmdArgs.push_back("-fdiagnostics-format");
3538 CmdArgs.push_back(A->getValue());
3539 }
3540
3541 if (Arg *A = Args.getLastArg(
3542 options::OPT_fdiagnostics_show_note_include_stack,
3543 options::OPT_fno_diagnostics_show_note_include_stack)) {
3544 if (A->getOption().matches(
3545 options::OPT_fdiagnostics_show_note_include_stack))
3546 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3547 else
3548 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3549 }
3550
3551 // Color diagnostics are the default, unless the terminal doesn't support
3552 // them.
3553 // Support both clang's -f[no-]color-diagnostics and gcc's
3554 // -f[no-]diagnostics-colors[=never|always|auto].
3555 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3556 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3557 it != ie; ++it) {
3558 const Option &O = (*it)->getOption();
3559 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3560 !O.matches(options::OPT_fdiagnostics_color) &&
3561 !O.matches(options::OPT_fno_color_diagnostics) &&
3562 !O.matches(options::OPT_fno_diagnostics_color) &&
3563 !O.matches(options::OPT_fdiagnostics_color_EQ))
3564 continue;
3565
3566 (*it)->claim();
3567 if (O.matches(options::OPT_fcolor_diagnostics) ||
3568 O.matches(options::OPT_fdiagnostics_color)) {
3569 ShowColors = Colors_On;
3570 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3571 O.matches(options::OPT_fno_diagnostics_color)) {
3572 ShowColors = Colors_Off;
3573 } else {
3574 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3575 StringRef value((*it)->getValue());
3576 if (value == "always")
3577 ShowColors = Colors_On;
3578 else if (value == "never")
3579 ShowColors = Colors_Off;
3580 else if (value == "auto")
3581 ShowColors = Colors_Auto;
3582 else
3583 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3584 << ("-fdiagnostics-color=" + value).str();
3585 }
3586 }
3587 if (ShowColors == Colors_On ||
3588 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
3589 CmdArgs.push_back("-fcolor-diagnostics");
3590
3591 if (Args.hasArg(options::OPT_fansi_escape_codes))
3592 CmdArgs.push_back("-fansi-escape-codes");
3593
3594 if (!Args.hasFlag(options::OPT_fshow_source_location,
3595 options::OPT_fno_show_source_location))
3596 CmdArgs.push_back("-fno-show-source-location");
3597
3598 if (!Args.hasFlag(options::OPT_fshow_column,
3599 options::OPT_fno_show_column,
3600 true))
3601 CmdArgs.push_back("-fno-show-column");
3602
3603 if (!Args.hasFlag(options::OPT_fspell_checking,
3604 options::OPT_fno_spell_checking))
3605 CmdArgs.push_back("-fno-spell-checking");
3606
3607
3608 // -fno-asm-blocks is default.
3609 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3610 false))
3611 CmdArgs.push_back("-fasm-blocks");
3612
3613 // Enable vectorization per default according to the optimization level
3614 // selected. For optimization levels that want vectorization we use the alias
3615 // option to simplify the hasFlag logic.
3616 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3617 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
3618 options::OPT_fvectorize;
3619 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
3620 options::OPT_fno_vectorize, EnableVec))
3621 CmdArgs.push_back("-vectorize-loops");
3622
3623 // -fslp-vectorize is default.
3624 if (Args.hasFlag(options::OPT_fslp_vectorize,
3625 options::OPT_fno_slp_vectorize, true))
3626 CmdArgs.push_back("-vectorize-slp");
3627
3628 // -fno-slp-vectorize-aggressive is default.
3629 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
3630 options::OPT_fno_slp_vectorize_aggressive, false))
3631 CmdArgs.push_back("-vectorize-slp-aggressive");
3632
3633 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3634 A->render(Args, CmdArgs);
3635
3636 // -fdollars-in-identifiers default varies depending on platform and
3637 // language; only pass if specified.
3638 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3639 options::OPT_fno_dollars_in_identifiers)) {
3640 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3641 CmdArgs.push_back("-fdollars-in-identifiers");
3642 else
3643 CmdArgs.push_back("-fno-dollars-in-identifiers");
3644 }
3645
3646 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3647 // practical purposes.
3648 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3649 options::OPT_fno_unit_at_a_time)) {
3650 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3651 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3652 }
3653
3654 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3655 options::OPT_fno_apple_pragma_pack, false))
3656 CmdArgs.push_back("-fapple-pragma-pack");
3657
3658 // le32-specific flags:
3659 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3660 // by default.
3661 if (getToolChain().getArch() == llvm::Triple::le32) {
3662 CmdArgs.push_back("-fno-math-builtin");
3663 }
3664
3665 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3666 //
3667 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3668#if 0
3669 if (getToolChain().getTriple().isOSDarwin() &&
3670 (getToolChain().getArch() == llvm::Triple::arm ||
3671 getToolChain().getArch() == llvm::Triple::thumb)) {
3672 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3673 CmdArgs.push_back("-fno-builtin-strcat");
3674 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3675 CmdArgs.push_back("-fno-builtin-strcpy");
3676 }
3677#endif
3678
3679 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3680 if (Arg *A = Args.getLastArg(options::OPT_traditional,
3681 options::OPT_traditional_cpp)) {
3682 if (isa<PreprocessJobAction>(JA))
3683 CmdArgs.push_back("-traditional-cpp");
3684 else
3685 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3686 }
3687
3688 Args.AddLastArg(CmdArgs, options::OPT_dM);
3689 Args.AddLastArg(CmdArgs, options::OPT_dD);
3690
3691 // Handle serialized diagnostics.
3692 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3693 CmdArgs.push_back("-serialize-diagnostic-file");
3694 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3695 }
3696
3697 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3698 CmdArgs.push_back("-fretain-comments-from-system-headers");
3699
3700 // Forward -fcomment-block-commands to -cc1.
3701 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3702 // Forward -fparse-all-comments to -cc1.
3703 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
3704
3705 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3706 // parser.
3707 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3708 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3709 ie = Args.filtered_end(); it != ie; ++it) {
3710 (*it)->claim();
3711
3712 // We translate this by hand to the -cc1 argument, since nightly test uses
3713 // it and developers have been trained to spell it with -mllvm.
3714 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3715 CmdArgs.push_back("-disable-llvm-optzns");
3716 else
3717 (*it)->render(Args, CmdArgs);
3718 }
3719
3720 if (Output.getType() == types::TY_Dependencies) {
3721 // Handled with other dependency code.
3722 } else if (Output.isFilename()) {
3723 CmdArgs.push_back("-o");
3724 CmdArgs.push_back(Output.getFilename());
3725 } else {
3726 assert(Output.isNothing() && "Invalid output.");
3727 }
3728
3729 for (InputInfoList::const_iterator
3730 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3731 const InputInfo &II = *it;
3732 CmdArgs.push_back("-x");
3733 if (Args.hasArg(options::OPT_rewrite_objc))
3734 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3735 else
3736 CmdArgs.push_back(types::getTypeName(II.getType()));
3737 if (II.isFilename())
3738 CmdArgs.push_back(II.getFilename());
3739 else
3740 II.getInputArg().renderAsInput(Args, CmdArgs);
3741 }
3742
3743 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3744
3745 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3746
3747 // Optionally embed the -cc1 level arguments into the debug info, for build
3748 // analysis.
3749 if (getToolChain().UseDwarfDebugFlags()) {
3750 ArgStringList OriginalArgs;
3751 for (ArgList::const_iterator it = Args.begin(),
3752 ie = Args.end(); it != ie; ++it)
3753 (*it)->render(Args, OriginalArgs);
3754
3755 SmallString<256> Flags;
3756 Flags += Exec;
3757 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3758 Flags += " ";
3759 Flags += OriginalArgs[i];
3760 }
3761 CmdArgs.push_back("-dwarf-debug-flags");
3762 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3763 }
3764
3765 // Add the split debug info name to the command lines here so we
3766 // can propagate it to the backend.
3767 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3768 getToolChain().getTriple().isOSLinux() &&
3769 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3770 const char *SplitDwarfOut;
3771 if (SplitDwarf) {
3772 CmdArgs.push_back("-split-dwarf-file");
3773 SplitDwarfOut = SplitDebugName(Args, Inputs);
3774 CmdArgs.push_back(SplitDwarfOut);
3775 }
3776
3777 // Finally add the compile command to the compilation.
3778 if (Args.hasArg(options::OPT__SLASH_fallback)) {
3779 tools::visualstudio::Compile CL(getToolChain());
3780 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3781 LinkingOutput);
3782 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3783 } else {
3784 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3785 }
3786
3787
3788 // Handle the debug info splitting at object creation time if we're
3789 // creating an object.
3790 // TODO: Currently only works on linux with newer objcopy.
3791 if (SplitDwarf && !isa<CompileJobAction>(JA))
3792 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3793
3794 if (Arg *A = Args.getLastArg(options::OPT_pg))
3795 if (Args.hasArg(options::OPT_fomit_frame_pointer))
3796 D.Diag(diag::err_drv_argument_not_allowed_with)
3797 << "-fomit-frame-pointer" << A->getAsString(Args);
3798
3799 // Claim some arguments which clang supports automatically.
3800
3801 // -fpch-preprocess is used with gcc to add a special marker in the output to
3802 // include the PCH file. Clang's PTH solution is completely transparent, so we
3803 // do not need to deal with it at all.
3804 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3805
3806 // Claim some arguments which clang doesn't support, but we don't
3807 // care to warn the user about.
3808 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3809 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3810
3811 // Disable warnings for clang -E -emit-llvm foo.c
3812 Args.ClaimAllArgs(options::OPT_emit_llvm);
3813}
3814
3815/// Add options related to the Objective-C runtime/ABI.
3816///
3817/// Returns true if the runtime is non-fragile.
3818ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3819 ArgStringList &cmdArgs,
3820 RewriteKind rewriteKind) const {
3821 // Look for the controlling runtime option.
3822 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3823 options::OPT_fgnu_runtime,
3824 options::OPT_fobjc_runtime_EQ);
3825
3826 // Just forward -fobjc-runtime= to the frontend. This supercedes
3827 // options about fragility.
3828 if (runtimeArg &&
3829 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3830 ObjCRuntime runtime;
3831 StringRef value = runtimeArg->getValue();
3832 if (runtime.tryParse(value)) {
3833 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3834 << value;
3835 }
3836
3837 runtimeArg->render(args, cmdArgs);
3838 return runtime;
3839 }
3840
3841 // Otherwise, we'll need the ABI "version". Version numbers are
3842 // slightly confusing for historical reasons:
3843 // 1 - Traditional "fragile" ABI
3844 // 2 - Non-fragile ABI, version 1
3845 // 3 - Non-fragile ABI, version 2
3846 unsigned objcABIVersion = 1;
3847 // If -fobjc-abi-version= is present, use that to set the version.
3848 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3849 StringRef value = abiArg->getValue();
3850 if (value == "1")
3851 objcABIVersion = 1;
3852 else if (value == "2")
3853 objcABIVersion = 2;
3854 else if (value == "3")
3855 objcABIVersion = 3;
3856 else
3857 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3858 << value;
3859 } else {
3860 // Otherwise, determine if we are using the non-fragile ABI.
3861 bool nonFragileABIIsDefault =
3862 (rewriteKind == RK_NonFragile ||
3863 (rewriteKind == RK_None &&
3864 getToolChain().IsObjCNonFragileABIDefault()));
3865 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3866 options::OPT_fno_objc_nonfragile_abi,
3867 nonFragileABIIsDefault)) {
3868 // Determine the non-fragile ABI version to use.
3869#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3870 unsigned nonFragileABIVersion = 1;
3871#else
3872 unsigned nonFragileABIVersion = 2;
3873#endif
3874
3875 if (Arg *abiArg = args.getLastArg(
3876 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3877 StringRef value = abiArg->getValue();
3878 if (value == "1")
3879 nonFragileABIVersion = 1;
3880 else if (value == "2")
3881 nonFragileABIVersion = 2;
3882 else
3883 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3884 << value;
3885 }
3886
3887 objcABIVersion = 1 + nonFragileABIVersion;
3888 } else {
3889 objcABIVersion = 1;
3890 }
3891 }
3892
3893 // We don't actually care about the ABI version other than whether
3894 // it's non-fragile.
3895 bool isNonFragile = objcABIVersion != 1;
3896
3897 // If we have no runtime argument, ask the toolchain for its default runtime.
3898 // However, the rewriter only really supports the Mac runtime, so assume that.
3899 ObjCRuntime runtime;
3900 if (!runtimeArg) {
3901 switch (rewriteKind) {
3902 case RK_None:
3903 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3904 break;
3905 case RK_Fragile:
3906 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3907 break;
3908 case RK_NonFragile:
3909 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3910 break;
3911 }
3912
3913 // -fnext-runtime
3914 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3915 // On Darwin, make this use the default behavior for the toolchain.
3916 if (getToolChain().getTriple().isOSDarwin()) {
3917 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3918
3919 // Otherwise, build for a generic macosx port.
3920 } else {
3921 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3922 }
3923
3924 // -fgnu-runtime
3925 } else {
3926 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3927 // Legacy behaviour is to target the gnustep runtime if we are i
3928 // non-fragile mode or the GCC runtime in fragile mode.
3929 if (isNonFragile)
3930 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3931 else
3932 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3933 }
3934
3935 cmdArgs.push_back(args.MakeArgString(
3936 "-fobjc-runtime=" + runtime.getAsString()));
3937 return runtime;
3938}
3939
3940void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3941 unsigned RTOptionID = options::OPT__SLASH_MT;
3942
3943 if (Args.hasArg(options::OPT__SLASH_LDd))
3944 // The /LDd option implies /MTd. The dependent lib part can be overridden,
3945 // but defining _DEBUG is sticky.
3946 RTOptionID = options::OPT__SLASH_MTd;
3947
3948 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
3949 RTOptionID = A->getOption().getID();
3950
3951 switch(RTOptionID) {
3952 case options::OPT__SLASH_MD:
3953 if (Args.hasArg(options::OPT__SLASH_LDd))
3954 CmdArgs.push_back("-D_DEBUG");
3955 CmdArgs.push_back("-D_MT");
3956 CmdArgs.push_back("-D_DLL");
3957 CmdArgs.push_back("--dependent-lib=msvcrt");
3958 break;
3959 case options::OPT__SLASH_MDd:
3960 CmdArgs.push_back("-D_DEBUG");
3961 CmdArgs.push_back("-D_MT");
3962 CmdArgs.push_back("-D_DLL");
3963 CmdArgs.push_back("--dependent-lib=msvcrtd");
3964 break;
3965 case options::OPT__SLASH_MT:
3966 if (Args.hasArg(options::OPT__SLASH_LDd))
3967 CmdArgs.push_back("-D_DEBUG");
3968 CmdArgs.push_back("-D_MT");
3969 CmdArgs.push_back("--dependent-lib=libcmt");
3970 break;
3971 case options::OPT__SLASH_MTd:
3972 CmdArgs.push_back("-D_DEBUG");
3973 CmdArgs.push_back("-D_MT");
3974 CmdArgs.push_back("--dependent-lib=libcmtd");
3975 break;
3976 default:
3977 llvm_unreachable("Unexpected option ID.");
3978 }
3979
3980 // This provides POSIX compatibility (maps 'open' to '_open'), which most
3981 // users want. The /Za flag to cl.exe turns this off, but it's not
3982 // implemented in clang.
3983 CmdArgs.push_back("--dependent-lib=oldnames");
3984
3985 // FIXME: Make this default for the win32 triple.
3986 CmdArgs.push_back("-cxx-abi");
3987 CmdArgs.push_back("microsoft");
3988
3989 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3990 A->render(Args, CmdArgs);
3991
3992 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3993 CmdArgs.push_back("-fdiagnostics-format");
3994 if (Args.hasArg(options::OPT__SLASH_fallback))
3995 CmdArgs.push_back("msvc-fallback");
3996 else
3997 CmdArgs.push_back("msvc");
3998 }
3999}
4000
4001void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
4002 const InputInfo &Output,
4003 const InputInfoList &Inputs,
4004 const ArgList &Args,
4005 const char *LinkingOutput) const {
4006 ArgStringList CmdArgs;
4007
4008 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4009 const InputInfo &Input = Inputs[0];
4010
4011 // Don't warn about "clang -w -c foo.s"
4012 Args.ClaimAllArgs(options::OPT_w);
4013 // and "clang -emit-llvm -c foo.s"
4014 Args.ClaimAllArgs(options::OPT_emit_llvm);
4015
4016 // Invoke ourselves in -cc1as mode.
4017 //
4018 // FIXME: Implement custom jobs for internal actions.
4019 CmdArgs.push_back("-cc1as");
4020
4021 // Add the "effective" target triple.
4022 CmdArgs.push_back("-triple");
4023 std::string TripleStr =
4024 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4025 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4026
4027 // Set the output mode, we currently only expect to be used as a real
4028 // assembler.
4029 CmdArgs.push_back("-filetype");
4030 CmdArgs.push_back("obj");
4031
4032 // Set the main file name, so that debug info works even with
4033 // -save-temps or preprocessed assembly.
4034 CmdArgs.push_back("-main-file-name");
4035 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4036
4037 // Add the target cpu
4038 const llvm::Triple &Triple = getToolChain().getTriple();
4039 std::string CPU = getCPUName(Args, Triple);
4040 if (!CPU.empty()) {
4041 CmdArgs.push_back("-target-cpu");
4042 CmdArgs.push_back(Args.MakeArgString(CPU));
4043 }
4044
4045 // Add the target features
4046 const Driver &D = getToolChain().getDriver();
4047 getTargetFeatures(D, Triple, Args, CmdArgs);
4048
4049 // Ignore explicit -force_cpusubtype_ALL option.
4050 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4051
4052 // Determine the original source input.
4053 const Action *SourceAction = &JA;
4054 while (SourceAction->getKind() != Action::InputClass) {
4055 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4056 SourceAction = SourceAction->getInputs()[0];
4057 }
4058
4059 // Forward -g and handle debug info related flags, assuming we are dealing
4060 // with an actual assembly file.
4061 if (SourceAction->getType() == types::TY_Asm ||
4062 SourceAction->getType() == types::TY_PP_Asm) {
4063 Args.ClaimAllArgs(options::OPT_g_Group);
4064 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4065 if (!A->getOption().matches(options::OPT_g0))
4066 CmdArgs.push_back("-g");
4067
4068 // Add the -fdebug-compilation-dir flag if needed.
4069 addDebugCompDirArg(Args, CmdArgs);
4070
4071 // Set the AT_producer to the clang version when using the integrated
4072 // assembler on assembly source files.
4073 CmdArgs.push_back("-dwarf-debug-producer");
4074 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4075 }
4076
4077 // Optionally embed the -cc1as level arguments into the debug info, for build
4078 // analysis.
4079 if (getToolChain().UseDwarfDebugFlags()) {
4080 ArgStringList OriginalArgs;
4081 for (ArgList::const_iterator it = Args.begin(),
4082 ie = Args.end(); it != ie; ++it)
4083 (*it)->render(Args, OriginalArgs);
4084
4085 SmallString<256> Flags;
4086 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4087 Flags += Exec;
4088 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4089 Flags += " ";
4090 Flags += OriginalArgs[i];
4091 }
4092 CmdArgs.push_back("-dwarf-debug-flags");
4093 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4094 }
4095
4096 // FIXME: Add -static support, once we have it.
4097
4098 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4099 getToolChain().getDriver());
4100
4101 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4102
4103 assert(Output.isFilename() && "Unexpected lipo output.");
4104 CmdArgs.push_back("-o");
4105 CmdArgs.push_back(Output.getFilename());
4106
4107 assert(Input.isFilename() && "Invalid input.");
4108 CmdArgs.push_back(Input.getFilename());
4109
4110 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4111 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4112
4113 // Handle the debug info splitting at object creation time if we're
4114 // creating an object.
4115 // TODO: Currently only works on linux with newer objcopy.
4116 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4117 getToolChain().getTriple().isOSLinux())
4118 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4119 SplitDebugName(Args, Inputs));
4120}
4121
4122void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
4123 const InputInfo &Output,
4124 const InputInfoList &Inputs,
4125 const ArgList &Args,
4126 const char *LinkingOutput) const {
4127 const Driver &D = getToolChain().getDriver();
4128 ArgStringList CmdArgs;
4129
4130 for (ArgList::const_iterator
4131 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
4132 Arg *A = *it;
4133 if (forwardToGCC(A->getOption())) {
4134 // Don't forward any -g arguments to assembly steps.
4135 if (isa<AssembleJobAction>(JA) &&
4136 A->getOption().matches(options::OPT_g_Group))
4137 continue;
4138
4139 // Don't forward any -W arguments to assembly and link steps.
4140 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4141 A->getOption().matches(options::OPT_W_Group))
4142 continue;
4143
4144 // It is unfortunate that we have to claim here, as this means
4145 // we will basically never report anything interesting for
4146 // platforms using a generic gcc, even if we are just using gcc
4147 // to get to the assembler.
4148 A->claim();
4149 A->render(Args, CmdArgs);
4150 }
4151 }
4152
4153 RenderExtraToolArgs(JA, CmdArgs);
4154
4155 // If using a driver driver, force the arch.
4156 llvm::Triple::ArchType Arch = getToolChain().getArch();
4157 if (getToolChain().getTriple().isOSDarwin()) {
4158 CmdArgs.push_back("-arch");
4159
4160 // FIXME: Remove these special cases.
4161 if (Arch == llvm::Triple::ppc)
4162 CmdArgs.push_back("ppc");
4163 else if (Arch == llvm::Triple::ppc64)
4164 CmdArgs.push_back("ppc64");
4165 else if (Arch == llvm::Triple::ppc64le)
4166 CmdArgs.push_back("ppc64le");
4167 else
4168 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4169 }
4170
4171 // Try to force gcc to match the tool chain we want, if we recognize
4172 // the arch.
4173 //
4174 // FIXME: The triple class should directly provide the information we want
4175 // here.
4176 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
4177 CmdArgs.push_back("-m32");
4178 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4179 Arch == llvm::Triple::ppc64le)
4180 CmdArgs.push_back("-m64");
4181
4182 if (Output.isFilename()) {
4183 CmdArgs.push_back("-o");
4184 CmdArgs.push_back(Output.getFilename());
4185 } else {
4186 assert(Output.isNothing() && "Unexpected output");
4187 CmdArgs.push_back("-fsyntax-only");
4188 }
4189
4190 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4191 options::OPT_Xassembler);
4192
4193 // Only pass -x if gcc will understand it; otherwise hope gcc
4194 // understands the suffix correctly. The main use case this would go
4195 // wrong in is for linker inputs if they happened to have an odd
4196 // suffix; really the only way to get this to happen is a command
4197 // like '-x foobar a.c' which will treat a.c like a linker input.
4198 //
4199 // FIXME: For the linker case specifically, can we safely convert
4200 // inputs into '-Wl,' options?
4201 for (InputInfoList::const_iterator
4202 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4203 const InputInfo &II = *it;
4204
4205 // Don't try to pass LLVM or AST inputs to a generic gcc.
4206 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4207 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4208 D.Diag(diag::err_drv_no_linker_llvm_support)
4209 << getToolChain().getTripleString();
4210 else if (II.getType() == types::TY_AST)
4211 D.Diag(diag::err_drv_no_ast_support)
4212 << getToolChain().getTripleString();
4213 else if (II.getType() == types::TY_ModuleFile)
4214 D.Diag(diag::err_drv_no_module_support)
4215 << getToolChain().getTripleString();
4216
4217 if (types::canTypeBeUserSpecified(II.getType())) {
4218 CmdArgs.push_back("-x");
4219 CmdArgs.push_back(types::getTypeName(II.getType()));
4220 }
4221
4222 if (II.isFilename())
4223 CmdArgs.push_back(II.getFilename());
4224 else {
4225 const Arg &A = II.getInputArg();
4226
4227 // Reverse translate some rewritten options.
4228 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4229 CmdArgs.push_back("-lstdc++");
4230 continue;
4231 }
4232
4233 // Don't render as input, we need gcc to do the translations.
4234 A.render(Args, CmdArgs);
4235 }
4236 }
4237
4238 const std::string customGCCName = D.getCCCGenericGCCName();
4239 const char *GCCName;
4240 if (!customGCCName.empty())
4241 GCCName = customGCCName.c_str();
4242 else if (D.CCCIsCXX()) {
4243 GCCName = "g++";
4244 } else
4245 GCCName = "gcc";
4246
4247 const char *Exec =
4248 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4249 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4250}
4251
4252void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4253 ArgStringList &CmdArgs) const {
4254 CmdArgs.push_back("-E");
4255}
4256
4257void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4258 ArgStringList &CmdArgs) const {
4259 // The type is good enough.
4260}
4261
4262void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4263 ArgStringList &CmdArgs) const {
4264 const Driver &D = getToolChain().getDriver();
4265
4266 // If -flto, etc. are present then make sure not to force assembly output.
4267 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4268 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
4269 CmdArgs.push_back("-c");
4270 else {
4271 if (JA.getType() != types::TY_PP_Asm)
4272 D.Diag(diag::err_drv_invalid_gcc_output_type)
4273 << getTypeName(JA.getType());
4274
4275 CmdArgs.push_back("-S");
4276 }
4277}
4278
4279void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4280 ArgStringList &CmdArgs) const {
4281 CmdArgs.push_back("-c");
4282}
4283
4284void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4285 ArgStringList &CmdArgs) const {
4286 // The types are (hopefully) good enough.
4287}
4288
4289// Hexagon tools start.
4290void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4291 ArgStringList &CmdArgs) const {
4292
4293}
4294void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4295 const InputInfo &Output,
4296 const InputInfoList &Inputs,
4297 const ArgList &Args,
4298 const char *LinkingOutput) const {
4299
4300 const Driver &D = getToolChain().getDriver();
4301 ArgStringList CmdArgs;
4302
4303 std::string MarchString = "-march=";
4304 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4305 CmdArgs.push_back(Args.MakeArgString(MarchString));
4306
4307 RenderExtraToolArgs(JA, CmdArgs);
4308
4309 if (Output.isFilename()) {
4310 CmdArgs.push_back("-o");
4311 CmdArgs.push_back(Output.getFilename());
4312 } else {
4313 assert(Output.isNothing() && "Unexpected output");
4314 CmdArgs.push_back("-fsyntax-only");
4315 }
4316
4317 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4318 if (!SmallDataThreshold.empty())
4319 CmdArgs.push_back(
4320 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4321
4322 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4323 options::OPT_Xassembler);
4324
4325 // Only pass -x if gcc will understand it; otherwise hope gcc
4326 // understands the suffix correctly. The main use case this would go
4327 // wrong in is for linker inputs if they happened to have an odd
4328 // suffix; really the only way to get this to happen is a command
4329 // like '-x foobar a.c' which will treat a.c like a linker input.
4330 //
4331 // FIXME: For the linker case specifically, can we safely convert
4332 // inputs into '-Wl,' options?
4333 for (InputInfoList::const_iterator
4334 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4335 const InputInfo &II = *it;
4336
4337 // Don't try to pass LLVM or AST inputs to a generic gcc.
4338 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4339 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4340 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4341 << getToolChain().getTripleString();
4342 else if (II.getType() == types::TY_AST)
4343 D.Diag(clang::diag::err_drv_no_ast_support)
4344 << getToolChain().getTripleString();
4345 else if (II.getType() == types::TY_ModuleFile)
4346 D.Diag(diag::err_drv_no_module_support)
4347 << getToolChain().getTripleString();
4348
4349 if (II.isFilename())
4350 CmdArgs.push_back(II.getFilename());
4351 else
4352 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4353 II.getInputArg().render(Args, CmdArgs);
4354 }
4355
4356 const char *GCCName = "hexagon-as";
4357 const char *Exec =
4358 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4359 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4360
4361}
4362void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4363 ArgStringList &CmdArgs) const {
4364 // The types are (hopefully) good enough.
4365}
4366
4367void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4368 const InputInfo &Output,
4369 const InputInfoList &Inputs,
4370 const ArgList &Args,
4371 const char *LinkingOutput) const {
4372
4373 const toolchains::Hexagon_TC& ToolChain =
4374 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4375 const Driver &D = ToolChain.getDriver();
4376
4377 ArgStringList CmdArgs;
4378
4379 //----------------------------------------------------------------------------
4380 //
4381 //----------------------------------------------------------------------------
4382 bool hasStaticArg = Args.hasArg(options::OPT_static);
4383 bool buildingLib = Args.hasArg(options::OPT_shared);
4384 bool buildPIE = Args.hasArg(options::OPT_pie);
4385 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4386 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4387 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4388 bool useShared = buildingLib && !hasStaticArg;
4389
4390 //----------------------------------------------------------------------------
4391 // Silence warnings for various options
4392 //----------------------------------------------------------------------------
4393
4394 Args.ClaimAllArgs(options::OPT_g_Group);
4395 Args.ClaimAllArgs(options::OPT_emit_llvm);
4396 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4397 // handled somewhere else.
4398 Args.ClaimAllArgs(options::OPT_static_libgcc);
4399
4400 //----------------------------------------------------------------------------
4401 //
4402 //----------------------------------------------------------------------------
4403 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4404 e = ToolChain.ExtraOpts.end();
4405 i != e; ++i)
4406 CmdArgs.push_back(i->c_str());
4407
4408 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4409 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4410
4411 if (buildingLib) {
4412 CmdArgs.push_back("-shared");
4413 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4414 // hexagon-gcc does
4415 }
4416
4417 if (hasStaticArg)
4418 CmdArgs.push_back("-static");
4419
4420 if (buildPIE && !buildingLib)
4421 CmdArgs.push_back("-pie");
4422
4423 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4424 if (!SmallDataThreshold.empty()) {
4425 CmdArgs.push_back(
4426 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4427 }
4428
4429 //----------------------------------------------------------------------------
4430 //
4431 //----------------------------------------------------------------------------
4432 CmdArgs.push_back("-o");
4433 CmdArgs.push_back(Output.getFilename());
4434
4435 const std::string MarchSuffix = "/" + MarchString;
4436 const std::string G0Suffix = "/G0";
4437 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4438 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4439 + "/";
4440 const std::string StartFilesDir = RootDir
4441 + "hexagon/lib"
4442 + (buildingLib
4443 ? MarchG0Suffix : MarchSuffix);
4444
4445 //----------------------------------------------------------------------------
4446 // moslib
4447 //----------------------------------------------------------------------------
4448 std::vector<std::string> oslibs;
4449 bool hasStandalone= false;
4450
4451 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4452 ie = Args.filtered_end(); it != ie; ++it) {
4453 (*it)->claim();
4454 oslibs.push_back((*it)->getValue());
4455 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
4456 }
4457 if (oslibs.empty()) {
4458 oslibs.push_back("standalone");
4459 hasStandalone = true;
4460 }
4461
4462 //----------------------------------------------------------------------------
4463 // Start Files
4464 //----------------------------------------------------------------------------
4465 if (incStdLib && incStartFiles) {
4466
4467 if (!buildingLib) {
4468 if (hasStandalone) {
4469 CmdArgs.push_back(
4470 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4471 }
4472 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4473 }
4474 std::string initObj = useShared ? "/initS.o" : "/init.o";
4475 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4476 }
4477
4478 //----------------------------------------------------------------------------
4479 // Library Search Paths
4480 //----------------------------------------------------------------------------
4481 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4482 for (ToolChain::path_list::const_iterator
4483 i = LibPaths.begin(),
4484 e = LibPaths.end();
4485 i != e;
4486 ++i)
4487 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4488
4489 //----------------------------------------------------------------------------
4490 //
4491 //----------------------------------------------------------------------------
4492 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4493 Args.AddAllArgs(CmdArgs, options::OPT_e);
4494 Args.AddAllArgs(CmdArgs, options::OPT_s);
4495 Args.AddAllArgs(CmdArgs, options::OPT_t);
4496 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4497
4498 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4499
4500 //----------------------------------------------------------------------------
4501 // Libraries
4502 //----------------------------------------------------------------------------
4503 if (incStdLib && incDefLibs) {
4504 if (D.CCCIsCXX()) {
4505 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4506 CmdArgs.push_back("-lm");
4507 }
4508
4509 CmdArgs.push_back("--start-group");
4510
4511 if (!buildingLib) {
4512 for(std::vector<std::string>::iterator i = oslibs.begin(),
4513 e = oslibs.end(); i != e; ++i)
4514 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4515 CmdArgs.push_back("-lc");
4516 }
4517 CmdArgs.push_back("-lgcc");
4518
4519 CmdArgs.push_back("--end-group");
4520 }
4521
4522 //----------------------------------------------------------------------------
4523 // End files
4524 //----------------------------------------------------------------------------
4525 if (incStdLib && incStartFiles) {
4526 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4527 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4528 }
4529
4530 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4531 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
4532}
4533// Hexagon tools end.
4534
4535llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4536 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4537 // archs which Darwin doesn't use.
4538
4539 // The matching this routine does is fairly pointless, since it is neither the
4540 // complete architecture list, nor a reasonable subset. The problem is that
4541 // historically the driver driver accepts this and also ties its -march=
4542 // handling to the architecture name, so we need to be careful before removing
4543 // support for it.
4544
4545 // This code must be kept in sync with Clang's Darwin specific argument
4546 // translation.
4547
4548 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4549 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4550 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4551 .Case("ppc64", llvm::Triple::ppc64)
4552 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4553 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4554 llvm::Triple::x86)
4555 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
4556 // This is derived from the driver driver.
4557 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4558 .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4559 .Cases("armv7s", "xscale", llvm::Triple::arm)
4560 .Case("r600", llvm::Triple::r600)
4561 .Case("nvptx", llvm::Triple::nvptx)
4562 .Case("nvptx64", llvm::Triple::nvptx64)
4563 .Case("amdil", llvm::Triple::amdil)
4564 .Case("spir", llvm::Triple::spir)
4565 .Default(llvm::Triple::UnknownArch);
4566}
4567
4568const char *Clang::getBaseInputName(const ArgList &Args,
4569 const InputInfoList &Inputs) {
4570 return Args.MakeArgString(
4571 llvm::sys::path::filename(Inputs[0].getBaseInput()));
4572}
4573
4574const char *Clang::getBaseInputStem(const ArgList &Args,
4575 const InputInfoList &Inputs) {
4576 const char *Str = getBaseInputName(Args, Inputs);
4577
4578 if (const char *End = strrchr(Str, '.'))
4579 return Args.MakeArgString(std::string(Str, End));
4580
4581 return Str;
4582}
4583
4584const char *Clang::getDependencyFileName(const ArgList &Args,
4585 const InputInfoList &Inputs) {
4586 // FIXME: Think about this more.
4587 std::string Res;
4588
4589 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4590 std::string Str(OutputOpt->getValue());
4591 Res = Str.substr(0, Str.rfind('.'));
4592 } else {
4593 Res = getBaseInputStem(Args, Inputs);
4594 }
4595 return Args.MakeArgString(Res + ".d");
4596}
4597
4598void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4599 const InputInfo &Output,
4600 const InputInfoList &Inputs,
4601 const ArgList &Args,
4602 const char *LinkingOutput) const {
4603 ArgStringList CmdArgs;
4604
4605 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4606 const InputInfo &Input = Inputs[0];
4607
4608 // Determine the original source input.
4609 const Action *SourceAction = &JA;
4610 while (SourceAction->getKind() != Action::InputClass) {
4611 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4612 SourceAction = SourceAction->getInputs()[0];
4613 }
4614
4615 // If -no_integrated_as is used add -Q to the darwin assember driver to make
4616 // sure it runs its system assembler not clang's integrated assembler.
| 1999/// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2000static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2001 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2002 if (A->getOption().matches(options::OPT_O4) ||
2003 A->getOption().matches(options::OPT_Ofast))
2004 return true;
2005
2006 if (A->getOption().matches(options::OPT_O0))
2007 return false;
2008
2009 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2010
2011 // Vectorize -Os.
2012 StringRef S(A->getValue());
2013 if (S == "s")
2014 return true;
2015
2016 // Don't vectorize -Oz.
2017 if (S == "z")
2018 return false;
2019
2020 unsigned OptLevel = 0;
2021 if (S.getAsInteger(10, OptLevel))
2022 return false;
2023
2024 return OptLevel > 1;
2025 }
2026
2027 return false;
2028}
2029
2030void Clang::ConstructJob(Compilation &C, const JobAction &JA,
2031 const InputInfo &Output,
2032 const InputInfoList &Inputs,
2033 const ArgList &Args,
2034 const char *LinkingOutput) const {
2035 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2036 options::OPT_fapple_kext);
2037 const Driver &D = getToolChain().getDriver();
2038 ArgStringList CmdArgs;
2039
2040 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2041
2042 // Invoke ourselves in -cc1 mode.
2043 //
2044 // FIXME: Implement custom jobs for internal actions.
2045 CmdArgs.push_back("-cc1");
2046
2047 // Add the "effective" target triple.
2048 CmdArgs.push_back("-triple");
2049 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2050 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2051
2052 // Select the appropriate action.
2053 RewriteKind rewriteKind = RK_None;
2054
2055 if (isa<AnalyzeJobAction>(JA)) {
2056 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2057 CmdArgs.push_back("-analyze");
2058 } else if (isa<MigrateJobAction>(JA)) {
2059 CmdArgs.push_back("-migrate");
2060 } else if (isa<PreprocessJobAction>(JA)) {
2061 if (Output.getType() == types::TY_Dependencies)
2062 CmdArgs.push_back("-Eonly");
2063 else {
2064 CmdArgs.push_back("-E");
2065 if (Args.hasArg(options::OPT_rewrite_objc) &&
2066 !Args.hasArg(options::OPT_g_Group))
2067 CmdArgs.push_back("-P");
2068 }
2069 } else if (isa<AssembleJobAction>(JA)) {
2070 CmdArgs.push_back("-emit-obj");
2071
2072 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2073
2074 // Also ignore explicit -force_cpusubtype_ALL option.
2075 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2076 } else if (isa<PrecompileJobAction>(JA)) {
2077 // Use PCH if the user requested it.
2078 bool UsePCH = D.CCCUsePCH;
2079
2080 if (JA.getType() == types::TY_Nothing)
2081 CmdArgs.push_back("-fsyntax-only");
2082 else if (UsePCH)
2083 CmdArgs.push_back("-emit-pch");
2084 else
2085 CmdArgs.push_back("-emit-pth");
2086 } else {
2087 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
2088
2089 if (JA.getType() == types::TY_Nothing) {
2090 CmdArgs.push_back("-fsyntax-only");
2091 } else if (JA.getType() == types::TY_LLVM_IR ||
2092 JA.getType() == types::TY_LTO_IR) {
2093 CmdArgs.push_back("-emit-llvm");
2094 } else if (JA.getType() == types::TY_LLVM_BC ||
2095 JA.getType() == types::TY_LTO_BC) {
2096 CmdArgs.push_back("-emit-llvm-bc");
2097 } else if (JA.getType() == types::TY_PP_Asm) {
2098 CmdArgs.push_back("-S");
2099 } else if (JA.getType() == types::TY_AST) {
2100 CmdArgs.push_back("-emit-pch");
2101 } else if (JA.getType() == types::TY_ModuleFile) {
2102 CmdArgs.push_back("-module-file-info");
2103 } else if (JA.getType() == types::TY_RewrittenObjC) {
2104 CmdArgs.push_back("-rewrite-objc");
2105 rewriteKind = RK_NonFragile;
2106 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2107 CmdArgs.push_back("-rewrite-objc");
2108 rewriteKind = RK_Fragile;
2109 } else {
2110 assert(JA.getType() == types::TY_PP_Asm &&
2111 "Unexpected output type!");
2112 }
2113 }
2114
2115 // The make clang go fast button.
2116 CmdArgs.push_back("-disable-free");
2117
2118 // Disable the verification pass in -asserts builds.
2119#ifdef NDEBUG
2120 CmdArgs.push_back("-disable-llvm-verifier");
2121#endif
2122
2123 // Set the main file name, so that debug info works even with
2124 // -save-temps.
2125 CmdArgs.push_back("-main-file-name");
2126 CmdArgs.push_back(getBaseInputName(Args, Inputs));
2127
2128 // Some flags which affect the language (via preprocessor
2129 // defines).
2130 if (Args.hasArg(options::OPT_static))
2131 CmdArgs.push_back("-static-define");
2132
2133 if (isa<AnalyzeJobAction>(JA)) {
2134 // Enable region store model by default.
2135 CmdArgs.push_back("-analyzer-store=region");
2136
2137 // Treat blocks as analysis entry points.
2138 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2139
2140 CmdArgs.push_back("-analyzer-eagerly-assume");
2141
2142 // Add default argument set.
2143 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2144 CmdArgs.push_back("-analyzer-checker=core");
2145
2146 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2147 CmdArgs.push_back("-analyzer-checker=unix");
2148
2149 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2150 CmdArgs.push_back("-analyzer-checker=osx");
2151
2152 CmdArgs.push_back("-analyzer-checker=deadcode");
2153
2154 if (types::isCXX(Inputs[0].getType()))
2155 CmdArgs.push_back("-analyzer-checker=cplusplus");
2156
2157 // Enable the following experimental checkers for testing.
2158 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2159 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2160 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2161 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2162 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2163 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2164 }
2165
2166 // Set the output format. The default is plist, for (lame) historical
2167 // reasons.
2168 CmdArgs.push_back("-analyzer-output");
2169 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2170 CmdArgs.push_back(A->getValue());
2171 else
2172 CmdArgs.push_back("plist");
2173
2174 // Disable the presentation of standard compiler warnings when
2175 // using --analyze. We only want to show static analyzer diagnostics
2176 // or frontend errors.
2177 CmdArgs.push_back("-w");
2178
2179 // Add -Xanalyzer arguments when running as analyzer.
2180 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2181 }
2182
2183 CheckCodeGenerationOptions(D, Args);
2184
2185 bool PIE = getToolChain().isPIEDefault();
2186 bool PIC = PIE || getToolChain().isPICDefault();
2187 bool IsPICLevelTwo = PIC;
2188
2189 // For the PIC and PIE flag options, this logic is different from the
2190 // legacy logic in very old versions of GCC, as that logic was just
2191 // a bug no one had ever fixed. This logic is both more rational and
2192 // consistent with GCC's new logic now that the bugs are fixed. The last
2193 // argument relating to either PIC or PIE wins, and no other argument is
2194 // used. If the last argument is any flavor of the '-fno-...' arguments,
2195 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2196 // at the same level.
2197 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2198 options::OPT_fpic, options::OPT_fno_pic,
2199 options::OPT_fPIE, options::OPT_fno_PIE,
2200 options::OPT_fpie, options::OPT_fno_pie);
2201 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2202 // is forced, then neither PIC nor PIE flags will have no effect.
2203 if (!getToolChain().isPICDefaultForced()) {
2204 if (LastPICArg) {
2205 Option O = LastPICArg->getOption();
2206 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2207 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2208 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2209 PIC = PIE || O.matches(options::OPT_fPIC) ||
2210 O.matches(options::OPT_fpic);
2211 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2212 O.matches(options::OPT_fPIC);
2213 } else {
2214 PIE = PIC = false;
2215 }
2216 }
2217 }
2218
2219 // Introduce a Darwin-specific hack. If the default is PIC but the flags
2220 // specified while enabling PIC enabled level 1 PIC, just force it back to
2221 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2222 // informal testing).
2223 if (PIC && getToolChain().getTriple().isOSDarwin())
2224 IsPICLevelTwo |= getToolChain().isPICDefault();
2225
2226 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2227 // PIC or PIE options above, if these show up, PIC is disabled.
2228 llvm::Triple Triple(TripleStr);
2229 if (KernelOrKext &&
2230 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
2231 PIC = PIE = false;
2232 if (Args.hasArg(options::OPT_static))
2233 PIC = PIE = false;
2234
2235 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2236 // This is a very special mode. It trumps the other modes, almost no one
2237 // uses it, and it isn't even valid on any OS but Darwin.
2238 if (!getToolChain().getTriple().isOSDarwin())
2239 D.Diag(diag::err_drv_unsupported_opt_for_target)
2240 << A->getSpelling() << getToolChain().getTriple().str();
2241
2242 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2243
2244 CmdArgs.push_back("-mrelocation-model");
2245 CmdArgs.push_back("dynamic-no-pic");
2246
2247 // Only a forced PIC mode can cause the actual compile to have PIC defines
2248 // etc., no flags are sufficient. This behavior was selected to closely
2249 // match that of llvm-gcc and Apple GCC before that.
2250 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2251 CmdArgs.push_back("-pic-level");
2252 CmdArgs.push_back("2");
2253 }
2254 } else {
2255 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2256 // handled in Clang's IRGen by the -pie-level flag.
2257 CmdArgs.push_back("-mrelocation-model");
2258 CmdArgs.push_back(PIC ? "pic" : "static");
2259
2260 if (PIC) {
2261 CmdArgs.push_back("-pic-level");
2262 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2263 if (PIE) {
2264 CmdArgs.push_back("-pie-level");
2265 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2266 }
2267 }
2268 }
2269
2270 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2271 options::OPT_fno_merge_all_constants))
2272 CmdArgs.push_back("-fno-merge-all-constants");
2273
2274 // LLVM Code Generator Options.
2275
2276 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2277 CmdArgs.push_back("-mregparm");
2278 CmdArgs.push_back(A->getValue());
2279 }
2280
2281 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2282 options::OPT_freg_struct_return)) {
2283 if (getToolChain().getArch() != llvm::Triple::x86) {
2284 D.Diag(diag::err_drv_unsupported_opt_for_target)
2285 << A->getSpelling() << getToolChain().getTriple().str();
2286 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2287 CmdArgs.push_back("-fpcc-struct-return");
2288 } else {
2289 assert(A->getOption().matches(options::OPT_freg_struct_return));
2290 CmdArgs.push_back("-freg-struct-return");
2291 }
2292 }
2293
2294 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2295 CmdArgs.push_back("-mrtd");
2296
2297 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2298 CmdArgs.push_back("-mdisable-fp-elim");
2299 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2300 options::OPT_fno_zero_initialized_in_bss))
2301 CmdArgs.push_back("-mno-zero-initialized-in-bss");
2302
2303 bool OFastEnabled = isOptimizationLevelFast(Args);
2304 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2305 // enabled. This alias option is being used to simplify the hasFlag logic.
2306 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2307 options::OPT_fstrict_aliasing;
2308 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2309 options::OPT_fno_strict_aliasing, true))
2310 CmdArgs.push_back("-relaxed-aliasing");
2311 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2312 options::OPT_fno_struct_path_tbaa))
2313 CmdArgs.push_back("-no-struct-path-tbaa");
2314 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2315 false))
2316 CmdArgs.push_back("-fstrict-enums");
2317 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2318 options::OPT_fno_optimize_sibling_calls))
2319 CmdArgs.push_back("-mdisable-tail-calls");
2320
2321 // Handle segmented stacks.
2322 if (Args.hasArg(options::OPT_fsplit_stack))
2323 CmdArgs.push_back("-split-stacks");
2324
2325 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2326 // This alias option is being used to simplify the getLastArg logic.
2327 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2328 options::OPT_ffast_math;
2329
2330 // Handle various floating point optimization flags, mapping them to the
2331 // appropriate LLVM code generation flags. The pattern for all of these is to
2332 // default off the codegen optimizations, and if any flag enables them and no
2333 // flag disables them after the flag enabling them, enable the codegen
2334 // optimization. This is complicated by several "umbrella" flags.
2335 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2336 options::OPT_fno_fast_math,
2337 options::OPT_ffinite_math_only,
2338 options::OPT_fno_finite_math_only,
2339 options::OPT_fhonor_infinities,
2340 options::OPT_fno_honor_infinities))
2341 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2342 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2343 A->getOption().getID() != options::OPT_fhonor_infinities)
2344 CmdArgs.push_back("-menable-no-infs");
2345 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2346 options::OPT_fno_fast_math,
2347 options::OPT_ffinite_math_only,
2348 options::OPT_fno_finite_math_only,
2349 options::OPT_fhonor_nans,
2350 options::OPT_fno_honor_nans))
2351 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2352 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2353 A->getOption().getID() != options::OPT_fhonor_nans)
2354 CmdArgs.push_back("-menable-no-nans");
2355
2356 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2357 bool MathErrno = getToolChain().IsMathErrnoDefault();
2358 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2359 options::OPT_fno_fast_math,
2360 options::OPT_fmath_errno,
2361 options::OPT_fno_math_errno)) {
2362 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2363 // However, turning *off* -ffast_math merely restores the toolchain default
2364 // (which may be false).
2365 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2366 A->getOption().getID() == options::OPT_ffast_math ||
2367 A->getOption().getID() == options::OPT_Ofast)
2368 MathErrno = false;
2369 else if (A->getOption().getID() == options::OPT_fmath_errno)
2370 MathErrno = true;
2371 }
2372 if (MathErrno)
2373 CmdArgs.push_back("-fmath-errno");
2374
2375 // There are several flags which require disabling very specific
2376 // optimizations. Any of these being disabled forces us to turn off the
2377 // entire set of LLVM optimizations, so collect them through all the flag
2378 // madness.
2379 bool AssociativeMath = false;
2380 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2381 options::OPT_fno_fast_math,
2382 options::OPT_funsafe_math_optimizations,
2383 options::OPT_fno_unsafe_math_optimizations,
2384 options::OPT_fassociative_math,
2385 options::OPT_fno_associative_math))
2386 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2387 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2388 A->getOption().getID() != options::OPT_fno_associative_math)
2389 AssociativeMath = true;
2390 bool ReciprocalMath = false;
2391 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2392 options::OPT_fno_fast_math,
2393 options::OPT_funsafe_math_optimizations,
2394 options::OPT_fno_unsafe_math_optimizations,
2395 options::OPT_freciprocal_math,
2396 options::OPT_fno_reciprocal_math))
2397 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2398 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2399 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2400 ReciprocalMath = true;
2401 bool SignedZeros = true;
2402 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2403 options::OPT_fno_fast_math,
2404 options::OPT_funsafe_math_optimizations,
2405 options::OPT_fno_unsafe_math_optimizations,
2406 options::OPT_fsigned_zeros,
2407 options::OPT_fno_signed_zeros))
2408 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2409 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2410 A->getOption().getID() != options::OPT_fsigned_zeros)
2411 SignedZeros = false;
2412 bool TrappingMath = true;
2413 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2414 options::OPT_fno_fast_math,
2415 options::OPT_funsafe_math_optimizations,
2416 options::OPT_fno_unsafe_math_optimizations,
2417 options::OPT_ftrapping_math,
2418 options::OPT_fno_trapping_math))
2419 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2420 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2421 A->getOption().getID() != options::OPT_ftrapping_math)
2422 TrappingMath = false;
2423 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2424 !TrappingMath)
2425 CmdArgs.push_back("-menable-unsafe-fp-math");
2426
2427
2428 // Validate and pass through -fp-contract option.
2429 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2430 options::OPT_fno_fast_math,
2431 options::OPT_ffp_contract)) {
2432 if (A->getOption().getID() == options::OPT_ffp_contract) {
2433 StringRef Val = A->getValue();
2434 if (Val == "fast" || Val == "on" || Val == "off") {
2435 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2436 } else {
2437 D.Diag(diag::err_drv_unsupported_option_argument)
2438 << A->getOption().getName() << Val;
2439 }
2440 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2441 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
2442 // If fast-math is set then set the fp-contract mode to fast.
2443 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2444 }
2445 }
2446
2447 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2448 // and if we find them, tell the frontend to provide the appropriate
2449 // preprocessor macros. This is distinct from enabling any optimizations as
2450 // these options induce language changes which must survive serialization
2451 // and deserialization, etc.
2452 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2453 options::OPT_fno_fast_math))
2454 if (!A->getOption().matches(options::OPT_fno_fast_math))
2455 CmdArgs.push_back("-ffast-math");
2456 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2457 if (A->getOption().matches(options::OPT_ffinite_math_only))
2458 CmdArgs.push_back("-ffinite-math-only");
2459
2460 // Decide whether to use verbose asm. Verbose assembly is the default on
2461 // toolchains which have the integrated assembler on by default.
2462 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2463 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2464 IsVerboseAsmDefault) ||
2465 Args.hasArg(options::OPT_dA))
2466 CmdArgs.push_back("-masm-verbose");
2467
2468 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2469 CmdArgs.push_back("-mdebug-pass");
2470 CmdArgs.push_back("Structure");
2471 }
2472 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2473 CmdArgs.push_back("-mdebug-pass");
2474 CmdArgs.push_back("Arguments");
2475 }
2476
2477 // Enable -mconstructor-aliases except on darwin, where we have to
2478 // work around a linker bug; see <rdar://problem/7651567>.
2479 if (!getToolChain().getTriple().isOSDarwin())
2480 CmdArgs.push_back("-mconstructor-aliases");
2481
2482 // Darwin's kernel doesn't support guard variables; just die if we
2483 // try to use them.
2484 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2485 CmdArgs.push_back("-fforbid-guard-variables");
2486
2487 if (Args.hasArg(options::OPT_mms_bitfields)) {
2488 CmdArgs.push_back("-mms-bitfields");
2489 }
2490
2491 // This is a coarse approximation of what llvm-gcc actually does, both
2492 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2493 // complicated ways.
2494 bool AsynchronousUnwindTables =
2495 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2496 options::OPT_fno_asynchronous_unwind_tables,
2497 getToolChain().IsUnwindTablesDefault() &&
2498 !KernelOrKext);
2499 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2500 AsynchronousUnwindTables))
2501 CmdArgs.push_back("-munwind-tables");
2502
2503 getToolChain().addClangTargetOptions(Args, CmdArgs);
2504
2505 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2506 CmdArgs.push_back("-mlimit-float-precision");
2507 CmdArgs.push_back(A->getValue());
2508 }
2509
2510 // FIXME: Handle -mtune=.
2511 (void) Args.hasArg(options::OPT_mtune_EQ);
2512
2513 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2514 CmdArgs.push_back("-mcode-model");
2515 CmdArgs.push_back(A->getValue());
2516 }
2517
2518 // Add the target cpu
2519 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2520 llvm::Triple ETriple(ETripleStr);
2521 std::string CPU = getCPUName(Args, ETriple);
2522 if (!CPU.empty()) {
2523 CmdArgs.push_back("-target-cpu");
2524 CmdArgs.push_back(Args.MakeArgString(CPU));
2525 }
2526
2527 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2528 CmdArgs.push_back("-mfpmath");
2529 CmdArgs.push_back(A->getValue());
2530 }
2531
2532 // Add the target features
2533 getTargetFeatures(D, ETriple, Args, CmdArgs);
2534
2535 // Add target specific flags.
2536 switch(getToolChain().getArch()) {
2537 default:
2538 break;
2539
2540 case llvm::Triple::arm:
2541 case llvm::Triple::thumb:
2542 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2543 break;
2544
2545 case llvm::Triple::mips:
2546 case llvm::Triple::mipsel:
2547 case llvm::Triple::mips64:
2548 case llvm::Triple::mips64el:
2549 AddMIPSTargetArgs(Args, CmdArgs);
2550 break;
2551
2552 case llvm::Triple::sparc:
2553 AddSparcTargetArgs(Args, CmdArgs);
2554 break;
2555
2556 case llvm::Triple::x86:
2557 case llvm::Triple::x86_64:
2558 AddX86TargetArgs(Args, CmdArgs);
2559 break;
2560
2561 case llvm::Triple::hexagon:
2562 AddHexagonTargetArgs(Args, CmdArgs);
2563 break;
2564 }
2565
2566 // Add clang-cl arguments.
2567 if (getToolChain().getDriver().IsCLMode())
2568 AddClangCLArgs(Args, CmdArgs);
2569
2570 // Pass the linker version in use.
2571 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2572 CmdArgs.push_back("-target-linker-version");
2573 CmdArgs.push_back(A->getValue());
2574 }
2575
2576 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
2577 CmdArgs.push_back("-momit-leaf-frame-pointer");
2578
2579 // Explicitly error on some things we know we don't support and can't just
2580 // ignore.
2581 types::ID InputType = Inputs[0].getType();
2582 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2583 Arg *Unsupported;
2584 if (types::isCXX(InputType) &&
2585 getToolChain().getTriple().isOSDarwin() &&
2586 getToolChain().getArch() == llvm::Triple::x86) {
2587 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2588 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2589 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2590 << Unsupported->getOption().getName();
2591 }
2592 }
2593
2594 Args.AddAllArgs(CmdArgs, options::OPT_v);
2595 Args.AddLastArg(CmdArgs, options::OPT_H);
2596 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
2597 CmdArgs.push_back("-header-include-file");
2598 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2599 D.CCPrintHeadersFilename : "-");
2600 }
2601 Args.AddLastArg(CmdArgs, options::OPT_P);
2602 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2603
2604 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
2605 CmdArgs.push_back("-diagnostic-log-file");
2606 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2607 D.CCLogDiagnosticsFilename : "-");
2608 }
2609
2610 // Use the last option from "-g" group. "-gline-tables-only"
2611 // is preserved, all other debug options are substituted with "-g".
2612 Args.ClaimAllArgs(options::OPT_g_Group);
2613 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2614 if (A->getOption().matches(options::OPT_gline_tables_only))
2615 CmdArgs.push_back("-gline-tables-only");
2616 else if (A->getOption().matches(options::OPT_gdwarf_2))
2617 CmdArgs.push_back("-gdwarf-2");
2618 else if (A->getOption().matches(options::OPT_gdwarf_3))
2619 CmdArgs.push_back("-gdwarf-3");
2620 else if (A->getOption().matches(options::OPT_gdwarf_4))
2621 CmdArgs.push_back("-gdwarf-4");
2622 else if (!A->getOption().matches(options::OPT_g0) &&
2623 !A->getOption().matches(options::OPT_ggdb0)) {
2624 // Default is dwarf-2 for darwin and FreeBSD.
2625 const llvm::Triple &Triple = getToolChain().getTriple();
2626 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::FreeBSD)
2627 CmdArgs.push_back("-gdwarf-2");
2628 else
2629 CmdArgs.push_back("-g");
2630 }
2631 }
2632
2633 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2634 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2635 if (Args.hasArg(options::OPT_gcolumn_info))
2636 CmdArgs.push_back("-dwarf-column-info");
2637
2638 // FIXME: Move backend command line options to the module.
2639 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2640 // splitting and extraction.
2641 // FIXME: Currently only works on Linux.
2642 if (getToolChain().getTriple().isOSLinux() &&
2643 Args.hasArg(options::OPT_gsplit_dwarf)) {
2644 CmdArgs.push_back("-g");
2645 CmdArgs.push_back("-backend-option");
2646 CmdArgs.push_back("-split-dwarf=Enable");
2647 }
2648
2649 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2650 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2651 CmdArgs.push_back("-backend-option");
2652 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2653 }
2654
2655 Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2656
2657 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2658 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2659
2660 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2661
2662 if (Args.hasArg(options::OPT_ftest_coverage) ||
2663 Args.hasArg(options::OPT_coverage))
2664 CmdArgs.push_back("-femit-coverage-notes");
2665 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2666 Args.hasArg(options::OPT_coverage))
2667 CmdArgs.push_back("-femit-coverage-data");
2668
2669 if (C.getArgs().hasArg(options::OPT_c) ||
2670 C.getArgs().hasArg(options::OPT_S)) {
2671 if (Output.isFilename()) {
2672 CmdArgs.push_back("-coverage-file");
2673 SmallString<128> CoverageFilename(Output.getFilename());
2674 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2675 SmallString<128> Pwd;
2676 if (!llvm::sys::fs::current_path(Pwd)) {
2677 llvm::sys::path::append(Pwd, CoverageFilename.str());
2678 CoverageFilename.swap(Pwd);
2679 }
2680 }
2681 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2682 }
2683 }
2684
2685 // Pass options for controlling the default header search paths.
2686 if (Args.hasArg(options::OPT_nostdinc)) {
2687 CmdArgs.push_back("-nostdsysteminc");
2688 CmdArgs.push_back("-nobuiltininc");
2689 } else {
2690 if (Args.hasArg(options::OPT_nostdlibinc))
2691 CmdArgs.push_back("-nostdsysteminc");
2692 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2693 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2694 }
2695
2696 // Pass the path to compiler resource files.
2697 CmdArgs.push_back("-resource-dir");
2698 CmdArgs.push_back(D.ResourceDir.c_str());
2699
2700 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2701
2702 bool ARCMTEnabled = false;
2703 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2704 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2705 options::OPT_ccc_arcmt_modify,
2706 options::OPT_ccc_arcmt_migrate)) {
2707 ARCMTEnabled = true;
2708 switch (A->getOption().getID()) {
2709 default:
2710 llvm_unreachable("missed a case");
2711 case options::OPT_ccc_arcmt_check:
2712 CmdArgs.push_back("-arcmt-check");
2713 break;
2714 case options::OPT_ccc_arcmt_modify:
2715 CmdArgs.push_back("-arcmt-modify");
2716 break;
2717 case options::OPT_ccc_arcmt_migrate:
2718 CmdArgs.push_back("-arcmt-migrate");
2719 CmdArgs.push_back("-mt-migrate-directory");
2720 CmdArgs.push_back(A->getValue());
2721
2722 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2723 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2724 break;
2725 }
2726 }
2727 } else {
2728 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2729 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2730 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2731 }
2732
2733 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2734 if (ARCMTEnabled) {
2735 D.Diag(diag::err_drv_argument_not_allowed_with)
2736 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2737 }
2738 CmdArgs.push_back("-mt-migrate-directory");
2739 CmdArgs.push_back(A->getValue());
2740
2741 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2742 options::OPT_objcmt_migrate_subscripting,
2743 options::OPT_objcmt_migrate_property)) {
2744 // None specified, means enable them all.
2745 CmdArgs.push_back("-objcmt-migrate-literals");
2746 CmdArgs.push_back("-objcmt-migrate-subscripting");
2747 CmdArgs.push_back("-objcmt-migrate-property");
2748 } else {
2749 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2750 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2751 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2752 }
2753 } else {
2754 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2755 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2756 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2757 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2758 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2759 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2760 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2762 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2763 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path);
2768 }
2769
2770 // Add preprocessing options like -I, -D, etc. if we are using the
2771 // preprocessor.
2772 //
2773 // FIXME: Support -fpreprocessed
2774 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2775 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2776
2777 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2778 // that "The compiler can only warn and ignore the option if not recognized".
2779 // When building with ccache, it will pass -D options to clang even on
2780 // preprocessed inputs and configure concludes that -fPIC is not supported.
2781 Args.ClaimAllArgs(options::OPT_D);
2782
2783 // Manually translate -O4 to -O3; let clang reject others.
2784 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2785 if (A->getOption().matches(options::OPT_O4)) {
2786 CmdArgs.push_back("-O3");
2787 D.Diag(diag::warn_O4_is_O3);
2788 } else {
2789 A->render(Args, CmdArgs);
2790 }
2791 }
2792
2793 // Don't warn about unused -flto. This can happen when we're preprocessing or
2794 // precompiling.
2795 Args.ClaimAllArgs(options::OPT_flto);
2796
2797 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2798 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2799 CmdArgs.push_back("-pedantic");
2800 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2801 Args.AddLastArg(CmdArgs, options::OPT_w);
2802
2803 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2804 // (-ansi is equivalent to -std=c89 or -std=c++98).
2805 //
2806 // If a std is supplied, only add -trigraphs if it follows the
2807 // option.
2808 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2809 if (Std->getOption().matches(options::OPT_ansi))
2810 if (types::isCXX(InputType))
2811 CmdArgs.push_back("-std=c++98");
2812 else
2813 CmdArgs.push_back("-std=c89");
2814 else
2815 Std->render(Args, CmdArgs);
2816
2817 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2818 options::OPT_trigraphs))
2819 if (A != Std)
2820 A->render(Args, CmdArgs);
2821 } else {
2822 // Honor -std-default.
2823 //
2824 // FIXME: Clang doesn't correctly handle -std= when the input language
2825 // doesn't match. For the time being just ignore this for C++ inputs;
2826 // eventually we want to do all the standard defaulting here instead of
2827 // splitting it between the driver and clang -cc1.
2828 if (!types::isCXX(InputType))
2829 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2830 "-std=", /*Joined=*/true);
2831 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2832 CmdArgs.push_back("-std=c++11");
2833
2834 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2835 }
2836
2837 // GCC's behavior for -Wwrite-strings is a bit strange:
2838 // * In C, this "warning flag" changes the types of string literals from
2839 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2840 // for the discarded qualifier.
2841 // * In C++, this is just a normal warning flag.
2842 //
2843 // Implementing this warning correctly in C is hard, so we follow GCC's
2844 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2845 // a non-const char* in C, rather than using this crude hack.
2846 if (!types::isCXX(InputType)) {
2847 DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel(
2848 diag::warn_deprecated_string_literal_conversion_c, SourceLocation());
2849 if (DiagLevel > DiagnosticsEngine::Ignored)
2850 CmdArgs.push_back("-fconst-strings");
2851 }
2852
2853 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2854 // during C++ compilation, which it is by default. GCC keeps this define even
2855 // in the presence of '-w', match this behavior bug-for-bug.
2856 if (types::isCXX(InputType) &&
2857 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2858 true)) {
2859 CmdArgs.push_back("-fdeprecated-macro");
2860 }
2861
2862 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2863 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2864 if (Asm->getOption().matches(options::OPT_fasm))
2865 CmdArgs.push_back("-fgnu-keywords");
2866 else
2867 CmdArgs.push_back("-fno-gnu-keywords");
2868 }
2869
2870 if (ShouldDisableCFI(Args, getToolChain()))
2871 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2872
2873 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2874 CmdArgs.push_back("-fno-dwarf-directory-asm");
2875
2876 if (ShouldDisableAutolink(Args, getToolChain()))
2877 CmdArgs.push_back("-fno-autolink");
2878
2879 // Add in -fdebug-compilation-dir if necessary.
2880 addDebugCompDirArg(Args, CmdArgs);
2881
2882 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2883 options::OPT_ftemplate_depth_EQ)) {
2884 CmdArgs.push_back("-ftemplate-depth");
2885 CmdArgs.push_back(A->getValue());
2886 }
2887
2888 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
2889 CmdArgs.push_back("-foperator-arrow-depth");
2890 CmdArgs.push_back(A->getValue());
2891 }
2892
2893 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2894 CmdArgs.push_back("-fconstexpr-depth");
2895 CmdArgs.push_back(A->getValue());
2896 }
2897
2898 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2899 CmdArgs.push_back("-fconstexpr-steps");
2900 CmdArgs.push_back(A->getValue());
2901 }
2902
2903 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2904 CmdArgs.push_back("-fbracket-depth");
2905 CmdArgs.push_back(A->getValue());
2906 }
2907
2908 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2909 options::OPT_Wlarge_by_value_copy_def)) {
2910 if (A->getNumValues()) {
2911 StringRef bytes = A->getValue();
2912 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2913 } else
2914 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2915 }
2916
2917
2918 if (Args.hasArg(options::OPT_relocatable_pch))
2919 CmdArgs.push_back("-relocatable-pch");
2920
2921 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2922 CmdArgs.push_back("-fconstant-string-class");
2923 CmdArgs.push_back(A->getValue());
2924 }
2925
2926 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2927 CmdArgs.push_back("-ftabstop");
2928 CmdArgs.push_back(A->getValue());
2929 }
2930
2931 CmdArgs.push_back("-ferror-limit");
2932 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2933 CmdArgs.push_back(A->getValue());
2934 else
2935 CmdArgs.push_back("19");
2936
2937 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2938 CmdArgs.push_back("-fmacro-backtrace-limit");
2939 CmdArgs.push_back(A->getValue());
2940 }
2941
2942 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2943 CmdArgs.push_back("-ftemplate-backtrace-limit");
2944 CmdArgs.push_back(A->getValue());
2945 }
2946
2947 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2948 CmdArgs.push_back("-fconstexpr-backtrace-limit");
2949 CmdArgs.push_back(A->getValue());
2950 }
2951
2952 // Pass -fmessage-length=.
2953 CmdArgs.push_back("-fmessage-length");
2954 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2955 CmdArgs.push_back(A->getValue());
2956 } else {
2957 // If -fmessage-length=N was not specified, determine whether this is a
2958 // terminal and, if so, implicitly define -fmessage-length appropriately.
2959 unsigned N = llvm::sys::Process::StandardErrColumns();
2960 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2961 }
2962
2963 // -fvisibility= and -fvisibility-ms-compat are of a piece.
2964 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2965 options::OPT_fvisibility_ms_compat)) {
2966 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2967 CmdArgs.push_back("-fvisibility");
2968 CmdArgs.push_back(A->getValue());
2969 } else {
2970 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2971 CmdArgs.push_back("-fvisibility");
2972 CmdArgs.push_back("hidden");
2973 CmdArgs.push_back("-ftype-visibility");
2974 CmdArgs.push_back("default");
2975 }
2976 }
2977
2978 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2979
2980 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2981
2982 // -fhosted is default.
2983 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2984 KernelOrKext)
2985 CmdArgs.push_back("-ffreestanding");
2986
2987 // Forward -f (flag) options which we can pass directly.
2988 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2989 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2990 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2991 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2992 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
2993 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
2994 // AltiVec language extensions aren't relevant for assembling.
2995 if (!isa<PreprocessJobAction>(JA) ||
2996 Output.getType() != types::TY_PP_Asm)
2997 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
2998 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2999 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3000
3001 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3002 Sanitize.addArgs(Args, CmdArgs);
3003
3004 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3005 options::OPT_fno_sanitize_recover,
3006 true))
3007 CmdArgs.push_back("-fno-sanitize-recover");
3008
3009 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3010 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3011 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3012 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3013
3014 // Report an error for -faltivec on anything other than PowerPC.
3015 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3016 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
3017 getToolChain().getArch() == llvm::Triple::ppc64 ||
3018 getToolChain().getArch() == llvm::Triple::ppc64le))
3019 D.Diag(diag::err_drv_argument_only_allowed_with)
3020 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3021
3022 if (getToolChain().SupportsProfiling())
3023 Args.AddLastArg(CmdArgs, options::OPT_pg);
3024
3025 // -flax-vector-conversions is default.
3026 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3027 options::OPT_fno_lax_vector_conversions))
3028 CmdArgs.push_back("-fno-lax-vector-conversions");
3029
3030 if (Args.getLastArg(options::OPT_fapple_kext))
3031 CmdArgs.push_back("-fapple-kext");
3032
3033 if (Args.hasFlag(options::OPT_frewrite_includes,
3034 options::OPT_fno_rewrite_includes, false))
3035 CmdArgs.push_back("-frewrite-includes");
3036
3037 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3038 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3039 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3040 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3041 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3042
3043 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3044 CmdArgs.push_back("-ftrapv-handler");
3045 CmdArgs.push_back(A->getValue());
3046 }
3047
3048 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3049
3050 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3051 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3052 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3053 options::OPT_fno_wrapv)) {
3054 if (A->getOption().matches(options::OPT_fwrapv))
3055 CmdArgs.push_back("-fwrapv");
3056 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3057 options::OPT_fno_strict_overflow)) {
3058 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3059 CmdArgs.push_back("-fwrapv");
3060 }
3061
3062 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3063 options::OPT_fno_reroll_loops))
3064 if (A->getOption().matches(options::OPT_freroll_loops))
3065 CmdArgs.push_back("-freroll-loops");
3066
3067 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3068 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3069 options::OPT_fno_unroll_loops);
3070
3071 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3072
3073
3074 // -stack-protector=0 is default.
3075 unsigned StackProtectorLevel = 0;
3076 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3077 options::OPT_fstack_protector_all,
3078 options::OPT_fstack_protector)) {
3079 if (A->getOption().matches(options::OPT_fstack_protector))
3080 StackProtectorLevel = 1;
3081 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3082 StackProtectorLevel = 2;
3083 } else {
3084 StackProtectorLevel =
3085 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3086 }
3087 if (StackProtectorLevel) {
3088 CmdArgs.push_back("-stack-protector");
3089 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3090 }
3091
3092 // --param ssp-buffer-size=
3093 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3094 ie = Args.filtered_end(); it != ie; ++it) {
3095 StringRef Str((*it)->getValue());
3096 if (Str.startswith("ssp-buffer-size=")) {
3097 if (StackProtectorLevel) {
3098 CmdArgs.push_back("-stack-protector-buffer-size");
3099 // FIXME: Verify the argument is a valid integer.
3100 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3101 }
3102 (*it)->claim();
3103 }
3104 }
3105
3106 // Translate -mstackrealign
3107 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3108 false)) {
3109 CmdArgs.push_back("-backend-option");
3110 CmdArgs.push_back("-force-align-stack");
3111 }
3112 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3113 false)) {
3114 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3115 }
3116
3117 if (Args.hasArg(options::OPT_mstack_alignment)) {
3118 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3119 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3120 }
3121 // -mkernel implies -mstrict-align; don't add the redundant option.
3122 if (!KernelOrKext) {
3123 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3124 options::OPT_munaligned_access)) {
3125 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3126 CmdArgs.push_back("-backend-option");
3127 CmdArgs.push_back("-arm-strict-align");
3128 } else {
3129 CmdArgs.push_back("-backend-option");
3130 CmdArgs.push_back("-arm-no-strict-align");
3131 }
3132 }
3133 }
3134
3135 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3136 options::OPT_mno_restrict_it)) {
3137 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3138 CmdArgs.push_back("-backend-option");
3139 CmdArgs.push_back("-arm-restrict-it");
3140 } else {
3141 CmdArgs.push_back("-backend-option");
3142 CmdArgs.push_back("-arm-no-restrict-it");
3143 }
3144 }
3145
3146 // Forward -f options with positive and negative forms; we translate
3147 // these by hand.
3148 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3149 StringRef fname = A->getValue();
3150 if (!llvm::sys::fs::exists(fname))
3151 D.Diag(diag::err_drv_no_such_file) << fname;
3152 else
3153 A->render(Args, CmdArgs);
3154 }
3155
3156 if (Args.hasArg(options::OPT_mkernel)) {
3157 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3158 CmdArgs.push_back("-fapple-kext");
3159 if (!Args.hasArg(options::OPT_fbuiltin))
3160 CmdArgs.push_back("-fno-builtin");
3161 Args.ClaimAllArgs(options::OPT_fno_builtin);
3162 }
3163 // -fbuiltin is default.
3164 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3165 CmdArgs.push_back("-fno-builtin");
3166
3167 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3168 options::OPT_fno_assume_sane_operator_new))
3169 CmdArgs.push_back("-fno-assume-sane-operator-new");
3170
3171 // -fblocks=0 is default.
3172 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3173 getToolChain().IsBlocksDefault()) ||
3174 (Args.hasArg(options::OPT_fgnu_runtime) &&
3175 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3176 !Args.hasArg(options::OPT_fno_blocks))) {
3177 CmdArgs.push_back("-fblocks");
3178
3179 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3180 !getToolChain().hasBlocksRuntime())
3181 CmdArgs.push_back("-fblocks-runtime-optional");
3182 }
3183
3184 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3185 // users must also pass -fcxx-modules. The latter flag will disappear once the
3186 // modules implementation is solid for C++/Objective-C++ programs as well.
3187 bool HaveModules = false;
3188 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3189 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3190 options::OPT_fno_cxx_modules,
3191 false);
3192 if (AllowedInCXX || !types::isCXX(InputType)) {
3193 CmdArgs.push_back("-fmodules");
3194 HaveModules = true;
3195 }
3196 }
3197
3198 // -fmodule-maps enables module map processing (off by default) for header
3199 // checking. It is implied by -fmodules.
3200 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3201 false)) {
3202 CmdArgs.push_back("-fmodule-maps");
3203 }
3204
3205 // -fmodules-decluse checks that modules used are declared so (off by
3206 // default).
3207 if (Args.hasFlag(options::OPT_fmodules_decluse,
3208 options::OPT_fno_modules_decluse,
3209 false)) {
3210 CmdArgs.push_back("-fmodules-decluse");
3211 }
3212
3213 // -fmodule-name specifies the module that is currently being built (or
3214 // used for header checking by -fmodule-maps).
3215 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3216 A->claim();
3217 A->render(Args, CmdArgs);
3218 }
3219
3220 // -fmodule-map-file can be used to specify a file containing module
3221 // definitions.
3222 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3223 A->claim();
3224 A->render(Args, CmdArgs);
3225 }
3226
3227 // If a module path was provided, pass it along. Otherwise, use a temporary
3228 // directory.
3229 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3230 A->claim();
3231 if (HaveModules) {
3232 A->render(Args, CmdArgs);
3233 }
3234 } else if (HaveModules) {
3235 SmallString<128> DefaultModuleCache;
3236 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3237 DefaultModuleCache);
3238 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3239 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
3240 const char Arg[] = "-fmodules-cache-path=";
3241 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3242 Arg, Arg + strlen(Arg));
3243 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3244 }
3245
3246 // Pass through all -fmodules-ignore-macro arguments.
3247 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3248 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3249 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3250
3251 // -faccess-control is default.
3252 if (Args.hasFlag(options::OPT_fno_access_control,
3253 options::OPT_faccess_control,
3254 false))
3255 CmdArgs.push_back("-fno-access-control");
3256
3257 // -felide-constructors is the default.
3258 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3259 options::OPT_felide_constructors,
3260 false))
3261 CmdArgs.push_back("-fno-elide-constructors");
3262
3263 // -frtti is default.
3264 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3265 KernelOrKext) {
3266 CmdArgs.push_back("-fno-rtti");
3267
3268 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
3269 if (Sanitize.sanitizesVptr()) {
3270 std::string NoRttiArg =
3271 Args.getLastArg(options::OPT_mkernel,
3272 options::OPT_fapple_kext,
3273 options::OPT_fno_rtti)->getAsString(Args);
3274 D.Diag(diag::err_drv_argument_not_allowed_with)
3275 << "-fsanitize=vptr" << NoRttiArg;
3276 }
3277 }
3278
3279 // -fshort-enums=0 is default for all architectures except Hexagon.
3280 if (Args.hasFlag(options::OPT_fshort_enums,
3281 options::OPT_fno_short_enums,
3282 getToolChain().getArch() ==
3283 llvm::Triple::hexagon))
3284 CmdArgs.push_back("-fshort-enums");
3285
3286 // -fsigned-char is default.
3287 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3288 isSignedCharDefault(getToolChain().getTriple())))
3289 CmdArgs.push_back("-fno-signed-char");
3290
3291 // -fthreadsafe-static is default.
3292 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3293 options::OPT_fno_threadsafe_statics))
3294 CmdArgs.push_back("-fno-threadsafe-statics");
3295
3296 // -fuse-cxa-atexit is default.
3297 if (!Args.hasFlag(
3298 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3299 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3300 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
3301 getToolChain().getArch() != llvm::Triple::hexagon &&
3302 getToolChain().getArch() != llvm::Triple::xcore) ||
3303 KernelOrKext)
3304 CmdArgs.push_back("-fno-use-cxa-atexit");
3305
3306 // -fms-extensions=0 is default.
3307 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3308 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3309 CmdArgs.push_back("-fms-extensions");
3310
3311 // -fms-compatibility=0 is default.
3312 if (Args.hasFlag(options::OPT_fms_compatibility,
3313 options::OPT_fno_ms_compatibility,
3314 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3315 Args.hasFlag(options::OPT_fms_extensions,
3316 options::OPT_fno_ms_extensions,
3317 true))))
3318 CmdArgs.push_back("-fms-compatibility");
3319
3320 // -fmsc-version=1700 is default.
3321 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3322 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3323 Args.hasArg(options::OPT_fmsc_version)) {
3324 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3325 if (msc_ver.empty())
3326 CmdArgs.push_back("-fmsc-version=1700");
3327 else
3328 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3329 }
3330
3331
3332 // -fno-borland-extensions is default.
3333 if (Args.hasFlag(options::OPT_fborland_extensions,
3334 options::OPT_fno_borland_extensions, false))
3335 CmdArgs.push_back("-fborland-extensions");
3336
3337 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3338 // needs it.
3339 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3340 options::OPT_fno_delayed_template_parsing,
3341 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3342 CmdArgs.push_back("-fdelayed-template-parsing");
3343
3344 // -fgnu-keywords default varies depending on language; only pass if
3345 // specified.
3346 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3347 options::OPT_fno_gnu_keywords))
3348 A->render(Args, CmdArgs);
3349
3350 if (Args.hasFlag(options::OPT_fgnu89_inline,
3351 options::OPT_fno_gnu89_inline,
3352 false))
3353 CmdArgs.push_back("-fgnu89-inline");
3354
3355 if (Args.hasArg(options::OPT_fno_inline))
3356 CmdArgs.push_back("-fno-inline");
3357
3358 if (Args.hasArg(options::OPT_fno_inline_functions))
3359 CmdArgs.push_back("-fno-inline-functions");
3360
3361 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3362
3363 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3364 // legacy is the default. Next runtime is always legacy dispatch and
3365 // -fno-objc-legacy-dispatch gets ignored silently.
3366 if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) {
3367 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3368 options::OPT_fno_objc_legacy_dispatch,
3369 objcRuntime.isLegacyDispatchDefaultForArch(
3370 getToolChain().getArch()))) {
3371 if (getToolChain().UseObjCMixedDispatch())
3372 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3373 else
3374 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3375 }
3376 }
3377
3378 // When ObjectiveC legacy runtime is in effect on MacOSX,
3379 // turn on the option to do Array/Dictionary subscripting
3380 // by default.
3381 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3382 getToolChain().getTriple().isMacOSX() &&
3383 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3384 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
3385 objcRuntime.isNeXTFamily())
3386 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3387
3388 // -fencode-extended-block-signature=1 is default.
3389 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3390 CmdArgs.push_back("-fencode-extended-block-signature");
3391 }
3392
3393 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3394 // NOTE: This logic is duplicated in ToolChains.cpp.
3395 bool ARC = isObjCAutoRefCount(Args);
3396 if (ARC) {
3397 getToolChain().CheckObjCARC();
3398
3399 CmdArgs.push_back("-fobjc-arc");
3400
3401 // FIXME: It seems like this entire block, and several around it should be
3402 // wrapped in isObjC, but for now we just use it here as this is where it
3403 // was being used previously.
3404 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3405 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3406 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3407 else
3408 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3409 }
3410
3411 // Allow the user to enable full exceptions code emission.
3412 // We define off for Objective-CC, on for Objective-C++.
3413 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3414 options::OPT_fno_objc_arc_exceptions,
3415 /*default*/ types::isCXX(InputType)))
3416 CmdArgs.push_back("-fobjc-arc-exceptions");
3417 }
3418
3419 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3420 // rewriter.
3421 if (rewriteKind != RK_None)
3422 CmdArgs.push_back("-fno-objc-infer-related-result-type");
3423
3424 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3425 // takes precedence.
3426 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3427 if (!GCArg)
3428 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3429 if (GCArg) {
3430 if (ARC) {
3431 D.Diag(diag::err_drv_objc_gc_arr)
3432 << GCArg->getAsString(Args);
3433 } else if (getToolChain().SupportsObjCGC()) {
3434 GCArg->render(Args, CmdArgs);
3435 } else {
3436 // FIXME: We should move this to a hard error.
3437 D.Diag(diag::warn_drv_objc_gc_unsupported)
3438 << GCArg->getAsString(Args);
3439 }
3440 }
3441
3442 // Add exception args.
3443 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3444 KernelOrKext, objcRuntime, CmdArgs);
3445
3446 if (getToolChain().UseSjLjExceptions())
3447 CmdArgs.push_back("-fsjlj-exceptions");
3448
3449 // C++ "sane" operator new.
3450 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3451 options::OPT_fno_assume_sane_operator_new))
3452 CmdArgs.push_back("-fno-assume-sane-operator-new");
3453
3454 // -fconstant-cfstrings is default, and may be subject to argument translation
3455 // on Darwin.
3456 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3457 options::OPT_fno_constant_cfstrings) ||
3458 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3459 options::OPT_mno_constant_cfstrings))
3460 CmdArgs.push_back("-fno-constant-cfstrings");
3461
3462 // -fshort-wchar default varies depending on platform; only
3463 // pass if specified.
3464 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3465 A->render(Args, CmdArgs);
3466
3467 // -fno-pascal-strings is default, only pass non-default.
3468 if (Args.hasFlag(options::OPT_fpascal_strings,
3469 options::OPT_fno_pascal_strings,
3470 false))
3471 CmdArgs.push_back("-fpascal-strings");
3472
3473 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3474 // -fno-pack-struct doesn't apply to -fpack-struct=.
3475 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3476 std::string PackStructStr = "-fpack-struct=";
3477 PackStructStr += A->getValue();
3478 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3479 } else if (Args.hasFlag(options::OPT_fpack_struct,
3480 options::OPT_fno_pack_struct, false)) {
3481 CmdArgs.push_back("-fpack-struct=1");
3482 }
3483
3484 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
3485 if (!Args.hasArg(options::OPT_fcommon))
3486 CmdArgs.push_back("-fno-common");
3487 Args.ClaimAllArgs(options::OPT_fno_common);
3488 }
3489
3490 // -fcommon is default, only pass non-default.
3491 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3492 CmdArgs.push_back("-fno-common");
3493
3494 // -fsigned-bitfields is default, and clang doesn't yet support
3495 // -funsigned-bitfields.
3496 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3497 options::OPT_funsigned_bitfields))
3498 D.Diag(diag::warn_drv_clang_unsupported)
3499 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3500
3501 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3502 if (!Args.hasFlag(options::OPT_ffor_scope,
3503 options::OPT_fno_for_scope))
3504 D.Diag(diag::err_drv_clang_unsupported)
3505 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3506
3507 // -fcaret-diagnostics is default.
3508 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3509 options::OPT_fno_caret_diagnostics, true))
3510 CmdArgs.push_back("-fno-caret-diagnostics");
3511
3512 // -fdiagnostics-fixit-info is default, only pass non-default.
3513 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3514 options::OPT_fno_diagnostics_fixit_info))
3515 CmdArgs.push_back("-fno-diagnostics-fixit-info");
3516
3517 // Enable -fdiagnostics-show-option by default.
3518 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3519 options::OPT_fno_diagnostics_show_option))
3520 CmdArgs.push_back("-fdiagnostics-show-option");
3521
3522 if (const Arg *A =
3523 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3524 CmdArgs.push_back("-fdiagnostics-show-category");
3525 CmdArgs.push_back(A->getValue());
3526 }
3527
3528 if (const Arg *A =
3529 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3530 CmdArgs.push_back("-fdiagnostics-format");
3531 CmdArgs.push_back(A->getValue());
3532 }
3533
3534 if (Arg *A = Args.getLastArg(
3535 options::OPT_fdiagnostics_show_note_include_stack,
3536 options::OPT_fno_diagnostics_show_note_include_stack)) {
3537 if (A->getOption().matches(
3538 options::OPT_fdiagnostics_show_note_include_stack))
3539 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3540 else
3541 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3542 }
3543
3544 // Color diagnostics are the default, unless the terminal doesn't support
3545 // them.
3546 // Support both clang's -f[no-]color-diagnostics and gcc's
3547 // -f[no-]diagnostics-colors[=never|always|auto].
3548 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3549 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3550 it != ie; ++it) {
3551 const Option &O = (*it)->getOption();
3552 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3553 !O.matches(options::OPT_fdiagnostics_color) &&
3554 !O.matches(options::OPT_fno_color_diagnostics) &&
3555 !O.matches(options::OPT_fno_diagnostics_color) &&
3556 !O.matches(options::OPT_fdiagnostics_color_EQ))
3557 continue;
3558
3559 (*it)->claim();
3560 if (O.matches(options::OPT_fcolor_diagnostics) ||
3561 O.matches(options::OPT_fdiagnostics_color)) {
3562 ShowColors = Colors_On;
3563 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3564 O.matches(options::OPT_fno_diagnostics_color)) {
3565 ShowColors = Colors_Off;
3566 } else {
3567 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3568 StringRef value((*it)->getValue());
3569 if (value == "always")
3570 ShowColors = Colors_On;
3571 else if (value == "never")
3572 ShowColors = Colors_Off;
3573 else if (value == "auto")
3574 ShowColors = Colors_Auto;
3575 else
3576 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3577 << ("-fdiagnostics-color=" + value).str();
3578 }
3579 }
3580 if (ShowColors == Colors_On ||
3581 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
3582 CmdArgs.push_back("-fcolor-diagnostics");
3583
3584 if (Args.hasArg(options::OPT_fansi_escape_codes))
3585 CmdArgs.push_back("-fansi-escape-codes");
3586
3587 if (!Args.hasFlag(options::OPT_fshow_source_location,
3588 options::OPT_fno_show_source_location))
3589 CmdArgs.push_back("-fno-show-source-location");
3590
3591 if (!Args.hasFlag(options::OPT_fshow_column,
3592 options::OPT_fno_show_column,
3593 true))
3594 CmdArgs.push_back("-fno-show-column");
3595
3596 if (!Args.hasFlag(options::OPT_fspell_checking,
3597 options::OPT_fno_spell_checking))
3598 CmdArgs.push_back("-fno-spell-checking");
3599
3600
3601 // -fno-asm-blocks is default.
3602 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3603 false))
3604 CmdArgs.push_back("-fasm-blocks");
3605
3606 // Enable vectorization per default according to the optimization level
3607 // selected. For optimization levels that want vectorization we use the alias
3608 // option to simplify the hasFlag logic.
3609 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3610 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
3611 options::OPT_fvectorize;
3612 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
3613 options::OPT_fno_vectorize, EnableVec))
3614 CmdArgs.push_back("-vectorize-loops");
3615
3616 // -fslp-vectorize is default.
3617 if (Args.hasFlag(options::OPT_fslp_vectorize,
3618 options::OPT_fno_slp_vectorize, true))
3619 CmdArgs.push_back("-vectorize-slp");
3620
3621 // -fno-slp-vectorize-aggressive is default.
3622 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
3623 options::OPT_fno_slp_vectorize_aggressive, false))
3624 CmdArgs.push_back("-vectorize-slp-aggressive");
3625
3626 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3627 A->render(Args, CmdArgs);
3628
3629 // -fdollars-in-identifiers default varies depending on platform and
3630 // language; only pass if specified.
3631 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3632 options::OPT_fno_dollars_in_identifiers)) {
3633 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3634 CmdArgs.push_back("-fdollars-in-identifiers");
3635 else
3636 CmdArgs.push_back("-fno-dollars-in-identifiers");
3637 }
3638
3639 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3640 // practical purposes.
3641 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3642 options::OPT_fno_unit_at_a_time)) {
3643 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3644 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3645 }
3646
3647 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3648 options::OPT_fno_apple_pragma_pack, false))
3649 CmdArgs.push_back("-fapple-pragma-pack");
3650
3651 // le32-specific flags:
3652 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3653 // by default.
3654 if (getToolChain().getArch() == llvm::Triple::le32) {
3655 CmdArgs.push_back("-fno-math-builtin");
3656 }
3657
3658 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3659 //
3660 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3661#if 0
3662 if (getToolChain().getTriple().isOSDarwin() &&
3663 (getToolChain().getArch() == llvm::Triple::arm ||
3664 getToolChain().getArch() == llvm::Triple::thumb)) {
3665 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3666 CmdArgs.push_back("-fno-builtin-strcat");
3667 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3668 CmdArgs.push_back("-fno-builtin-strcpy");
3669 }
3670#endif
3671
3672 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3673 if (Arg *A = Args.getLastArg(options::OPT_traditional,
3674 options::OPT_traditional_cpp)) {
3675 if (isa<PreprocessJobAction>(JA))
3676 CmdArgs.push_back("-traditional-cpp");
3677 else
3678 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3679 }
3680
3681 Args.AddLastArg(CmdArgs, options::OPT_dM);
3682 Args.AddLastArg(CmdArgs, options::OPT_dD);
3683
3684 // Handle serialized diagnostics.
3685 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3686 CmdArgs.push_back("-serialize-diagnostic-file");
3687 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3688 }
3689
3690 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3691 CmdArgs.push_back("-fretain-comments-from-system-headers");
3692
3693 // Forward -fcomment-block-commands to -cc1.
3694 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3695 // Forward -fparse-all-comments to -cc1.
3696 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
3697
3698 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3699 // parser.
3700 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3701 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3702 ie = Args.filtered_end(); it != ie; ++it) {
3703 (*it)->claim();
3704
3705 // We translate this by hand to the -cc1 argument, since nightly test uses
3706 // it and developers have been trained to spell it with -mllvm.
3707 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3708 CmdArgs.push_back("-disable-llvm-optzns");
3709 else
3710 (*it)->render(Args, CmdArgs);
3711 }
3712
3713 if (Output.getType() == types::TY_Dependencies) {
3714 // Handled with other dependency code.
3715 } else if (Output.isFilename()) {
3716 CmdArgs.push_back("-o");
3717 CmdArgs.push_back(Output.getFilename());
3718 } else {
3719 assert(Output.isNothing() && "Invalid output.");
3720 }
3721
3722 for (InputInfoList::const_iterator
3723 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3724 const InputInfo &II = *it;
3725 CmdArgs.push_back("-x");
3726 if (Args.hasArg(options::OPT_rewrite_objc))
3727 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3728 else
3729 CmdArgs.push_back(types::getTypeName(II.getType()));
3730 if (II.isFilename())
3731 CmdArgs.push_back(II.getFilename());
3732 else
3733 II.getInputArg().renderAsInput(Args, CmdArgs);
3734 }
3735
3736 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3737
3738 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3739
3740 // Optionally embed the -cc1 level arguments into the debug info, for build
3741 // analysis.
3742 if (getToolChain().UseDwarfDebugFlags()) {
3743 ArgStringList OriginalArgs;
3744 for (ArgList::const_iterator it = Args.begin(),
3745 ie = Args.end(); it != ie; ++it)
3746 (*it)->render(Args, OriginalArgs);
3747
3748 SmallString<256> Flags;
3749 Flags += Exec;
3750 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3751 Flags += " ";
3752 Flags += OriginalArgs[i];
3753 }
3754 CmdArgs.push_back("-dwarf-debug-flags");
3755 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3756 }
3757
3758 // Add the split debug info name to the command lines here so we
3759 // can propagate it to the backend.
3760 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3761 getToolChain().getTriple().isOSLinux() &&
3762 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3763 const char *SplitDwarfOut;
3764 if (SplitDwarf) {
3765 CmdArgs.push_back("-split-dwarf-file");
3766 SplitDwarfOut = SplitDebugName(Args, Inputs);
3767 CmdArgs.push_back(SplitDwarfOut);
3768 }
3769
3770 // Finally add the compile command to the compilation.
3771 if (Args.hasArg(options::OPT__SLASH_fallback)) {
3772 tools::visualstudio::Compile CL(getToolChain());
3773 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3774 LinkingOutput);
3775 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3776 } else {
3777 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3778 }
3779
3780
3781 // Handle the debug info splitting at object creation time if we're
3782 // creating an object.
3783 // TODO: Currently only works on linux with newer objcopy.
3784 if (SplitDwarf && !isa<CompileJobAction>(JA))
3785 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3786
3787 if (Arg *A = Args.getLastArg(options::OPT_pg))
3788 if (Args.hasArg(options::OPT_fomit_frame_pointer))
3789 D.Diag(diag::err_drv_argument_not_allowed_with)
3790 << "-fomit-frame-pointer" << A->getAsString(Args);
3791
3792 // Claim some arguments which clang supports automatically.
3793
3794 // -fpch-preprocess is used with gcc to add a special marker in the output to
3795 // include the PCH file. Clang's PTH solution is completely transparent, so we
3796 // do not need to deal with it at all.
3797 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3798
3799 // Claim some arguments which clang doesn't support, but we don't
3800 // care to warn the user about.
3801 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3802 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3803
3804 // Disable warnings for clang -E -emit-llvm foo.c
3805 Args.ClaimAllArgs(options::OPT_emit_llvm);
3806}
3807
3808/// Add options related to the Objective-C runtime/ABI.
3809///
3810/// Returns true if the runtime is non-fragile.
3811ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3812 ArgStringList &cmdArgs,
3813 RewriteKind rewriteKind) const {
3814 // Look for the controlling runtime option.
3815 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3816 options::OPT_fgnu_runtime,
3817 options::OPT_fobjc_runtime_EQ);
3818
3819 // Just forward -fobjc-runtime= to the frontend. This supercedes
3820 // options about fragility.
3821 if (runtimeArg &&
3822 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3823 ObjCRuntime runtime;
3824 StringRef value = runtimeArg->getValue();
3825 if (runtime.tryParse(value)) {
3826 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3827 << value;
3828 }
3829
3830 runtimeArg->render(args, cmdArgs);
3831 return runtime;
3832 }
3833
3834 // Otherwise, we'll need the ABI "version". Version numbers are
3835 // slightly confusing for historical reasons:
3836 // 1 - Traditional "fragile" ABI
3837 // 2 - Non-fragile ABI, version 1
3838 // 3 - Non-fragile ABI, version 2
3839 unsigned objcABIVersion = 1;
3840 // If -fobjc-abi-version= is present, use that to set the version.
3841 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3842 StringRef value = abiArg->getValue();
3843 if (value == "1")
3844 objcABIVersion = 1;
3845 else if (value == "2")
3846 objcABIVersion = 2;
3847 else if (value == "3")
3848 objcABIVersion = 3;
3849 else
3850 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3851 << value;
3852 } else {
3853 // Otherwise, determine if we are using the non-fragile ABI.
3854 bool nonFragileABIIsDefault =
3855 (rewriteKind == RK_NonFragile ||
3856 (rewriteKind == RK_None &&
3857 getToolChain().IsObjCNonFragileABIDefault()));
3858 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3859 options::OPT_fno_objc_nonfragile_abi,
3860 nonFragileABIIsDefault)) {
3861 // Determine the non-fragile ABI version to use.
3862#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3863 unsigned nonFragileABIVersion = 1;
3864#else
3865 unsigned nonFragileABIVersion = 2;
3866#endif
3867
3868 if (Arg *abiArg = args.getLastArg(
3869 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3870 StringRef value = abiArg->getValue();
3871 if (value == "1")
3872 nonFragileABIVersion = 1;
3873 else if (value == "2")
3874 nonFragileABIVersion = 2;
3875 else
3876 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3877 << value;
3878 }
3879
3880 objcABIVersion = 1 + nonFragileABIVersion;
3881 } else {
3882 objcABIVersion = 1;
3883 }
3884 }
3885
3886 // We don't actually care about the ABI version other than whether
3887 // it's non-fragile.
3888 bool isNonFragile = objcABIVersion != 1;
3889
3890 // If we have no runtime argument, ask the toolchain for its default runtime.
3891 // However, the rewriter only really supports the Mac runtime, so assume that.
3892 ObjCRuntime runtime;
3893 if (!runtimeArg) {
3894 switch (rewriteKind) {
3895 case RK_None:
3896 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3897 break;
3898 case RK_Fragile:
3899 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3900 break;
3901 case RK_NonFragile:
3902 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3903 break;
3904 }
3905
3906 // -fnext-runtime
3907 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3908 // On Darwin, make this use the default behavior for the toolchain.
3909 if (getToolChain().getTriple().isOSDarwin()) {
3910 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3911
3912 // Otherwise, build for a generic macosx port.
3913 } else {
3914 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3915 }
3916
3917 // -fgnu-runtime
3918 } else {
3919 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3920 // Legacy behaviour is to target the gnustep runtime if we are i
3921 // non-fragile mode or the GCC runtime in fragile mode.
3922 if (isNonFragile)
3923 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3924 else
3925 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3926 }
3927
3928 cmdArgs.push_back(args.MakeArgString(
3929 "-fobjc-runtime=" + runtime.getAsString()));
3930 return runtime;
3931}
3932
3933void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3934 unsigned RTOptionID = options::OPT__SLASH_MT;
3935
3936 if (Args.hasArg(options::OPT__SLASH_LDd))
3937 // The /LDd option implies /MTd. The dependent lib part can be overridden,
3938 // but defining _DEBUG is sticky.
3939 RTOptionID = options::OPT__SLASH_MTd;
3940
3941 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
3942 RTOptionID = A->getOption().getID();
3943
3944 switch(RTOptionID) {
3945 case options::OPT__SLASH_MD:
3946 if (Args.hasArg(options::OPT__SLASH_LDd))
3947 CmdArgs.push_back("-D_DEBUG");
3948 CmdArgs.push_back("-D_MT");
3949 CmdArgs.push_back("-D_DLL");
3950 CmdArgs.push_back("--dependent-lib=msvcrt");
3951 break;
3952 case options::OPT__SLASH_MDd:
3953 CmdArgs.push_back("-D_DEBUG");
3954 CmdArgs.push_back("-D_MT");
3955 CmdArgs.push_back("-D_DLL");
3956 CmdArgs.push_back("--dependent-lib=msvcrtd");
3957 break;
3958 case options::OPT__SLASH_MT:
3959 if (Args.hasArg(options::OPT__SLASH_LDd))
3960 CmdArgs.push_back("-D_DEBUG");
3961 CmdArgs.push_back("-D_MT");
3962 CmdArgs.push_back("--dependent-lib=libcmt");
3963 break;
3964 case options::OPT__SLASH_MTd:
3965 CmdArgs.push_back("-D_DEBUG");
3966 CmdArgs.push_back("-D_MT");
3967 CmdArgs.push_back("--dependent-lib=libcmtd");
3968 break;
3969 default:
3970 llvm_unreachable("Unexpected option ID.");
3971 }
3972
3973 // This provides POSIX compatibility (maps 'open' to '_open'), which most
3974 // users want. The /Za flag to cl.exe turns this off, but it's not
3975 // implemented in clang.
3976 CmdArgs.push_back("--dependent-lib=oldnames");
3977
3978 // FIXME: Make this default for the win32 triple.
3979 CmdArgs.push_back("-cxx-abi");
3980 CmdArgs.push_back("microsoft");
3981
3982 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3983 A->render(Args, CmdArgs);
3984
3985 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3986 CmdArgs.push_back("-fdiagnostics-format");
3987 if (Args.hasArg(options::OPT__SLASH_fallback))
3988 CmdArgs.push_back("msvc-fallback");
3989 else
3990 CmdArgs.push_back("msvc");
3991 }
3992}
3993
3994void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
3995 const InputInfo &Output,
3996 const InputInfoList &Inputs,
3997 const ArgList &Args,
3998 const char *LinkingOutput) const {
3999 ArgStringList CmdArgs;
4000
4001 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4002 const InputInfo &Input = Inputs[0];
4003
4004 // Don't warn about "clang -w -c foo.s"
4005 Args.ClaimAllArgs(options::OPT_w);
4006 // and "clang -emit-llvm -c foo.s"
4007 Args.ClaimAllArgs(options::OPT_emit_llvm);
4008
4009 // Invoke ourselves in -cc1as mode.
4010 //
4011 // FIXME: Implement custom jobs for internal actions.
4012 CmdArgs.push_back("-cc1as");
4013
4014 // Add the "effective" target triple.
4015 CmdArgs.push_back("-triple");
4016 std::string TripleStr =
4017 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4018 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4019
4020 // Set the output mode, we currently only expect to be used as a real
4021 // assembler.
4022 CmdArgs.push_back("-filetype");
4023 CmdArgs.push_back("obj");
4024
4025 // Set the main file name, so that debug info works even with
4026 // -save-temps or preprocessed assembly.
4027 CmdArgs.push_back("-main-file-name");
4028 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4029
4030 // Add the target cpu
4031 const llvm::Triple &Triple = getToolChain().getTriple();
4032 std::string CPU = getCPUName(Args, Triple);
4033 if (!CPU.empty()) {
4034 CmdArgs.push_back("-target-cpu");
4035 CmdArgs.push_back(Args.MakeArgString(CPU));
4036 }
4037
4038 // Add the target features
4039 const Driver &D = getToolChain().getDriver();
4040 getTargetFeatures(D, Triple, Args, CmdArgs);
4041
4042 // Ignore explicit -force_cpusubtype_ALL option.
4043 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4044
4045 // Determine the original source input.
4046 const Action *SourceAction = &JA;
4047 while (SourceAction->getKind() != Action::InputClass) {
4048 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4049 SourceAction = SourceAction->getInputs()[0];
4050 }
4051
4052 // Forward -g and handle debug info related flags, assuming we are dealing
4053 // with an actual assembly file.
4054 if (SourceAction->getType() == types::TY_Asm ||
4055 SourceAction->getType() == types::TY_PP_Asm) {
4056 Args.ClaimAllArgs(options::OPT_g_Group);
4057 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4058 if (!A->getOption().matches(options::OPT_g0))
4059 CmdArgs.push_back("-g");
4060
4061 // Add the -fdebug-compilation-dir flag if needed.
4062 addDebugCompDirArg(Args, CmdArgs);
4063
4064 // Set the AT_producer to the clang version when using the integrated
4065 // assembler on assembly source files.
4066 CmdArgs.push_back("-dwarf-debug-producer");
4067 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4068 }
4069
4070 // Optionally embed the -cc1as level arguments into the debug info, for build
4071 // analysis.
4072 if (getToolChain().UseDwarfDebugFlags()) {
4073 ArgStringList OriginalArgs;
4074 for (ArgList::const_iterator it = Args.begin(),
4075 ie = Args.end(); it != ie; ++it)
4076 (*it)->render(Args, OriginalArgs);
4077
4078 SmallString<256> Flags;
4079 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4080 Flags += Exec;
4081 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4082 Flags += " ";
4083 Flags += OriginalArgs[i];
4084 }
4085 CmdArgs.push_back("-dwarf-debug-flags");
4086 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4087 }
4088
4089 // FIXME: Add -static support, once we have it.
4090
4091 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4092 getToolChain().getDriver());
4093
4094 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4095
4096 assert(Output.isFilename() && "Unexpected lipo output.");
4097 CmdArgs.push_back("-o");
4098 CmdArgs.push_back(Output.getFilename());
4099
4100 assert(Input.isFilename() && "Invalid input.");
4101 CmdArgs.push_back(Input.getFilename());
4102
4103 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4104 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4105
4106 // Handle the debug info splitting at object creation time if we're
4107 // creating an object.
4108 // TODO: Currently only works on linux with newer objcopy.
4109 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4110 getToolChain().getTriple().isOSLinux())
4111 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4112 SplitDebugName(Args, Inputs));
4113}
4114
4115void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
4116 const InputInfo &Output,
4117 const InputInfoList &Inputs,
4118 const ArgList &Args,
4119 const char *LinkingOutput) const {
4120 const Driver &D = getToolChain().getDriver();
4121 ArgStringList CmdArgs;
4122
4123 for (ArgList::const_iterator
4124 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
4125 Arg *A = *it;
4126 if (forwardToGCC(A->getOption())) {
4127 // Don't forward any -g arguments to assembly steps.
4128 if (isa<AssembleJobAction>(JA) &&
4129 A->getOption().matches(options::OPT_g_Group))
4130 continue;
4131
4132 // Don't forward any -W arguments to assembly and link steps.
4133 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4134 A->getOption().matches(options::OPT_W_Group))
4135 continue;
4136
4137 // It is unfortunate that we have to claim here, as this means
4138 // we will basically never report anything interesting for
4139 // platforms using a generic gcc, even if we are just using gcc
4140 // to get to the assembler.
4141 A->claim();
4142 A->render(Args, CmdArgs);
4143 }
4144 }
4145
4146 RenderExtraToolArgs(JA, CmdArgs);
4147
4148 // If using a driver driver, force the arch.
4149 llvm::Triple::ArchType Arch = getToolChain().getArch();
4150 if (getToolChain().getTriple().isOSDarwin()) {
4151 CmdArgs.push_back("-arch");
4152
4153 // FIXME: Remove these special cases.
4154 if (Arch == llvm::Triple::ppc)
4155 CmdArgs.push_back("ppc");
4156 else if (Arch == llvm::Triple::ppc64)
4157 CmdArgs.push_back("ppc64");
4158 else if (Arch == llvm::Triple::ppc64le)
4159 CmdArgs.push_back("ppc64le");
4160 else
4161 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4162 }
4163
4164 // Try to force gcc to match the tool chain we want, if we recognize
4165 // the arch.
4166 //
4167 // FIXME: The triple class should directly provide the information we want
4168 // here.
4169 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
4170 CmdArgs.push_back("-m32");
4171 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4172 Arch == llvm::Triple::ppc64le)
4173 CmdArgs.push_back("-m64");
4174
4175 if (Output.isFilename()) {
4176 CmdArgs.push_back("-o");
4177 CmdArgs.push_back(Output.getFilename());
4178 } else {
4179 assert(Output.isNothing() && "Unexpected output");
4180 CmdArgs.push_back("-fsyntax-only");
4181 }
4182
4183 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4184 options::OPT_Xassembler);
4185
4186 // Only pass -x if gcc will understand it; otherwise hope gcc
4187 // understands the suffix correctly. The main use case this would go
4188 // wrong in is for linker inputs if they happened to have an odd
4189 // suffix; really the only way to get this to happen is a command
4190 // like '-x foobar a.c' which will treat a.c like a linker input.
4191 //
4192 // FIXME: For the linker case specifically, can we safely convert
4193 // inputs into '-Wl,' options?
4194 for (InputInfoList::const_iterator
4195 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4196 const InputInfo &II = *it;
4197
4198 // Don't try to pass LLVM or AST inputs to a generic gcc.
4199 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4200 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4201 D.Diag(diag::err_drv_no_linker_llvm_support)
4202 << getToolChain().getTripleString();
4203 else if (II.getType() == types::TY_AST)
4204 D.Diag(diag::err_drv_no_ast_support)
4205 << getToolChain().getTripleString();
4206 else if (II.getType() == types::TY_ModuleFile)
4207 D.Diag(diag::err_drv_no_module_support)
4208 << getToolChain().getTripleString();
4209
4210 if (types::canTypeBeUserSpecified(II.getType())) {
4211 CmdArgs.push_back("-x");
4212 CmdArgs.push_back(types::getTypeName(II.getType()));
4213 }
4214
4215 if (II.isFilename())
4216 CmdArgs.push_back(II.getFilename());
4217 else {
4218 const Arg &A = II.getInputArg();
4219
4220 // Reverse translate some rewritten options.
4221 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4222 CmdArgs.push_back("-lstdc++");
4223 continue;
4224 }
4225
4226 // Don't render as input, we need gcc to do the translations.
4227 A.render(Args, CmdArgs);
4228 }
4229 }
4230
4231 const std::string customGCCName = D.getCCCGenericGCCName();
4232 const char *GCCName;
4233 if (!customGCCName.empty())
4234 GCCName = customGCCName.c_str();
4235 else if (D.CCCIsCXX()) {
4236 GCCName = "g++";
4237 } else
4238 GCCName = "gcc";
4239
4240 const char *Exec =
4241 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4242 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4243}
4244
4245void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4246 ArgStringList &CmdArgs) const {
4247 CmdArgs.push_back("-E");
4248}
4249
4250void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4251 ArgStringList &CmdArgs) const {
4252 // The type is good enough.
4253}
4254
4255void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4256 ArgStringList &CmdArgs) const {
4257 const Driver &D = getToolChain().getDriver();
4258
4259 // If -flto, etc. are present then make sure not to force assembly output.
4260 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4261 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
4262 CmdArgs.push_back("-c");
4263 else {
4264 if (JA.getType() != types::TY_PP_Asm)
4265 D.Diag(diag::err_drv_invalid_gcc_output_type)
4266 << getTypeName(JA.getType());
4267
4268 CmdArgs.push_back("-S");
4269 }
4270}
4271
4272void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4273 ArgStringList &CmdArgs) const {
4274 CmdArgs.push_back("-c");
4275}
4276
4277void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4278 ArgStringList &CmdArgs) const {
4279 // The types are (hopefully) good enough.
4280}
4281
4282// Hexagon tools start.
4283void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4284 ArgStringList &CmdArgs) const {
4285
4286}
4287void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4288 const InputInfo &Output,
4289 const InputInfoList &Inputs,
4290 const ArgList &Args,
4291 const char *LinkingOutput) const {
4292
4293 const Driver &D = getToolChain().getDriver();
4294 ArgStringList CmdArgs;
4295
4296 std::string MarchString = "-march=";
4297 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4298 CmdArgs.push_back(Args.MakeArgString(MarchString));
4299
4300 RenderExtraToolArgs(JA, CmdArgs);
4301
4302 if (Output.isFilename()) {
4303 CmdArgs.push_back("-o");
4304 CmdArgs.push_back(Output.getFilename());
4305 } else {
4306 assert(Output.isNothing() && "Unexpected output");
4307 CmdArgs.push_back("-fsyntax-only");
4308 }
4309
4310 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4311 if (!SmallDataThreshold.empty())
4312 CmdArgs.push_back(
4313 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4314
4315 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4316 options::OPT_Xassembler);
4317
4318 // Only pass -x if gcc will understand it; otherwise hope gcc
4319 // understands the suffix correctly. The main use case this would go
4320 // wrong in is for linker inputs if they happened to have an odd
4321 // suffix; really the only way to get this to happen is a command
4322 // like '-x foobar a.c' which will treat a.c like a linker input.
4323 //
4324 // FIXME: For the linker case specifically, can we safely convert
4325 // inputs into '-Wl,' options?
4326 for (InputInfoList::const_iterator
4327 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4328 const InputInfo &II = *it;
4329
4330 // Don't try to pass LLVM or AST inputs to a generic gcc.
4331 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4332 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4333 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4334 << getToolChain().getTripleString();
4335 else if (II.getType() == types::TY_AST)
4336 D.Diag(clang::diag::err_drv_no_ast_support)
4337 << getToolChain().getTripleString();
4338 else if (II.getType() == types::TY_ModuleFile)
4339 D.Diag(diag::err_drv_no_module_support)
4340 << getToolChain().getTripleString();
4341
4342 if (II.isFilename())
4343 CmdArgs.push_back(II.getFilename());
4344 else
4345 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4346 II.getInputArg().render(Args, CmdArgs);
4347 }
4348
4349 const char *GCCName = "hexagon-as";
4350 const char *Exec =
4351 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4352 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4353
4354}
4355void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4356 ArgStringList &CmdArgs) const {
4357 // The types are (hopefully) good enough.
4358}
4359
4360void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4361 const InputInfo &Output,
4362 const InputInfoList &Inputs,
4363 const ArgList &Args,
4364 const char *LinkingOutput) const {
4365
4366 const toolchains::Hexagon_TC& ToolChain =
4367 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4368 const Driver &D = ToolChain.getDriver();
4369
4370 ArgStringList CmdArgs;
4371
4372 //----------------------------------------------------------------------------
4373 //
4374 //----------------------------------------------------------------------------
4375 bool hasStaticArg = Args.hasArg(options::OPT_static);
4376 bool buildingLib = Args.hasArg(options::OPT_shared);
4377 bool buildPIE = Args.hasArg(options::OPT_pie);
4378 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4379 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4380 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4381 bool useShared = buildingLib && !hasStaticArg;
4382
4383 //----------------------------------------------------------------------------
4384 // Silence warnings for various options
4385 //----------------------------------------------------------------------------
4386
4387 Args.ClaimAllArgs(options::OPT_g_Group);
4388 Args.ClaimAllArgs(options::OPT_emit_llvm);
4389 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4390 // handled somewhere else.
4391 Args.ClaimAllArgs(options::OPT_static_libgcc);
4392
4393 //----------------------------------------------------------------------------
4394 //
4395 //----------------------------------------------------------------------------
4396 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4397 e = ToolChain.ExtraOpts.end();
4398 i != e; ++i)
4399 CmdArgs.push_back(i->c_str());
4400
4401 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4402 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4403
4404 if (buildingLib) {
4405 CmdArgs.push_back("-shared");
4406 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4407 // hexagon-gcc does
4408 }
4409
4410 if (hasStaticArg)
4411 CmdArgs.push_back("-static");
4412
4413 if (buildPIE && !buildingLib)
4414 CmdArgs.push_back("-pie");
4415
4416 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4417 if (!SmallDataThreshold.empty()) {
4418 CmdArgs.push_back(
4419 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4420 }
4421
4422 //----------------------------------------------------------------------------
4423 //
4424 //----------------------------------------------------------------------------
4425 CmdArgs.push_back("-o");
4426 CmdArgs.push_back(Output.getFilename());
4427
4428 const std::string MarchSuffix = "/" + MarchString;
4429 const std::string G0Suffix = "/G0";
4430 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4431 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4432 + "/";
4433 const std::string StartFilesDir = RootDir
4434 + "hexagon/lib"
4435 + (buildingLib
4436 ? MarchG0Suffix : MarchSuffix);
4437
4438 //----------------------------------------------------------------------------
4439 // moslib
4440 //----------------------------------------------------------------------------
4441 std::vector<std::string> oslibs;
4442 bool hasStandalone= false;
4443
4444 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4445 ie = Args.filtered_end(); it != ie; ++it) {
4446 (*it)->claim();
4447 oslibs.push_back((*it)->getValue());
4448 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
4449 }
4450 if (oslibs.empty()) {
4451 oslibs.push_back("standalone");
4452 hasStandalone = true;
4453 }
4454
4455 //----------------------------------------------------------------------------
4456 // Start Files
4457 //----------------------------------------------------------------------------
4458 if (incStdLib && incStartFiles) {
4459
4460 if (!buildingLib) {
4461 if (hasStandalone) {
4462 CmdArgs.push_back(
4463 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4464 }
4465 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4466 }
4467 std::string initObj = useShared ? "/initS.o" : "/init.o";
4468 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4469 }
4470
4471 //----------------------------------------------------------------------------
4472 // Library Search Paths
4473 //----------------------------------------------------------------------------
4474 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4475 for (ToolChain::path_list::const_iterator
4476 i = LibPaths.begin(),
4477 e = LibPaths.end();
4478 i != e;
4479 ++i)
4480 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4481
4482 //----------------------------------------------------------------------------
4483 //
4484 //----------------------------------------------------------------------------
4485 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4486 Args.AddAllArgs(CmdArgs, options::OPT_e);
4487 Args.AddAllArgs(CmdArgs, options::OPT_s);
4488 Args.AddAllArgs(CmdArgs, options::OPT_t);
4489 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4490
4491 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4492
4493 //----------------------------------------------------------------------------
4494 // Libraries
4495 //----------------------------------------------------------------------------
4496 if (incStdLib && incDefLibs) {
4497 if (D.CCCIsCXX()) {
4498 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4499 CmdArgs.push_back("-lm");
4500 }
4501
4502 CmdArgs.push_back("--start-group");
4503
4504 if (!buildingLib) {
4505 for(std::vector<std::string>::iterator i = oslibs.begin(),
4506 e = oslibs.end(); i != e; ++i)
4507 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4508 CmdArgs.push_back("-lc");
4509 }
4510 CmdArgs.push_back("-lgcc");
4511
4512 CmdArgs.push_back("--end-group");
4513 }
4514
4515 //----------------------------------------------------------------------------
4516 // End files
4517 //----------------------------------------------------------------------------
4518 if (incStdLib && incStartFiles) {
4519 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4520 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4521 }
4522
4523 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4524 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
4525}
4526// Hexagon tools end.
4527
4528llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4529 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4530 // archs which Darwin doesn't use.
4531
4532 // The matching this routine does is fairly pointless, since it is neither the
4533 // complete architecture list, nor a reasonable subset. The problem is that
4534 // historically the driver driver accepts this and also ties its -march=
4535 // handling to the architecture name, so we need to be careful before removing
4536 // support for it.
4537
4538 // This code must be kept in sync with Clang's Darwin specific argument
4539 // translation.
4540
4541 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4542 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4543 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4544 .Case("ppc64", llvm::Triple::ppc64)
4545 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4546 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4547 llvm::Triple::x86)
4548 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
4549 // This is derived from the driver driver.
4550 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4551 .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4552 .Cases("armv7s", "xscale", llvm::Triple::arm)
4553 .Case("r600", llvm::Triple::r600)
4554 .Case("nvptx", llvm::Triple::nvptx)
4555 .Case("nvptx64", llvm::Triple::nvptx64)
4556 .Case("amdil", llvm::Triple::amdil)
4557 .Case("spir", llvm::Triple::spir)
4558 .Default(llvm::Triple::UnknownArch);
4559}
4560
4561const char *Clang::getBaseInputName(const ArgList &Args,
4562 const InputInfoList &Inputs) {
4563 return Args.MakeArgString(
4564 llvm::sys::path::filename(Inputs[0].getBaseInput()));
4565}
4566
4567const char *Clang::getBaseInputStem(const ArgList &Args,
4568 const InputInfoList &Inputs) {
4569 const char *Str = getBaseInputName(Args, Inputs);
4570
4571 if (const char *End = strrchr(Str, '.'))
4572 return Args.MakeArgString(std::string(Str, End));
4573
4574 return Str;
4575}
4576
4577const char *Clang::getDependencyFileName(const ArgList &Args,
4578 const InputInfoList &Inputs) {
4579 // FIXME: Think about this more.
4580 std::string Res;
4581
4582 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4583 std::string Str(OutputOpt->getValue());
4584 Res = Str.substr(0, Str.rfind('.'));
4585 } else {
4586 Res = getBaseInputStem(Args, Inputs);
4587 }
4588 return Args.MakeArgString(Res + ".d");
4589}
4590
4591void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4592 const InputInfo &Output,
4593 const InputInfoList &Inputs,
4594 const ArgList &Args,
4595 const char *LinkingOutput) const {
4596 ArgStringList CmdArgs;
4597
4598 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4599 const InputInfo &Input = Inputs[0];
4600
4601 // Determine the original source input.
4602 const Action *SourceAction = &JA;
4603 while (SourceAction->getKind() != Action::InputClass) {
4604 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4605 SourceAction = SourceAction->getInputs()[0];
4606 }
4607
4608 // If -no_integrated_as is used add -Q to the darwin assember driver to make
4609 // sure it runs its system assembler not clang's integrated assembler.
|
4617 if (Args.hasArg(options::OPT_no_integrated_as))
4618 CmdArgs.push_back("-Q");
| 4610 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
4611 // FIXME: at run-time detect assembler capabilities or rely on version
4612 // information forwarded by -target-assembler-version (future)
4613 if (Args.hasArg(options::OPT_no_integrated_as)) {
4614 const llvm::Triple& t(getToolChain().getTriple());
4615 if (!(t.isMacOSX() && t.isMacOSXVersionLT(10, 7)))
4616 CmdArgs.push_back("-Q");
4617 }
|
4619
4620 // Forward -g, assuming we are dealing with an actual assembly file.
4621 if (SourceAction->getType() == types::TY_Asm ||
4622 SourceAction->getType() == types::TY_PP_Asm) {
4623 if (Args.hasArg(options::OPT_gstabs))
4624 CmdArgs.push_back("--gstabs");
4625 else if (Args.hasArg(options::OPT_g_Group))
4626 CmdArgs.push_back("-g");
4627 }
4628
4629 // Derived from asm spec.
4630 AddDarwinArch(Args, CmdArgs);
4631
4632 // Use -force_cpusubtype_ALL on x86 by default.
4633 if (getToolChain().getArch() == llvm::Triple::x86 ||
4634 getToolChain().getArch() == llvm::Triple::x86_64 ||
4635 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4636 CmdArgs.push_back("-force_cpusubtype_ALL");
4637
4638 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
4639 (((Args.hasArg(options::OPT_mkernel) ||
4640 Args.hasArg(options::OPT_fapple_kext)) &&
4641 (!getDarwinToolChain().isTargetIPhoneOS() ||
4642 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4643 Args.hasArg(options::OPT_static)))
4644 CmdArgs.push_back("-static");
4645
4646 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4647 options::OPT_Xassembler);
4648
4649 assert(Output.isFilename() && "Unexpected lipo output.");
4650 CmdArgs.push_back("-o");
4651 CmdArgs.push_back(Output.getFilename());
4652
4653 assert(Input.isFilename() && "Invalid input.");
4654 CmdArgs.push_back(Input.getFilename());
4655
4656 // asm_final spec is empty.
4657
4658 const char *Exec =
4659 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4660 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4661}
4662
4663void darwin::DarwinTool::anchor() {}
4664
4665void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4666 ArgStringList &CmdArgs) const {
4667 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4668
4669 // Derived from darwin_arch spec.
4670 CmdArgs.push_back("-arch");
4671 CmdArgs.push_back(Args.MakeArgString(ArchName));
4672
4673 // FIXME: Is this needed anymore?
4674 if (ArchName == "arm")
4675 CmdArgs.push_back("-force_cpusubtype_ALL");
4676}
4677
4678bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4679 // We only need to generate a temp path for LTO if we aren't compiling object
4680 // files. When compiling source files, we run 'dsymutil' after linking. We
4681 // don't run 'dsymutil' when compiling object files.
4682 for (InputInfoList::const_iterator
4683 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4684 if (it->getType() != types::TY_Object)
4685 return true;
4686
4687 return false;
4688}
4689
4690void darwin::Link::AddLinkArgs(Compilation &C,
4691 const ArgList &Args,
4692 ArgStringList &CmdArgs,
4693 const InputInfoList &Inputs) const {
4694 const Driver &D = getToolChain().getDriver();
4695 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4696
4697 unsigned Version[3] = { 0, 0, 0 };
4698 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4699 bool HadExtra;
4700 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4701 Version[1], Version[2], HadExtra) ||
4702 HadExtra)
4703 D.Diag(diag::err_drv_invalid_version_number)
4704 << A->getAsString(Args);
4705 }
4706
4707 // Newer linkers support -demangle, pass it if supported and not disabled by
4708 // the user.
4709 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4710 // Don't pass -demangle to ld_classic.
4711 //
4712 // FIXME: This is a temporary workaround, ld should be handling this.
4713 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4714 Args.hasArg(options::OPT_static));
4715 if (getToolChain().getArch() == llvm::Triple::x86) {
4716 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4717 options::OPT_Wl_COMMA),
4718 ie = Args.filtered_end(); it != ie; ++it) {
4719 const Arg *A = *it;
4720 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4721 if (StringRef(A->getValue(i)) == "-kext")
4722 UsesLdClassic = true;
4723 }
4724 }
4725 if (!UsesLdClassic)
4726 CmdArgs.push_back("-demangle");
4727 }
4728
4729 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4730 CmdArgs.push_back("-export_dynamic");
4731
4732 // If we are using LTO, then automatically create a temporary file path for
4733 // the linker to use, so that it's lifetime will extend past a possible
4734 // dsymutil step.
4735 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4736 const char *TmpPath = C.getArgs().MakeArgString(
4737 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4738 C.addTempFile(TmpPath);
4739 CmdArgs.push_back("-object_path_lto");
4740 CmdArgs.push_back(TmpPath);
4741 }
4742
4743 // Derived from the "link" spec.
4744 Args.AddAllArgs(CmdArgs, options::OPT_static);
4745 if (!Args.hasArg(options::OPT_static))
4746 CmdArgs.push_back("-dynamic");
4747 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4748 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4749 // here. How do we wish to handle such things?
4750 }
4751
4752 if (!Args.hasArg(options::OPT_dynamiclib)) {
4753 AddDarwinArch(Args, CmdArgs);
4754 // FIXME: Why do this only on this path?
4755 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4756
4757 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4758 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4759 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4760
4761 Arg *A;
4762 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4763 (A = Args.getLastArg(options::OPT_current__version)) ||
4764 (A = Args.getLastArg(options::OPT_install__name)))
4765 D.Diag(diag::err_drv_argument_only_allowed_with)
4766 << A->getAsString(Args) << "-dynamiclib";
4767
4768 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4769 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4770 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4771 } else {
4772 CmdArgs.push_back("-dylib");
4773
4774 Arg *A;
4775 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4776 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4777 (A = Args.getLastArg(options::OPT_client__name)) ||
4778 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4779 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4780 (A = Args.getLastArg(options::OPT_private__bundle)))
4781 D.Diag(diag::err_drv_argument_not_allowed_with)
4782 << A->getAsString(Args) << "-dynamiclib";
4783
4784 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4785 "-dylib_compatibility_version");
4786 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4787 "-dylib_current_version");
4788
4789 AddDarwinArch(Args, CmdArgs);
4790
4791 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4792 "-dylib_install_name");
4793 }
4794
4795 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4796 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4797 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4798 if (DarwinTC.isTargetIPhoneOS())
4799 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4800 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4801 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4802 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4803 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4804 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4805 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4806 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4807 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4808 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4809 Args.AddAllArgs(CmdArgs, options::OPT_init);
4810
4811 // Add the deployment target.
4812 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4813
4814 // If we had an explicit -mios-simulator-version-min argument, honor that,
4815 // otherwise use the traditional deployment targets. We can't just check the
4816 // is-sim attribute because existing code follows this path, and the linker
4817 // may not handle the argument.
4818 //
4819 // FIXME: We may be able to remove this, once we can verify no one depends on
4820 // it.
4821 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4822 CmdArgs.push_back("-ios_simulator_version_min");
4823 else if (DarwinTC.isTargetIPhoneOS())
4824 CmdArgs.push_back("-iphoneos_version_min");
4825 else
4826 CmdArgs.push_back("-macosx_version_min");
4827 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4828
4829 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4830 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4831 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4832 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4833 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4834
4835 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4836 options::OPT_fno_pie,
4837 options::OPT_fno_PIE)) {
4838 if (A->getOption().matches(options::OPT_fpie) ||
4839 A->getOption().matches(options::OPT_fPIE))
4840 CmdArgs.push_back("-pie");
4841 else
4842 CmdArgs.push_back("-no_pie");
4843 }
4844
4845 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4846 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4847 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4848 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4849 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4850 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4851 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4852 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4853 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4854 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4855 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4856 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4857 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4858 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4859 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4860 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4861
4862 // Give --sysroot= preference, over the Apple specific behavior to also use
4863 // --isysroot as the syslibroot.
4864 StringRef sysroot = C.getSysRoot();
4865 if (sysroot != "") {
4866 CmdArgs.push_back("-syslibroot");
4867 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4868 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4869 CmdArgs.push_back("-syslibroot");
4870 CmdArgs.push_back(A->getValue());
4871 }
4872
4873 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4874 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4875 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4876 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4877 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4878 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4879 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4880 Args.AddAllArgs(CmdArgs, options::OPT_y);
4881 Args.AddLastArg(CmdArgs, options::OPT_w);
4882 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4883 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4884 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4885 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4886 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4887 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4888 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4889 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4890 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4891 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4892 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4893 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4894}
4895
4896void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4897 const InputInfo &Output,
4898 const InputInfoList &Inputs,
4899 const ArgList &Args,
4900 const char *LinkingOutput) const {
4901 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4902
4903 // The logic here is derived from gcc's behavior; most of which
4904 // comes from specs (starting with link_command). Consult gcc for
4905 // more information.
4906 ArgStringList CmdArgs;
4907
4908 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4909 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4910 options::OPT_ccc_arcmt_migrate)) {
4911 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4912 (*I)->claim();
4913 const char *Exec =
4914 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4915 CmdArgs.push_back(Output.getFilename());
4916 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4917 return;
4918 }
4919
4920 // I'm not sure why this particular decomposition exists in gcc, but
4921 // we follow suite for ease of comparison.
4922 AddLinkArgs(C, Args, CmdArgs, Inputs);
4923
4924 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4925 Args.AddAllArgs(CmdArgs, options::OPT_s);
4926 Args.AddAllArgs(CmdArgs, options::OPT_t);
4927 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4928 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4929 Args.AddLastArg(CmdArgs, options::OPT_e);
4930 Args.AddAllArgs(CmdArgs, options::OPT_r);
4931
4932 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4933 // members of static archive libraries which implement Objective-C classes or
4934 // categories.
4935 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4936 CmdArgs.push_back("-ObjC");
4937
4938 CmdArgs.push_back("-o");
4939 CmdArgs.push_back(Output.getFilename());
4940
4941 if (!Args.hasArg(options::OPT_nostdlib) &&
4942 !Args.hasArg(options::OPT_nostartfiles)) {
4943 // Derived from startfile spec.
4944 if (Args.hasArg(options::OPT_dynamiclib)) {
4945 // Derived from darwin_dylib1 spec.
4946 if (getDarwinToolChain().isTargetIOSSimulator()) {
4947 // The simulator doesn't have a versioned crt1 file.
4948 CmdArgs.push_back("-ldylib1.o");
4949 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4950 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4951 CmdArgs.push_back("-ldylib1.o");
4952 } else {
4953 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4954 CmdArgs.push_back("-ldylib1.o");
4955 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4956 CmdArgs.push_back("-ldylib1.10.5.o");
4957 }
4958 } else {
4959 if (Args.hasArg(options::OPT_bundle)) {
4960 if (!Args.hasArg(options::OPT_static)) {
4961 // Derived from darwin_bundle1 spec.
4962 if (getDarwinToolChain().isTargetIOSSimulator()) {
4963 // The simulator doesn't have a versioned crt1 file.
4964 CmdArgs.push_back("-lbundle1.o");
4965 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4966 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4967 CmdArgs.push_back("-lbundle1.o");
4968 } else {
4969 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4970 CmdArgs.push_back("-lbundle1.o");
4971 }
4972 }
4973 } else {
4974 if (Args.hasArg(options::OPT_pg) &&
4975 getToolChain().SupportsProfiling()) {
4976 if (Args.hasArg(options::OPT_static) ||
4977 Args.hasArg(options::OPT_object) ||
4978 Args.hasArg(options::OPT_preload)) {
4979 CmdArgs.push_back("-lgcrt0.o");
4980 } else {
4981 CmdArgs.push_back("-lgcrt1.o");
4982
4983 // darwin_crt2 spec is empty.
4984 }
4985 // By default on OS X 10.8 and later, we don't link with a crt1.o
4986 // file and the linker knows to use _main as the entry point. But,
4987 // when compiling with -pg, we need to link with the gcrt1.o file,
4988 // so pass the -no_new_main option to tell the linker to use the
4989 // "start" symbol as the entry point.
4990 if (getDarwinToolChain().isTargetMacOS() &&
4991 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4992 CmdArgs.push_back("-no_new_main");
4993 } else {
4994 if (Args.hasArg(options::OPT_static) ||
4995 Args.hasArg(options::OPT_object) ||
4996 Args.hasArg(options::OPT_preload)) {
4997 CmdArgs.push_back("-lcrt0.o");
4998 } else {
4999 // Derived from darwin_crt1 spec.
5000 if (getDarwinToolChain().isTargetIOSSimulator()) {
5001 // The simulator doesn't have a versioned crt1 file.
5002 CmdArgs.push_back("-lcrt1.o");
5003 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
5004 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
5005 CmdArgs.push_back("-lcrt1.o");
5006 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
5007 CmdArgs.push_back("-lcrt1.3.1.o");
5008 } else {
5009 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
5010 CmdArgs.push_back("-lcrt1.o");
5011 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
5012 CmdArgs.push_back("-lcrt1.10.5.o");
5013 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
5014 CmdArgs.push_back("-lcrt1.10.6.o");
5015
5016 // darwin_crt2 spec is empty.
5017 }
5018 }
5019 }
5020 }
5021 }
5022
5023 if (!getDarwinToolChain().isTargetIPhoneOS() &&
5024 Args.hasArg(options::OPT_shared_libgcc) &&
5025 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
5026 const char *Str =
5027 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
5028 CmdArgs.push_back(Str);
5029 }
5030 }
5031
5032 Args.AddAllArgs(CmdArgs, options::OPT_L);
5033
5034 if (Args.hasArg(options::OPT_fopenmp))
5035 // This is more complicated in gcc...
5036 CmdArgs.push_back("-lgomp");
5037
5038 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5039
5040 if (isObjCRuntimeLinked(Args) &&
5041 !Args.hasArg(options::OPT_nostdlib) &&
5042 !Args.hasArg(options::OPT_nodefaultlibs)) {
5043 // Avoid linking compatibility stubs on i386 mac.
5044 if (!getDarwinToolChain().isTargetMacOS() ||
5045 getDarwinToolChain().getArch() != llvm::Triple::x86) {
5046 // If we don't have ARC or subscripting runtime support, link in the
5047 // runtime stubs. We have to do this *before* adding any of the normal
5048 // linker inputs so that its initializer gets run first.
5049 ObjCRuntime runtime =
5050 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
5051 // We use arclite library for both ARC and subscripting support.
5052 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
5053 !runtime.hasSubscripting())
5054 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
5055 }
5056 CmdArgs.push_back("-framework");
5057 CmdArgs.push_back("Foundation");
5058 // Link libobj.
5059 CmdArgs.push_back("-lobjc");
5060 }
5061
5062 if (LinkingOutput) {
5063 CmdArgs.push_back("-arch_multiple");
5064 CmdArgs.push_back("-final_output");
5065 CmdArgs.push_back(LinkingOutput);
5066 }
5067
5068 if (Args.hasArg(options::OPT_fnested_functions))
5069 CmdArgs.push_back("-allow_stack_execute");
5070
5071 if (!Args.hasArg(options::OPT_nostdlib) &&
5072 !Args.hasArg(options::OPT_nodefaultlibs)) {
5073 if (getToolChain().getDriver().CCCIsCXX())
5074 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5075
5076 // link_ssp spec is empty.
5077
5078 // Let the tool chain choose which runtime library to link.
5079 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5080 }
5081
5082 if (!Args.hasArg(options::OPT_nostdlib) &&
5083 !Args.hasArg(options::OPT_nostartfiles)) {
5084 // endfile_spec is empty.
5085 }
5086
5087 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5088 Args.AddAllArgs(CmdArgs, options::OPT_F);
5089
5090 const char *Exec =
5091 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5092 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5093}
5094
5095void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
5096 const InputInfo &Output,
5097 const InputInfoList &Inputs,
5098 const ArgList &Args,
5099 const char *LinkingOutput) const {
5100 ArgStringList CmdArgs;
5101
5102 CmdArgs.push_back("-create");
5103 assert(Output.isFilename() && "Unexpected lipo output.");
5104
5105 CmdArgs.push_back("-output");
5106 CmdArgs.push_back(Output.getFilename());
5107
5108 for (InputInfoList::const_iterator
5109 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5110 const InputInfo &II = *it;
5111 assert(II.isFilename() && "Unexpected lipo input.");
5112 CmdArgs.push_back(II.getFilename());
5113 }
5114 const char *Exec =
5115 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5116 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5117}
5118
5119void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
5120 const InputInfo &Output,
5121 const InputInfoList &Inputs,
5122 const ArgList &Args,
5123 const char *LinkingOutput) const {
5124 ArgStringList CmdArgs;
5125
5126 CmdArgs.push_back("-o");
5127 CmdArgs.push_back(Output.getFilename());
5128
5129 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5130 const InputInfo &Input = Inputs[0];
5131 assert(Input.isFilename() && "Unexpected dsymutil input.");
5132 CmdArgs.push_back(Input.getFilename());
5133
5134 const char *Exec =
5135 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5136 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5137}
5138
5139void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
5140 const InputInfo &Output,
5141 const InputInfoList &Inputs,
5142 const ArgList &Args,
5143 const char *LinkingOutput) const {
5144 ArgStringList CmdArgs;
5145 CmdArgs.push_back("--verify");
5146 CmdArgs.push_back("--debug-info");
5147 CmdArgs.push_back("--eh-frame");
5148 CmdArgs.push_back("--quiet");
5149
5150 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5151 const InputInfo &Input = Inputs[0];
5152 assert(Input.isFilename() && "Unexpected verify input");
5153
5154 // Grabbing the output of the earlier dsymutil run.
5155 CmdArgs.push_back(Input.getFilename());
5156
5157 const char *Exec =
5158 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5159 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5160}
5161
5162void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5163 const InputInfo &Output,
5164 const InputInfoList &Inputs,
5165 const ArgList &Args,
5166 const char *LinkingOutput) const {
5167 ArgStringList CmdArgs;
5168
5169 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5170 options::OPT_Xassembler);
5171
5172 CmdArgs.push_back("-o");
5173 CmdArgs.push_back(Output.getFilename());
5174
5175 for (InputInfoList::const_iterator
5176 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5177 const InputInfo &II = *it;
5178 CmdArgs.push_back(II.getFilename());
5179 }
5180
5181 const char *Exec =
5182 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5183 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5184}
5185
5186
5187void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5188 const InputInfo &Output,
5189 const InputInfoList &Inputs,
5190 const ArgList &Args,
5191 const char *LinkingOutput) const {
5192 // FIXME: Find a real GCC, don't hard-code versions here
5193 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5194 const llvm::Triple &T = getToolChain().getTriple();
5195 std::string LibPath = "/usr/lib/";
5196 llvm::Triple::ArchType Arch = T.getArch();
5197 switch (Arch) {
5198 case llvm::Triple::x86:
5199 GCCLibPath +=
5200 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5201 break;
5202 case llvm::Triple::x86_64:
5203 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5204 GCCLibPath += "/4.5.2/amd64/";
5205 LibPath += "amd64/";
5206 break;
5207 default:
5208 llvm_unreachable("Unsupported architecture");
5209 }
5210
5211 ArgStringList CmdArgs;
5212
5213 // Demangle C++ names in errors
5214 CmdArgs.push_back("-C");
5215
5216 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5217 (!Args.hasArg(options::OPT_shared))) {
5218 CmdArgs.push_back("-e");
5219 CmdArgs.push_back("_start");
5220 }
5221
5222 if (Args.hasArg(options::OPT_static)) {
5223 CmdArgs.push_back("-Bstatic");
5224 CmdArgs.push_back("-dn");
5225 } else {
5226 CmdArgs.push_back("-Bdynamic");
5227 if (Args.hasArg(options::OPT_shared)) {
5228 CmdArgs.push_back("-shared");
5229 } else {
5230 CmdArgs.push_back("--dynamic-linker");
5231 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5232 }
5233 }
5234
5235 if (Output.isFilename()) {
5236 CmdArgs.push_back("-o");
5237 CmdArgs.push_back(Output.getFilename());
5238 } else {
5239 assert(Output.isNothing() && "Invalid output.");
5240 }
5241
5242 if (!Args.hasArg(options::OPT_nostdlib) &&
5243 !Args.hasArg(options::OPT_nostartfiles)) {
5244 if (!Args.hasArg(options::OPT_shared)) {
5245 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5246 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5247 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5248 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5249 } else {
5250 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5251 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5252 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5253 }
5254 if (getToolChain().getDriver().CCCIsCXX())
5255 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5256 }
5257
5258 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5259
5260 Args.AddAllArgs(CmdArgs, options::OPT_L);
5261 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5262 Args.AddAllArgs(CmdArgs, options::OPT_e);
5263 Args.AddAllArgs(CmdArgs, options::OPT_r);
5264
5265 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5266
5267 if (!Args.hasArg(options::OPT_nostdlib) &&
5268 !Args.hasArg(options::OPT_nodefaultlibs)) {
5269 if (getToolChain().getDriver().CCCIsCXX())
5270 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5271 CmdArgs.push_back("-lgcc_s");
5272 if (!Args.hasArg(options::OPT_shared)) {
5273 CmdArgs.push_back("-lgcc");
5274 CmdArgs.push_back("-lc");
5275 CmdArgs.push_back("-lm");
5276 }
5277 }
5278
5279 if (!Args.hasArg(options::OPT_nostdlib) &&
5280 !Args.hasArg(options::OPT_nostartfiles)) {
5281 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5282 }
5283 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5284
5285 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5286
5287 const char *Exec =
5288 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5289 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5290}
5291
5292void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5293 const InputInfo &Output,
5294 const InputInfoList &Inputs,
5295 const ArgList &Args,
5296 const char *LinkingOutput) const {
5297 ArgStringList CmdArgs;
5298
5299 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5300 options::OPT_Xassembler);
5301
5302 CmdArgs.push_back("-o");
5303 CmdArgs.push_back(Output.getFilename());
5304
5305 for (InputInfoList::const_iterator
5306 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5307 const InputInfo &II = *it;
5308 CmdArgs.push_back(II.getFilename());
5309 }
5310
5311 const char *Exec =
5312 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5313 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5314}
5315
5316void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
5317 const InputInfo &Output,
5318 const InputInfoList &Inputs,
5319 const ArgList &Args,
5320 const char *LinkingOutput) const {
5321 ArgStringList CmdArgs;
5322
5323 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5324 (!Args.hasArg(options::OPT_shared))) {
5325 CmdArgs.push_back("-e");
5326 CmdArgs.push_back("_start");
5327 }
5328
5329 if (Args.hasArg(options::OPT_static)) {
5330 CmdArgs.push_back("-Bstatic");
5331 CmdArgs.push_back("-dn");
5332 } else {
5333// CmdArgs.push_back("--eh-frame-hdr");
5334 CmdArgs.push_back("-Bdynamic");
5335 if (Args.hasArg(options::OPT_shared)) {
5336 CmdArgs.push_back("-shared");
5337 } else {
5338 CmdArgs.push_back("--dynamic-linker");
5339 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5340 }
5341 }
5342
5343 if (Output.isFilename()) {
5344 CmdArgs.push_back("-o");
5345 CmdArgs.push_back(Output.getFilename());
5346 } else {
5347 assert(Output.isNothing() && "Invalid output.");
5348 }
5349
5350 if (!Args.hasArg(options::OPT_nostdlib) &&
5351 !Args.hasArg(options::OPT_nostartfiles)) {
5352 if (!Args.hasArg(options::OPT_shared)) {
5353 CmdArgs.push_back(Args.MakeArgString(
5354 getToolChain().GetFilePath("crt1.o")));
5355 CmdArgs.push_back(Args.MakeArgString(
5356 getToolChain().GetFilePath("crti.o")));
5357 CmdArgs.push_back(Args.MakeArgString(
5358 getToolChain().GetFilePath("crtbegin.o")));
5359 } else {
5360 CmdArgs.push_back(Args.MakeArgString(
5361 getToolChain().GetFilePath("crti.o")));
5362 }
5363 CmdArgs.push_back(Args.MakeArgString(
5364 getToolChain().GetFilePath("crtn.o")));
5365 }
5366
5367 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5368 + getToolChain().getTripleString()
5369 + "/4.2.4"));
5370
5371 Args.AddAllArgs(CmdArgs, options::OPT_L);
5372 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5373 Args.AddAllArgs(CmdArgs, options::OPT_e);
5374
5375 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5376
5377 if (!Args.hasArg(options::OPT_nostdlib) &&
5378 !Args.hasArg(options::OPT_nodefaultlibs)) {
5379 // FIXME: For some reason GCC passes -lgcc before adding
5380 // the default system libraries. Just mimic this for now.
5381 CmdArgs.push_back("-lgcc");
5382
5383 if (Args.hasArg(options::OPT_pthread))
5384 CmdArgs.push_back("-pthread");
5385 if (!Args.hasArg(options::OPT_shared))
5386 CmdArgs.push_back("-lc");
5387 CmdArgs.push_back("-lgcc");
5388 }
5389
5390 if (!Args.hasArg(options::OPT_nostdlib) &&
5391 !Args.hasArg(options::OPT_nostartfiles)) {
5392 if (!Args.hasArg(options::OPT_shared))
5393 CmdArgs.push_back(Args.MakeArgString(
5394 getToolChain().GetFilePath("crtend.o")));
5395 }
5396
5397 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5398
5399 const char *Exec =
5400 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5401 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5402}
5403
5404void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5405 const InputInfo &Output,
5406 const InputInfoList &Inputs,
5407 const ArgList &Args,
5408 const char *LinkingOutput) const {
5409 ArgStringList CmdArgs;
5410
5411 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5412 // instruct as in the base system to assemble 32-bit code.
5413 if (getToolChain().getArch() == llvm::Triple::x86)
5414 CmdArgs.push_back("--32");
5415 else if (getToolChain().getArch() == llvm::Triple::ppc) {
5416 CmdArgs.push_back("-mppc");
5417 CmdArgs.push_back("-many");
5418 } else if (getToolChain().getArch() == llvm::Triple::mips64 ||
5419 getToolChain().getArch() == llvm::Triple::mips64el) {
5420 StringRef CPUName;
5421 StringRef ABIName;
5422 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5423
5424 CmdArgs.push_back("-mabi");
5425 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5426
5427 if (getToolChain().getArch() == llvm::Triple::mips64)
5428 CmdArgs.push_back("-EB");
5429 else
5430 CmdArgs.push_back("-EL");
5431
5432 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5433 options::OPT_fpic, options::OPT_fno_pic,
5434 options::OPT_fPIE, options::OPT_fno_PIE,
5435 options::OPT_fpie, options::OPT_fno_pie);
5436 if (LastPICArg &&
5437 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5438 LastPICArg->getOption().matches(options::OPT_fpic) ||
5439 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5440 LastPICArg->getOption().matches(options::OPT_fpie))) {
5441 CmdArgs.push_back("-KPIC");
5442 }
5443 }
5444
5445 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5446 options::OPT_Xassembler);
5447
5448 CmdArgs.push_back("-o");
5449 CmdArgs.push_back(Output.getFilename());
5450
5451 for (InputInfoList::const_iterator
5452 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5453 const InputInfo &II = *it;
5454 CmdArgs.push_back(II.getFilename());
5455 }
5456
5457 const char *Exec =
5458 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5459 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5460}
5461
5462void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5463 const InputInfo &Output,
5464 const InputInfoList &Inputs,
5465 const ArgList &Args,
5466 const char *LinkingOutput) const {
5467 const Driver &D = getToolChain().getDriver();
5468 ArgStringList CmdArgs;
5469
5470 // Silence warning for "clang -g foo.o -o foo"
5471 Args.ClaimAllArgs(options::OPT_g_Group);
5472 // and "clang -emit-llvm foo.o -o foo"
5473 Args.ClaimAllArgs(options::OPT_emit_llvm);
5474 // and for "clang -w foo.o -o foo". Other warning options are already
5475 // handled somewhere else.
5476 Args.ClaimAllArgs(options::OPT_w);
5477
5478 if (getToolChain().getArch() == llvm::Triple::mips64)
5479 CmdArgs.push_back("-EB");
5480 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5481 CmdArgs.push_back("-EL");
5482
5483 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5484 (!Args.hasArg(options::OPT_shared))) {
5485 CmdArgs.push_back("-e");
5486 CmdArgs.push_back("__start");
5487 }
5488
5489 if (Args.hasArg(options::OPT_static)) {
5490 CmdArgs.push_back("-Bstatic");
5491 } else {
5492 if (Args.hasArg(options::OPT_rdynamic))
5493 CmdArgs.push_back("-export-dynamic");
5494 CmdArgs.push_back("--eh-frame-hdr");
5495 CmdArgs.push_back("-Bdynamic");
5496 if (Args.hasArg(options::OPT_shared)) {
5497 CmdArgs.push_back("-shared");
5498 } else {
5499 CmdArgs.push_back("-dynamic-linker");
5500 CmdArgs.push_back("/usr/libexec/ld.so");
5501 }
5502 }
5503
5504 if (Args.hasArg(options::OPT_nopie))
5505 CmdArgs.push_back("-nopie");
5506
5507 if (Output.isFilename()) {
5508 CmdArgs.push_back("-o");
5509 CmdArgs.push_back(Output.getFilename());
5510 } else {
5511 assert(Output.isNothing() && "Invalid output.");
5512 }
5513
5514 if (!Args.hasArg(options::OPT_nostdlib) &&
5515 !Args.hasArg(options::OPT_nostartfiles)) {
5516 if (!Args.hasArg(options::OPT_shared)) {
5517 if (Args.hasArg(options::OPT_pg))
5518 CmdArgs.push_back(Args.MakeArgString(
5519 getToolChain().GetFilePath("gcrt0.o")));
5520 else
5521 CmdArgs.push_back(Args.MakeArgString(
5522 getToolChain().GetFilePath("crt0.o")));
5523 CmdArgs.push_back(Args.MakeArgString(
5524 getToolChain().GetFilePath("crtbegin.o")));
5525 } else {
5526 CmdArgs.push_back(Args.MakeArgString(
5527 getToolChain().GetFilePath("crtbeginS.o")));
5528 }
5529 }
5530
5531 std::string Triple = getToolChain().getTripleString();
5532 if (Triple.substr(0, 6) == "x86_64")
5533 Triple.replace(0, 6, "amd64");
5534 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
5535 "/4.2.1"));
5536
5537 Args.AddAllArgs(CmdArgs, options::OPT_L);
5538 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5539 Args.AddAllArgs(CmdArgs, options::OPT_e);
5540 Args.AddAllArgs(CmdArgs, options::OPT_s);
5541 Args.AddAllArgs(CmdArgs, options::OPT_t);
5542 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5543 Args.AddAllArgs(CmdArgs, options::OPT_r);
5544
5545 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5546
5547 if (!Args.hasArg(options::OPT_nostdlib) &&
5548 !Args.hasArg(options::OPT_nodefaultlibs)) {
5549 if (D.CCCIsCXX()) {
5550 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5551 if (Args.hasArg(options::OPT_pg))
5552 CmdArgs.push_back("-lm_p");
5553 else
5554 CmdArgs.push_back("-lm");
5555 }
5556
5557 // FIXME: For some reason GCC passes -lgcc before adding
5558 // the default system libraries. Just mimic this for now.
5559 CmdArgs.push_back("-lgcc");
5560
5561 if (Args.hasArg(options::OPT_pthread)) {
5562 if (!Args.hasArg(options::OPT_shared) &&
5563 Args.hasArg(options::OPT_pg))
5564 CmdArgs.push_back("-lpthread_p");
5565 else
5566 CmdArgs.push_back("-lpthread");
5567 }
5568
5569 if (!Args.hasArg(options::OPT_shared)) {
5570 if (Args.hasArg(options::OPT_pg))
5571 CmdArgs.push_back("-lc_p");
5572 else
5573 CmdArgs.push_back("-lc");
5574 }
5575
5576 CmdArgs.push_back("-lgcc");
5577 }
5578
5579 if (!Args.hasArg(options::OPT_nostdlib) &&
5580 !Args.hasArg(options::OPT_nostartfiles)) {
5581 if (!Args.hasArg(options::OPT_shared))
5582 CmdArgs.push_back(Args.MakeArgString(
5583 getToolChain().GetFilePath("crtend.o")));
5584 else
5585 CmdArgs.push_back(Args.MakeArgString(
5586 getToolChain().GetFilePath("crtendS.o")));
5587 }
5588
5589 const char *Exec =
5590 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5591 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5592}
5593
5594void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5595 const InputInfo &Output,
5596 const InputInfoList &Inputs,
5597 const ArgList &Args,
5598 const char *LinkingOutput) const {
5599 ArgStringList CmdArgs;
5600
5601 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5602 options::OPT_Xassembler);
5603
5604 CmdArgs.push_back("-o");
5605 CmdArgs.push_back(Output.getFilename());
5606
5607 for (InputInfoList::const_iterator
5608 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5609 const InputInfo &II = *it;
5610 CmdArgs.push_back(II.getFilename());
5611 }
5612
5613 const char *Exec =
5614 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5615 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5616}
5617
5618void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5619 const InputInfo &Output,
5620 const InputInfoList &Inputs,
5621 const ArgList &Args,
5622 const char *LinkingOutput) const {
5623 const Driver &D = getToolChain().getDriver();
5624 ArgStringList CmdArgs;
5625
5626 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5627 (!Args.hasArg(options::OPT_shared))) {
5628 CmdArgs.push_back("-e");
5629 CmdArgs.push_back("__start");
5630 }
5631
5632 if (Args.hasArg(options::OPT_static)) {
5633 CmdArgs.push_back("-Bstatic");
5634 } else {
5635 if (Args.hasArg(options::OPT_rdynamic))
5636 CmdArgs.push_back("-export-dynamic");
5637 CmdArgs.push_back("--eh-frame-hdr");
5638 CmdArgs.push_back("-Bdynamic");
5639 if (Args.hasArg(options::OPT_shared)) {
5640 CmdArgs.push_back("-shared");
5641 } else {
5642 CmdArgs.push_back("-dynamic-linker");
5643 CmdArgs.push_back("/usr/libexec/ld.so");
5644 }
5645 }
5646
5647 if (Output.isFilename()) {
5648 CmdArgs.push_back("-o");
5649 CmdArgs.push_back(Output.getFilename());
5650 } else {
5651 assert(Output.isNothing() && "Invalid output.");
5652 }
5653
5654 if (!Args.hasArg(options::OPT_nostdlib) &&
5655 !Args.hasArg(options::OPT_nostartfiles)) {
5656 if (!Args.hasArg(options::OPT_shared)) {
5657 if (Args.hasArg(options::OPT_pg))
5658 CmdArgs.push_back(Args.MakeArgString(
5659 getToolChain().GetFilePath("gcrt0.o")));
5660 else
5661 CmdArgs.push_back(Args.MakeArgString(
5662 getToolChain().GetFilePath("crt0.o")));
5663 CmdArgs.push_back(Args.MakeArgString(
5664 getToolChain().GetFilePath("crtbegin.o")));
5665 } else {
5666 CmdArgs.push_back(Args.MakeArgString(
5667 getToolChain().GetFilePath("crtbeginS.o")));
5668 }
5669 }
5670
5671 Args.AddAllArgs(CmdArgs, options::OPT_L);
5672 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5673 Args.AddAllArgs(CmdArgs, options::OPT_e);
5674
5675 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5676
5677 if (!Args.hasArg(options::OPT_nostdlib) &&
5678 !Args.hasArg(options::OPT_nodefaultlibs)) {
5679 if (D.CCCIsCXX()) {
5680 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5681 if (Args.hasArg(options::OPT_pg))
5682 CmdArgs.push_back("-lm_p");
5683 else
5684 CmdArgs.push_back("-lm");
5685 }
5686
5687 if (Args.hasArg(options::OPT_pthread)) {
5688 if (!Args.hasArg(options::OPT_shared) &&
5689 Args.hasArg(options::OPT_pg))
5690 CmdArgs.push_back("-lpthread_p");
5691 else
5692 CmdArgs.push_back("-lpthread");
5693 }
5694
5695 if (!Args.hasArg(options::OPT_shared)) {
5696 if (Args.hasArg(options::OPT_pg))
5697 CmdArgs.push_back("-lc_p");
5698 else
5699 CmdArgs.push_back("-lc");
5700 }
5701
5702 StringRef MyArch;
5703 switch (getToolChain().getTriple().getArch()) {
5704 case llvm::Triple::arm:
5705 MyArch = "arm";
5706 break;
5707 case llvm::Triple::x86:
5708 MyArch = "i386";
5709 break;
5710 case llvm::Triple::x86_64:
5711 MyArch = "amd64";
5712 break;
5713 default:
5714 llvm_unreachable("Unsupported architecture");
5715 }
5716 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
5717 }
5718
5719 if (!Args.hasArg(options::OPT_nostdlib) &&
5720 !Args.hasArg(options::OPT_nostartfiles)) {
5721 if (!Args.hasArg(options::OPT_shared))
5722 CmdArgs.push_back(Args.MakeArgString(
5723 getToolChain().GetFilePath("crtend.o")));
5724 else
5725 CmdArgs.push_back(Args.MakeArgString(
5726 getToolChain().GetFilePath("crtendS.o")));
5727 }
5728
5729 const char *Exec =
5730 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5731 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5732}
5733
5734void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5735 const InputInfo &Output,
5736 const InputInfoList &Inputs,
5737 const ArgList &Args,
5738 const char *LinkingOutput) const {
5739 ArgStringList CmdArgs;
5740
5741 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5742 // instruct as in the base system to assemble 32-bit code.
5743 if (getToolChain().getArch() == llvm::Triple::x86)
5744 CmdArgs.push_back("--32");
5745 else if (getToolChain().getArch() == llvm::Triple::ppc)
5746 CmdArgs.push_back("-a32");
5747 else if (getToolChain().getArch() == llvm::Triple::mips ||
5748 getToolChain().getArch() == llvm::Triple::mipsel ||
5749 getToolChain().getArch() == llvm::Triple::mips64 ||
5750 getToolChain().getArch() == llvm::Triple::mips64el) {
5751 StringRef CPUName;
5752 StringRef ABIName;
5753 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5754
5755 CmdArgs.push_back("-march");
5756 CmdArgs.push_back(CPUName.data());
5757
5758 CmdArgs.push_back("-mabi");
5759 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5760
5761 if (getToolChain().getArch() == llvm::Triple::mips ||
5762 getToolChain().getArch() == llvm::Triple::mips64)
5763 CmdArgs.push_back("-EB");
5764 else
5765 CmdArgs.push_back("-EL");
5766
5767 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5768 options::OPT_fpic, options::OPT_fno_pic,
5769 options::OPT_fPIE, options::OPT_fno_PIE,
5770 options::OPT_fpie, options::OPT_fno_pie);
5771 if (LastPICArg &&
5772 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5773 LastPICArg->getOption().matches(options::OPT_fpic) ||
5774 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5775 LastPICArg->getOption().matches(options::OPT_fpie))) {
5776 CmdArgs.push_back("-KPIC");
5777 }
5778 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5779 getToolChain().getArch() == llvm::Triple::thumb) {
5780 CmdArgs.push_back("-mfpu=softvfp");
5781 switch(getToolChain().getTriple().getEnvironment()) {
5782 case llvm::Triple::GNUEABI:
5783 case llvm::Triple::EABI:
5784 CmdArgs.push_back("-meabi=5");
5785 break;
5786
5787 default:
5788 CmdArgs.push_back("-matpcs");
5789 }
5790 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
5791 getToolChain().getArch() == llvm::Triple::sparcv9) {
5792 if (getToolChain().getArch() == llvm::Triple::sparc)
5793 CmdArgs.push_back("-Av8plusa");
5794 else
5795 CmdArgs.push_back("-Av9a");
5796
5797 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5798 options::OPT_fpic, options::OPT_fno_pic,
5799 options::OPT_fPIE, options::OPT_fno_PIE,
5800 options::OPT_fpie, options::OPT_fno_pie);
5801 if (LastPICArg &&
5802 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5803 LastPICArg->getOption().matches(options::OPT_fpic) ||
5804 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5805 LastPICArg->getOption().matches(options::OPT_fpie))) {
5806 CmdArgs.push_back("-KPIC");
5807 }
5808 }
5809
5810 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5811 options::OPT_Xassembler);
5812
5813 CmdArgs.push_back("-o");
5814 CmdArgs.push_back(Output.getFilename());
5815
5816 for (InputInfoList::const_iterator
5817 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5818 const InputInfo &II = *it;
5819 CmdArgs.push_back(II.getFilename());
5820 }
5821
5822 const char *Exec =
5823 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5824 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5825}
5826
5827void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5828 const InputInfo &Output,
5829 const InputInfoList &Inputs,
5830 const ArgList &Args,
5831 const char *LinkingOutput) const {
5832 const toolchains::FreeBSD& ToolChain =
5833 static_cast<const toolchains::FreeBSD&>(getToolChain());
5834 const Driver &D = ToolChain.getDriver();
5835 ArgStringList CmdArgs;
5836
5837 // Silence warning for "clang -g foo.o -o foo"
5838 Args.ClaimAllArgs(options::OPT_g_Group);
5839 // and "clang -emit-llvm foo.o -o foo"
5840 Args.ClaimAllArgs(options::OPT_emit_llvm);
5841 // and for "clang -w foo.o -o foo". Other warning options are already
5842 // handled somewhere else.
5843 Args.ClaimAllArgs(options::OPT_w);
5844
5845 if (!D.SysRoot.empty())
5846 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5847
5848 if (Args.hasArg(options::OPT_pie))
5849 CmdArgs.push_back("-pie");
5850
5851 if (Args.hasArg(options::OPT_static)) {
5852 CmdArgs.push_back("-Bstatic");
5853 } else {
5854 if (Args.hasArg(options::OPT_rdynamic))
5855 CmdArgs.push_back("-export-dynamic");
5856 CmdArgs.push_back("--eh-frame-hdr");
5857 if (Args.hasArg(options::OPT_shared)) {
5858 CmdArgs.push_back("-Bshareable");
5859 } else {
5860 CmdArgs.push_back("-dynamic-linker");
5861 CmdArgs.push_back("/libexec/ld-elf.so.1");
5862 }
5863 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5864 llvm::Triple::ArchType Arch = ToolChain.getArch();
5865 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5866 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5867 CmdArgs.push_back("--hash-style=both");
5868 }
5869 }
5870 CmdArgs.push_back("--enable-new-dtags");
5871 }
5872
5873 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5874 // instruct ld in the base system to link 32-bit code.
5875 if (ToolChain.getArch() == llvm::Triple::x86) {
5876 CmdArgs.push_back("-m");
5877 CmdArgs.push_back("elf_i386_fbsd");
5878 }
5879
5880 if (ToolChain.getArch() == llvm::Triple::ppc) {
5881 CmdArgs.push_back("-m");
5882 CmdArgs.push_back("elf32ppc_fbsd");
5883 }
5884
5885 if (Output.isFilename()) {
5886 CmdArgs.push_back("-o");
5887 CmdArgs.push_back(Output.getFilename());
5888 } else {
5889 assert(Output.isNothing() && "Invalid output.");
5890 }
5891
5892 if (!Args.hasArg(options::OPT_nostdlib) &&
5893 !Args.hasArg(options::OPT_nostartfiles)) {
5894 const char *crt1 = NULL;
5895 if (!Args.hasArg(options::OPT_shared)) {
5896 if (Args.hasArg(options::OPT_pg))
5897 crt1 = "gcrt1.o";
5898 else if (Args.hasArg(options::OPT_pie))
5899 crt1 = "Scrt1.o";
5900 else
5901 crt1 = "crt1.o";
5902 }
5903 if (crt1)
5904 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5905
5906 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5907
5908 const char *crtbegin = NULL;
5909 if (Args.hasArg(options::OPT_static))
5910 crtbegin = "crtbeginT.o";
5911 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5912 crtbegin = "crtbeginS.o";
5913 else
5914 crtbegin = "crtbegin.o";
5915
5916 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5917 }
5918
5919 Args.AddAllArgs(CmdArgs, options::OPT_L);
5920 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5921 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5922 i != e; ++i)
5923 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5924 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5925 Args.AddAllArgs(CmdArgs, options::OPT_e);
5926 Args.AddAllArgs(CmdArgs, options::OPT_s);
5927 Args.AddAllArgs(CmdArgs, options::OPT_t);
5928 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5929 Args.AddAllArgs(CmdArgs, options::OPT_r);
5930
5931 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5932 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5933 // forward.
5934 if (D.IsUsingLTO(Args)) {
5935 CmdArgs.push_back("-plugin");
5936 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5937 CmdArgs.push_back(Args.MakeArgString(Plugin));
5938
5939 // Try to pass driver level flags relevant to LTO code generation down to
5940 // the plugin.
5941
5942 // Handle flags for selecting CPU variants.
5943 std::string CPU = getCPUName(Args, ToolChain.getTriple());
5944 if (!CPU.empty()) {
5945 CmdArgs.push_back(
5946 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5947 CPU));
5948 }
5949 }
5950
5951 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5952
5953 if (!Args.hasArg(options::OPT_nostdlib) &&
5954 !Args.hasArg(options::OPT_nodefaultlibs)) {
5955 if (D.CCCIsCXX()) {
5956 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5957 if (Args.hasArg(options::OPT_pg))
5958 CmdArgs.push_back("-lm_p");
5959 else
5960 CmdArgs.push_back("-lm");
5961 }
5962 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5963 // the default system libraries. Just mimic this for now.
5964 if (Args.hasArg(options::OPT_pg))
5965 CmdArgs.push_back("-lgcc_p");
5966 else
5967 CmdArgs.push_back("-lgcc");
5968 if (Args.hasArg(options::OPT_static)) {
5969 CmdArgs.push_back("-lgcc_eh");
5970 } else if (Args.hasArg(options::OPT_pg)) {
5971 CmdArgs.push_back("-lgcc_eh_p");
5972 } else {
5973 CmdArgs.push_back("--as-needed");
5974 CmdArgs.push_back("-lgcc_s");
5975 CmdArgs.push_back("--no-as-needed");
5976 }
5977
5978 if (Args.hasArg(options::OPT_pthread)) {
5979 if (Args.hasArg(options::OPT_pg))
5980 CmdArgs.push_back("-lpthread_p");
5981 else
5982 CmdArgs.push_back("-lpthread");
5983 }
5984
5985 if (Args.hasArg(options::OPT_pg)) {
5986 if (Args.hasArg(options::OPT_shared))
5987 CmdArgs.push_back("-lc");
5988 else
5989 CmdArgs.push_back("-lc_p");
5990 CmdArgs.push_back("-lgcc_p");
5991 } else {
5992 CmdArgs.push_back("-lc");
5993 CmdArgs.push_back("-lgcc");
5994 }
5995
5996 if (Args.hasArg(options::OPT_static)) {
5997 CmdArgs.push_back("-lgcc_eh");
5998 } else if (Args.hasArg(options::OPT_pg)) {
5999 CmdArgs.push_back("-lgcc_eh_p");
6000 } else {
6001 CmdArgs.push_back("--as-needed");
6002 CmdArgs.push_back("-lgcc_s");
6003 CmdArgs.push_back("--no-as-needed");
6004 }
6005 }
6006
6007 if (!Args.hasArg(options::OPT_nostdlib) &&
6008 !Args.hasArg(options::OPT_nostartfiles)) {
6009 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6010 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6011 else
6012 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6013 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6014 }
6015
6016 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
6017
6018 const char *Exec =
6019 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
6020 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6021}
6022
6023void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6024 const InputInfo &Output,
6025 const InputInfoList &Inputs,
6026 const ArgList &Args,
6027 const char *LinkingOutput) const {
6028 ArgStringList CmdArgs;
6029
6030 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6031 // instruct as in the base system to assemble 32-bit code.
6032 if (getToolChain().getArch() == llvm::Triple::x86)
6033 CmdArgs.push_back("--32");
6034
6035 // Pass the target CPU to GNU as for ARM, since the source code might
6036 // not have the correct .cpu annotation.
6037 if (getToolChain().getArch() == llvm::Triple::arm) {
6038 std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple()));
6039 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6040 }
6041
6042 if (getToolChain().getArch() == llvm::Triple::mips ||
6043 getToolChain().getArch() == llvm::Triple::mipsel ||
6044 getToolChain().getArch() == llvm::Triple::mips64 ||
6045 getToolChain().getArch() == llvm::Triple::mips64el) {
6046 StringRef CPUName;
6047 StringRef ABIName;
6048 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6049
6050 CmdArgs.push_back("-march");
6051 CmdArgs.push_back(CPUName.data());
6052
6053 CmdArgs.push_back("-mabi");
6054 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6055
6056 if (getToolChain().getArch() == llvm::Triple::mips ||
6057 getToolChain().getArch() == llvm::Triple::mips64)
6058 CmdArgs.push_back("-EB");
6059 else
6060 CmdArgs.push_back("-EL");
6061
6062 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6063 options::OPT_fpic, options::OPT_fno_pic,
6064 options::OPT_fPIE, options::OPT_fno_PIE,
6065 options::OPT_fpie, options::OPT_fno_pie);
6066 if (LastPICArg &&
6067 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6068 LastPICArg->getOption().matches(options::OPT_fpic) ||
6069 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6070 LastPICArg->getOption().matches(options::OPT_fpie))) {
6071 CmdArgs.push_back("-KPIC");
6072 }
6073 }
6074
6075 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6076 options::OPT_Xassembler);
6077
6078 CmdArgs.push_back("-o");
6079 CmdArgs.push_back(Output.getFilename());
6080
6081 for (InputInfoList::const_iterator
6082 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6083 const InputInfo &II = *it;
6084 CmdArgs.push_back(II.getFilename());
6085 }
6086
6087 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6088 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6089}
6090
6091void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6092 const InputInfo &Output,
6093 const InputInfoList &Inputs,
6094 const ArgList &Args,
6095 const char *LinkingOutput) const {
6096 const Driver &D = getToolChain().getDriver();
6097 ArgStringList CmdArgs;
6098
6099 if (!D.SysRoot.empty())
6100 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6101
6102 if (Args.hasArg(options::OPT_static)) {
6103 CmdArgs.push_back("-Bstatic");
6104 } else {
6105 if (Args.hasArg(options::OPT_rdynamic))
6106 CmdArgs.push_back("-export-dynamic");
6107 CmdArgs.push_back("--eh-frame-hdr");
6108 if (Args.hasArg(options::OPT_shared)) {
6109 CmdArgs.push_back("-Bshareable");
6110 } else {
6111 CmdArgs.push_back("-dynamic-linker");
6112 CmdArgs.push_back("/libexec/ld.elf_so");
6113 }
6114 }
6115
6116 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6117 // instruct ld in the base system to link 32-bit code.
6118 if (getToolChain().getArch() == llvm::Triple::x86) {
6119 CmdArgs.push_back("-m");
6120 CmdArgs.push_back("elf_i386");
6121 }
6122
6123 if (Output.isFilename()) {
6124 CmdArgs.push_back("-o");
6125 CmdArgs.push_back(Output.getFilename());
6126 } else {
6127 assert(Output.isNothing() && "Invalid output.");
6128 }
6129
6130 if (!Args.hasArg(options::OPT_nostdlib) &&
6131 !Args.hasArg(options::OPT_nostartfiles)) {
6132 if (!Args.hasArg(options::OPT_shared)) {
6133 CmdArgs.push_back(Args.MakeArgString(
6134 getToolChain().GetFilePath("crt0.o")));
6135 CmdArgs.push_back(Args.MakeArgString(
6136 getToolChain().GetFilePath("crti.o")));
6137 CmdArgs.push_back(Args.MakeArgString(
6138 getToolChain().GetFilePath("crtbegin.o")));
6139 } else {
6140 CmdArgs.push_back(Args.MakeArgString(
6141 getToolChain().GetFilePath("crti.o")));
6142 CmdArgs.push_back(Args.MakeArgString(
6143 getToolChain().GetFilePath("crtbeginS.o")));
6144 }
6145 }
6146
6147 Args.AddAllArgs(CmdArgs, options::OPT_L);
6148 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6149 Args.AddAllArgs(CmdArgs, options::OPT_e);
6150 Args.AddAllArgs(CmdArgs, options::OPT_s);
6151 Args.AddAllArgs(CmdArgs, options::OPT_t);
6152 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6153 Args.AddAllArgs(CmdArgs, options::OPT_r);
6154
6155 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6156
6157 unsigned Major, Minor, Micro;
6158 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6159 bool useLibgcc = true;
6160 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
6161 if (getToolChain().getArch() == llvm::Triple::x86 ||
6162 getToolChain().getArch() == llvm::Triple::x86_64)
6163 useLibgcc = false;
6164 }
6165
6166 if (!Args.hasArg(options::OPT_nostdlib) &&
6167 !Args.hasArg(options::OPT_nodefaultlibs)) {
6168 if (D.CCCIsCXX()) {
6169 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6170 CmdArgs.push_back("-lm");
6171 }
6172 if (Args.hasArg(options::OPT_pthread))
6173 CmdArgs.push_back("-lpthread");
6174 CmdArgs.push_back("-lc");
6175
6176 if (useLibgcc) {
6177 if (Args.hasArg(options::OPT_static)) {
6178 // libgcc_eh depends on libc, so resolve as much as possible,
6179 // pull in any new requirements from libc and then get the rest
6180 // of libgcc.
6181 CmdArgs.push_back("-lgcc_eh");
6182 CmdArgs.push_back("-lc");
6183 CmdArgs.push_back("-lgcc");
6184 } else {
6185 CmdArgs.push_back("-lgcc");
6186 CmdArgs.push_back("--as-needed");
6187 CmdArgs.push_back("-lgcc_s");
6188 CmdArgs.push_back("--no-as-needed");
6189 }
6190 }
6191 }
6192
6193 if (!Args.hasArg(options::OPT_nostdlib) &&
6194 !Args.hasArg(options::OPT_nostartfiles)) {
6195 if (!Args.hasArg(options::OPT_shared))
6196 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6197 "crtend.o")));
6198 else
6199 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6200 "crtendS.o")));
6201 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6202 "crtn.o")));
6203 }
6204
6205 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6206
6207 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6208 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6209}
6210
6211void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6212 const InputInfo &Output,
6213 const InputInfoList &Inputs,
6214 const ArgList &Args,
6215 const char *LinkingOutput) const {
6216 ArgStringList CmdArgs;
6217 bool NeedsKPIC = false;
6218
6219 // Add --32/--64 to make sure we get the format we want.
6220 // This is incomplete
6221 if (getToolChain().getArch() == llvm::Triple::x86) {
6222 CmdArgs.push_back("--32");
6223 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6224 CmdArgs.push_back("--64");
6225 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6226 CmdArgs.push_back("-a32");
6227 CmdArgs.push_back("-mppc");
6228 CmdArgs.push_back("-many");
6229 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6230 CmdArgs.push_back("-a64");
6231 CmdArgs.push_back("-mppc64");
6232 CmdArgs.push_back("-many");
6233 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6234 CmdArgs.push_back("-a64");
6235 CmdArgs.push_back("-mppc64le");
6236 CmdArgs.push_back("-many");
6237 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6238 CmdArgs.push_back("-32");
6239 CmdArgs.push_back("-Av8plusa");
6240 NeedsKPIC = true;
6241 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6242 CmdArgs.push_back("-64");
6243 CmdArgs.push_back("-Av9a");
6244 NeedsKPIC = true;
6245 } else if (getToolChain().getArch() == llvm::Triple::arm) {
6246 StringRef MArch = getToolChain().getArchName();
6247 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6248 CmdArgs.push_back("-mfpu=neon");
6249 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6250 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
6251
6252 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
6253 getToolChain().getTriple());
6254 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6255
6256 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6257 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6258 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6259 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6260 getToolChain().getArch() == llvm::Triple::mipsel ||
6261 getToolChain().getArch() == llvm::Triple::mips64 ||
6262 getToolChain().getArch() == llvm::Triple::mips64el) {
6263 StringRef CPUName;
6264 StringRef ABIName;
6265 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6266
6267 CmdArgs.push_back("-march");
6268 CmdArgs.push_back(CPUName.data());
6269
6270 CmdArgs.push_back("-mabi");
6271 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6272
6273 if (getToolChain().getArch() == llvm::Triple::mips ||
6274 getToolChain().getArch() == llvm::Triple::mips64)
6275 CmdArgs.push_back("-EB");
6276 else
6277 CmdArgs.push_back("-EL");
6278
6279 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6280 if (StringRef(A->getValue()) == "2008")
6281 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6282 }
6283
6284 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) {
6285 if (A->getOption().matches(options::OPT_mfp32))
6286 CmdArgs.push_back(Args.MakeArgString("-mfp32"));
6287 else
6288 CmdArgs.push_back(Args.MakeArgString("-mfp64"));
6289 }
6290
6291 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6292 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6293 options::OPT_mno_micromips);
6294 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6295 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6296
6297 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6298 // Do not use AddLastArg because not all versions of MIPS assembler
6299 // support -mmsa / -mno-msa options.
6300 if (A->getOption().matches(options::OPT_mmsa))
6301 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6302 }
6303
6304 NeedsKPIC = true;
6305 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6306 // Always pass an -march option, since our default of z10 is later
6307 // than the GNU assembler's default.
6308 StringRef CPUName = getSystemZTargetCPU(Args);
6309 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6310 }
6311
6312 if (NeedsKPIC) {
6313 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6314 options::OPT_fpic, options::OPT_fno_pic,
6315 options::OPT_fPIE, options::OPT_fno_PIE,
6316 options::OPT_fpie, options::OPT_fno_pie);
6317 if (LastPICArg &&
6318 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6319 LastPICArg->getOption().matches(options::OPT_fpic) ||
6320 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6321 LastPICArg->getOption().matches(options::OPT_fpie))) {
6322 CmdArgs.push_back("-KPIC");
6323 }
6324 }
6325
6326 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6327 options::OPT_Xassembler);
6328
6329 CmdArgs.push_back("-o");
6330 CmdArgs.push_back(Output.getFilename());
6331
6332 for (InputInfoList::const_iterator
6333 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6334 const InputInfo &II = *it;
6335 CmdArgs.push_back(II.getFilename());
6336 }
6337
6338 const char *Exec =
6339 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6340 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6341
6342 // Handle the debug info splitting at object creation time if we're
6343 // creating an object.
6344 // TODO: Currently only works on linux with newer objcopy.
6345 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6346 getToolChain().getTriple().isOSLinux())
6347 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6348 SplitDebugName(Args, Inputs));
6349}
6350
6351static void AddLibgcc(llvm::Triple Triple, const Driver &D,
6352 ArgStringList &CmdArgs, const ArgList &Args) {
6353 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
6354 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6355 Args.hasArg(options::OPT_static);
6356 if (!D.CCCIsCXX())
6357 CmdArgs.push_back("-lgcc");
6358
6359 if (StaticLibgcc || isAndroid) {
6360 if (D.CCCIsCXX())
6361 CmdArgs.push_back("-lgcc");
6362 } else {
6363 if (!D.CCCIsCXX())
6364 CmdArgs.push_back("--as-needed");
6365 CmdArgs.push_back("-lgcc_s");
6366 if (!D.CCCIsCXX())
6367 CmdArgs.push_back("--no-as-needed");
6368 }
6369
6370 if (StaticLibgcc && !isAndroid)
6371 CmdArgs.push_back("-lgcc_eh");
6372 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
6373 CmdArgs.push_back("-lgcc");
6374
6375 // According to Android ABI, we have to link with libdl if we are
6376 // linking with non-static libgcc.
6377 //
6378 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6379 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6380 if (isAndroid && !StaticLibgcc)
6381 CmdArgs.push_back("-ldl");
6382}
6383
6384static bool hasMipsN32ABIArg(const ArgList &Args) {
6385 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6386 return A && (A->getValue() == StringRef("n32"));
6387}
6388
6389static StringRef getLinuxDynamicLinker(const ArgList &Args,
6390 const toolchains::Linux &ToolChain) {
6391 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6392 return "/system/bin/linker";
6393 else if (ToolChain.getArch() == llvm::Triple::x86 ||
6394 ToolChain.getArch() == llvm::Triple::sparc)
6395 return "/lib/ld-linux.so.2";
6396 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6397 return "/lib/ld-linux-aarch64.so.1";
6398 else if (ToolChain.getArch() == llvm::Triple::arm ||
6399 ToolChain.getArch() == llvm::Triple::thumb) {
6400 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6401 return "/lib/ld-linux-armhf.so.3";
6402 else
6403 return "/lib/ld-linux.so.3";
6404 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6405 ToolChain.getArch() == llvm::Triple::mipsel)
6406 return "/lib/ld.so.1";
6407 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6408 ToolChain.getArch() == llvm::Triple::mips64el) {
6409 if (hasMipsN32ABIArg(Args))
6410 return "/lib32/ld.so.1";
6411 else
6412 return "/lib64/ld.so.1";
6413 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6414 return "/lib/ld.so.1";
6415 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6416 ToolChain.getArch() == llvm::Triple::ppc64le ||
6417 ToolChain.getArch() == llvm::Triple::systemz)
6418 return "/lib64/ld64.so.1";
6419 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6420 return "/lib64/ld-linux.so.2";
6421 else
6422 return "/lib64/ld-linux-x86-64.so.2";
6423}
6424
6425void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6426 const InputInfo &Output,
6427 const InputInfoList &Inputs,
6428 const ArgList &Args,
6429 const char *LinkingOutput) const {
6430 const toolchains::Linux& ToolChain =
6431 static_cast<const toolchains::Linux&>(getToolChain());
6432 const Driver &D = ToolChain.getDriver();
6433 const bool isAndroid =
6434 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
6435 const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
6436 const bool IsPIE =
6437 !Args.hasArg(options::OPT_shared) &&
6438 (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
6439
6440 ArgStringList CmdArgs;
6441
6442 // Silence warning for "clang -g foo.o -o foo"
6443 Args.ClaimAllArgs(options::OPT_g_Group);
6444 // and "clang -emit-llvm foo.o -o foo"
6445 Args.ClaimAllArgs(options::OPT_emit_llvm);
6446 // and for "clang -w foo.o -o foo". Other warning options are already
6447 // handled somewhere else.
6448 Args.ClaimAllArgs(options::OPT_w);
6449
6450 if (!D.SysRoot.empty())
6451 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6452
6453 if (IsPIE)
6454 CmdArgs.push_back("-pie");
6455
6456 if (Args.hasArg(options::OPT_rdynamic))
6457 CmdArgs.push_back("-export-dynamic");
6458
6459 if (Args.hasArg(options::OPT_s))
6460 CmdArgs.push_back("-s");
6461
6462 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6463 e = ToolChain.ExtraOpts.end();
6464 i != e; ++i)
6465 CmdArgs.push_back(i->c_str());
6466
6467 if (!Args.hasArg(options::OPT_static)) {
6468 CmdArgs.push_back("--eh-frame-hdr");
6469 }
6470
6471 CmdArgs.push_back("-m");
6472 if (ToolChain.getArch() == llvm::Triple::x86)
6473 CmdArgs.push_back("elf_i386");
6474 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6475 CmdArgs.push_back("aarch64linux");
6476 else if (ToolChain.getArch() == llvm::Triple::arm
6477 || ToolChain.getArch() == llvm::Triple::thumb)
6478 CmdArgs.push_back("armelf_linux_eabi");
6479 else if (ToolChain.getArch() == llvm::Triple::ppc)
6480 CmdArgs.push_back("elf32ppclinux");
6481 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6482 CmdArgs.push_back("elf64ppc");
6483 else if (ToolChain.getArch() == llvm::Triple::sparc)
6484 CmdArgs.push_back("elf32_sparc");
6485 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6486 CmdArgs.push_back("elf64_sparc");
6487 else if (ToolChain.getArch() == llvm::Triple::mips)
6488 CmdArgs.push_back("elf32btsmip");
6489 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6490 CmdArgs.push_back("elf32ltsmip");
6491 else if (ToolChain.getArch() == llvm::Triple::mips64) {
6492 if (hasMipsN32ABIArg(Args))
6493 CmdArgs.push_back("elf32btsmipn32");
6494 else
6495 CmdArgs.push_back("elf64btsmip");
6496 }
6497 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6498 if (hasMipsN32ABIArg(Args))
6499 CmdArgs.push_back("elf32ltsmipn32");
6500 else
6501 CmdArgs.push_back("elf64ltsmip");
6502 }
6503 else if (ToolChain.getArch() == llvm::Triple::systemz)
6504 CmdArgs.push_back("elf64_s390");
6505 else
6506 CmdArgs.push_back("elf_x86_64");
6507
6508 if (Args.hasArg(options::OPT_static)) {
6509 if (ToolChain.getArch() == llvm::Triple::arm
6510 || ToolChain.getArch() == llvm::Triple::thumb)
6511 CmdArgs.push_back("-Bstatic");
6512 else
6513 CmdArgs.push_back("-static");
6514 } else if (Args.hasArg(options::OPT_shared)) {
6515 CmdArgs.push_back("-shared");
6516 if (isAndroid) {
6517 CmdArgs.push_back("-Bsymbolic");
6518 }
6519 }
6520
6521 if (ToolChain.getArch() == llvm::Triple::arm ||
6522 ToolChain.getArch() == llvm::Triple::thumb ||
6523 (!Args.hasArg(options::OPT_static) &&
6524 !Args.hasArg(options::OPT_shared))) {
6525 CmdArgs.push_back("-dynamic-linker");
6526 CmdArgs.push_back(Args.MakeArgString(
6527 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
6528 }
6529
6530 CmdArgs.push_back("-o");
6531 CmdArgs.push_back(Output.getFilename());
6532
6533 if (!Args.hasArg(options::OPT_nostdlib) &&
6534 !Args.hasArg(options::OPT_nostartfiles)) {
6535 if (!isAndroid) {
6536 const char *crt1 = NULL;
6537 if (!Args.hasArg(options::OPT_shared)){
6538 if (Args.hasArg(options::OPT_pg))
6539 crt1 = "gcrt1.o";
6540 else if (IsPIE)
6541 crt1 = "Scrt1.o";
6542 else
6543 crt1 = "crt1.o";
6544 }
6545 if (crt1)
6546 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6547
6548 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6549 }
6550
6551 const char *crtbegin;
6552 if (Args.hasArg(options::OPT_static))
6553 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
6554 else if (Args.hasArg(options::OPT_shared))
6555 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
6556 else if (IsPIE)
6557 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
6558 else
6559 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
6560 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6561
6562 // Add crtfastmath.o if available and fast math is enabled.
6563 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
6564 }
6565
6566 Args.AddAllArgs(CmdArgs, options::OPT_L);
6567
6568 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6569
6570 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6571 i != e; ++i)
6572 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
6573
6574 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6575 // as gold requires -plugin to come before any -plugin-opt that -Wl might
6576 // forward.
6577 if (D.IsUsingLTO(Args)) {
6578 CmdArgs.push_back("-plugin");
6579 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6580 CmdArgs.push_back(Args.MakeArgString(Plugin));
6581
6582 // Try to pass driver level flags relevant to LTO code generation down to
6583 // the plugin.
6584
6585 // Handle flags for selecting CPU variants.
6586 std::string CPU = getCPUName(Args, ToolChain.getTriple());
6587 if (!CPU.empty()) {
6588 CmdArgs.push_back(
6589 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6590 CPU));
6591 }
6592 }
6593
6594
6595 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6596 CmdArgs.push_back("--no-demangle");
6597
6598 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6599
6600 // Call these before we add the C++ ABI library.
6601 if (Sanitize.needsUbsanRt())
6602 addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
6603 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
6604 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
6605 if (Sanitize.needsAsanRt())
6606 addAsanRTLinux(getToolChain(), Args, CmdArgs);
6607 if (Sanitize.needsTsanRt())
6608 addTsanRTLinux(getToolChain(), Args, CmdArgs);
6609 if (Sanitize.needsMsanRt())
6610 addMsanRTLinux(getToolChain(), Args, CmdArgs);
6611 if (Sanitize.needsLsanRt())
6612 addLsanRTLinux(getToolChain(), Args, CmdArgs);
6613 if (Sanitize.needsDfsanRt())
6614 addDfsanRTLinux(getToolChain(), Args, CmdArgs);
6615
6616 // The profile runtime also needs access to system libraries.
6617 addProfileRTLinux(getToolChain(), Args, CmdArgs);
6618
6619 if (D.CCCIsCXX() &&
6620 !Args.hasArg(options::OPT_nostdlib) &&
6621 !Args.hasArg(options::OPT_nodefaultlibs)) {
6622 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6623 !Args.hasArg(options::OPT_static);
6624 if (OnlyLibstdcxxStatic)
6625 CmdArgs.push_back("-Bstatic");
6626 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6627 if (OnlyLibstdcxxStatic)
6628 CmdArgs.push_back("-Bdynamic");
6629 CmdArgs.push_back("-lm");
6630 }
6631
6632 if (!Args.hasArg(options::OPT_nostdlib)) {
6633 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6634 if (Args.hasArg(options::OPT_static))
6635 CmdArgs.push_back("--start-group");
6636
6637 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6638 if (OpenMP) {
6639 CmdArgs.push_back("-lgomp");
6640
6641 // FIXME: Exclude this for platforms whith libgomp that doesn't require
6642 // librt. Most modern Linux platfroms require it, but some may not.
6643 CmdArgs.push_back("-lrt");
6644 }
6645
6646 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6647
6648 if (Args.hasArg(options::OPT_pthread) ||
6649 Args.hasArg(options::OPT_pthreads) || OpenMP)
6650 CmdArgs.push_back("-lpthread");
6651
6652 CmdArgs.push_back("-lc");
6653
6654 if (Args.hasArg(options::OPT_static))
6655 CmdArgs.push_back("--end-group");
6656 else
6657 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6658 }
6659
6660 if (!Args.hasArg(options::OPT_nostartfiles)) {
6661 const char *crtend;
6662 if (Args.hasArg(options::OPT_shared))
6663 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
6664 else if (IsPIE)
6665 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
6666 else
6667 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
6668
6669 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
6670 if (!isAndroid)
6671 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6672 }
6673 }
6674
6675 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6676}
6677
6678void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6679 const InputInfo &Output,
6680 const InputInfoList &Inputs,
6681 const ArgList &Args,
6682 const char *LinkingOutput) const {
6683 ArgStringList CmdArgs;
6684
6685 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6686 options::OPT_Xassembler);
6687
6688 CmdArgs.push_back("-o");
6689 CmdArgs.push_back(Output.getFilename());
6690
6691 for (InputInfoList::const_iterator
6692 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6693 const InputInfo &II = *it;
6694 CmdArgs.push_back(II.getFilename());
6695 }
6696
6697 const char *Exec =
6698 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6699 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6700}
6701
6702void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
6703 const InputInfo &Output,
6704 const InputInfoList &Inputs,
6705 const ArgList &Args,
6706 const char *LinkingOutput) const {
6707 const Driver &D = getToolChain().getDriver();
6708 ArgStringList CmdArgs;
6709
6710 if (Output.isFilename()) {
6711 CmdArgs.push_back("-o");
6712 CmdArgs.push_back(Output.getFilename());
6713 } else {
6714 assert(Output.isNothing() && "Invalid output.");
6715 }
6716
6717 if (!Args.hasArg(options::OPT_nostdlib) &&
6718 !Args.hasArg(options::OPT_nostartfiles)) {
6719 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6720 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6722 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6723 }
6724
6725 Args.AddAllArgs(CmdArgs, options::OPT_L);
6726 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6727 Args.AddAllArgs(CmdArgs, options::OPT_e);
6728
6729 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6730
6731 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6732
6733 if (!Args.hasArg(options::OPT_nostdlib) &&
6734 !Args.hasArg(options::OPT_nodefaultlibs)) {
6735 if (D.CCCIsCXX()) {
6736 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6737 CmdArgs.push_back("-lm");
6738 }
6739 }
6740
6741 if (!Args.hasArg(options::OPT_nostdlib) &&
6742 !Args.hasArg(options::OPT_nostartfiles)) {
6743 if (Args.hasArg(options::OPT_pthread))
6744 CmdArgs.push_back("-lpthread");
6745 CmdArgs.push_back("-lc");
6746 CmdArgs.push_back("-lCompilerRT-Generic");
6747 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6748 CmdArgs.push_back(
6749 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6750 }
6751
6752 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6753 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6754}
6755
6756/// DragonFly Tools
6757
6758// For now, DragonFly Assemble does just about the same as for
6759// FreeBSD, but this may change soon.
6760void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6761 const InputInfo &Output,
6762 const InputInfoList &Inputs,
6763 const ArgList &Args,
6764 const char *LinkingOutput) const {
6765 ArgStringList CmdArgs;
6766
6767 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6768 // instruct as in the base system to assemble 32-bit code.
6769 if (getToolChain().getArch() == llvm::Triple::x86)
6770 CmdArgs.push_back("--32");
6771
6772 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6773 options::OPT_Xassembler);
6774
6775 CmdArgs.push_back("-o");
6776 CmdArgs.push_back(Output.getFilename());
6777
6778 for (InputInfoList::const_iterator
6779 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6780 const InputInfo &II = *it;
6781 CmdArgs.push_back(II.getFilename());
6782 }
6783
6784 const char *Exec =
6785 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6786 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6787}
6788
6789void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6790 const InputInfo &Output,
6791 const InputInfoList &Inputs,
6792 const ArgList &Args,
6793 const char *LinkingOutput) const {
6794 bool UseGCC47 = false;
6795 const Driver &D = getToolChain().getDriver();
6796 ArgStringList CmdArgs;
6797
6798 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6799 UseGCC47 = false;
6800
6801 if (!D.SysRoot.empty())
6802 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6803
6804 CmdArgs.push_back("--eh-frame-hdr");
6805 if (Args.hasArg(options::OPT_static)) {
6806 CmdArgs.push_back("-Bstatic");
6807 } else {
6808 if (Args.hasArg(options::OPT_rdynamic))
6809 CmdArgs.push_back("-export-dynamic");
6810 if (Args.hasArg(options::OPT_shared))
6811 CmdArgs.push_back("-Bshareable");
6812 else {
6813 CmdArgs.push_back("-dynamic-linker");
6814 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6815 }
6816 CmdArgs.push_back("--hash-style=both");
6817 }
6818
6819 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6820 // instruct ld in the base system to link 32-bit code.
6821 if (getToolChain().getArch() == llvm::Triple::x86) {
6822 CmdArgs.push_back("-m");
6823 CmdArgs.push_back("elf_i386");
6824 }
6825
6826 if (Output.isFilename()) {
6827 CmdArgs.push_back("-o");
6828 CmdArgs.push_back(Output.getFilename());
6829 } else {
6830 assert(Output.isNothing() && "Invalid output.");
6831 }
6832
6833 if (!Args.hasArg(options::OPT_nostdlib) &&
6834 !Args.hasArg(options::OPT_nostartfiles)) {
6835 if (!Args.hasArg(options::OPT_shared)) {
6836 if (Args.hasArg(options::OPT_pg))
6837 CmdArgs.push_back(Args.MakeArgString(
6838 getToolChain().GetFilePath("gcrt1.o")));
6839 else {
6840 if (Args.hasArg(options::OPT_pie))
6841 CmdArgs.push_back(Args.MakeArgString(
6842 getToolChain().GetFilePath("Scrt1.o")));
6843 else
6844 CmdArgs.push_back(Args.MakeArgString(
6845 getToolChain().GetFilePath("crt1.o")));
6846 }
6847 }
6848 CmdArgs.push_back(Args.MakeArgString(
6849 getToolChain().GetFilePath("crti.o")));
6850 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6851 CmdArgs.push_back(Args.MakeArgString(
6852 getToolChain().GetFilePath("crtbeginS.o")));
6853 else
6854 CmdArgs.push_back(Args.MakeArgString(
6855 getToolChain().GetFilePath("crtbegin.o")));
6856 }
6857
6858 Args.AddAllArgs(CmdArgs, options::OPT_L);
6859 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6860 Args.AddAllArgs(CmdArgs, options::OPT_e);
6861
6862 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6863
6864 if (!Args.hasArg(options::OPT_nostdlib) &&
6865 !Args.hasArg(options::OPT_nodefaultlibs)) {
6866 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6867 // rpaths
6868 if (UseGCC47)
6869 CmdArgs.push_back("-L/usr/lib/gcc47");
6870 else
6871 CmdArgs.push_back("-L/usr/lib/gcc44");
6872
6873 if (!Args.hasArg(options::OPT_static)) {
6874 if (UseGCC47) {
6875 CmdArgs.push_back("-rpath");
6876 CmdArgs.push_back("/usr/lib/gcc47");
6877 } else {
6878 CmdArgs.push_back("-rpath");
6879 CmdArgs.push_back("/usr/lib/gcc44");
6880 }
6881 }
6882
6883 if (D.CCCIsCXX()) {
6884 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6885 CmdArgs.push_back("-lm");
6886 }
6887
6888 if (Args.hasArg(options::OPT_pthread))
6889 CmdArgs.push_back("-lpthread");
6890
6891 if (!Args.hasArg(options::OPT_nolibc)) {
6892 CmdArgs.push_back("-lc");
6893 }
6894
6895 if (UseGCC47) {
6896 if (Args.hasArg(options::OPT_static) ||
6897 Args.hasArg(options::OPT_static_libgcc)) {
6898 CmdArgs.push_back("-lgcc");
6899 CmdArgs.push_back("-lgcc_eh");
6900 } else {
6901 if (Args.hasArg(options::OPT_shared_libgcc)) {
6902 CmdArgs.push_back("-lgcc_pic");
6903 if (!Args.hasArg(options::OPT_shared))
6904 CmdArgs.push_back("-lgcc");
6905 } else {
6906 CmdArgs.push_back("-lgcc");
6907 CmdArgs.push_back("--as-needed");
6908 CmdArgs.push_back("-lgcc_pic");
6909 CmdArgs.push_back("--no-as-needed");
6910 }
6911 }
6912 } else {
6913 if (Args.hasArg(options::OPT_shared)) {
6914 CmdArgs.push_back("-lgcc_pic");
6915 } else {
6916 CmdArgs.push_back("-lgcc");
6917 }
6918 }
6919 }
6920
6921 if (!Args.hasArg(options::OPT_nostdlib) &&
6922 !Args.hasArg(options::OPT_nostartfiles)) {
6923 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6924 CmdArgs.push_back(Args.MakeArgString(
6925 getToolChain().GetFilePath("crtendS.o")));
6926 else
6927 CmdArgs.push_back(Args.MakeArgString(
6928 getToolChain().GetFilePath("crtend.o")));
6929 CmdArgs.push_back(Args.MakeArgString(
6930 getToolChain().GetFilePath("crtn.o")));
6931 }
6932
6933 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6934
6935 const char *Exec =
6936 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6937 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6938}
6939
6940void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6941 const InputInfo &Output,
6942 const InputInfoList &Inputs,
6943 const ArgList &Args,
6944 const char *LinkingOutput) const {
6945 ArgStringList CmdArgs;
6946
6947 if (Output.isFilename()) {
6948 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6949 Output.getFilename()));
6950 } else {
6951 assert(Output.isNothing() && "Invalid output.");
6952 }
6953
6954 if (!Args.hasArg(options::OPT_nostdlib) &&
6955 !Args.hasArg(options::OPT_nostartfiles) &&
6956 !C.getDriver().IsCLMode()) {
6957 CmdArgs.push_back("-defaultlib:libcmt");
6958 }
6959
6960 CmdArgs.push_back("-nologo");
6961
6962 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6963
6964 if (DLL) {
6965 CmdArgs.push_back(Args.MakeArgString("-dll"));
6966
6967 SmallString<128> ImplibName(Output.getFilename());
6968 llvm::sys::path::replace_extension(ImplibName, "lib");
6969 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6970 ImplibName.str()));
6971 }
6972
6973 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
6974 CmdArgs.push_back(Args.MakeArgString("-debug"));
6975 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
6976 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
6977 llvm::sys::path::append(LibSanitizer, "lib", "windows");
6978 if (DLL) {
6979 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
6980 } else {
6981 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6982 }
6983 // FIXME: Handle 64-bit.
6984 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6985 }
6986
6987 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6988 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
6989
6990 // Add filenames immediately.
6991 for (InputInfoList::const_iterator
6992 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6993 if (it->isFilename())
6994 CmdArgs.push_back(it->getFilename());
6995 else
6996 it->getInputArg().renderAsInput(Args, CmdArgs);
6997 }
6998
6999 const char *Exec =
7000 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
7001 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7002}
7003
7004void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7005 const InputInfo &Output,
7006 const InputInfoList &Inputs,
7007 const ArgList &Args,
7008 const char *LinkingOutput) const {
7009 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7010}
7011
7012// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7013// If one cannot be found, return FallbackName.
7014// We do this special search to prevent clang-cl from falling back onto itself
7015// if it's available as cl.exe on the path.
7016static std::string FindFallback(const char *FallbackName,
7017 const char *ClangProgramPath) {
7018 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7019 if (!OptPath.hasValue())
7020 return FallbackName;
7021
7022#ifdef LLVM_ON_WIN32
7023 const StringRef PathSeparators = ";";
7024#else
7025 const StringRef PathSeparators = ":";
7026#endif
7027
7028 SmallVector<StringRef, 8> PathSegments;
7029 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7030
7031 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7032 const StringRef &PathSegment = PathSegments[i];
7033 if (PathSegment.empty())
7034 continue;
7035
7036 SmallString<128> FilePath(PathSegment);
7037 llvm::sys::path::append(FilePath, FallbackName);
7038 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7039 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7040 return FilePath.str();
7041 }
7042
7043 return FallbackName;
7044}
7045
7046Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7047 const InputInfo &Output,
7048 const InputInfoList &Inputs,
7049 const ArgList &Args,
7050 const char *LinkingOutput) const {
7051 ArgStringList CmdArgs;
7052 CmdArgs.push_back("/nologo");
7053 CmdArgs.push_back("/c"); // Compile only.
7054 CmdArgs.push_back("/W0"); // No warnings.
7055
7056 // The goal is to be able to invoke this tool correctly based on
7057 // any flag accepted by clang-cl.
7058
7059 // These are spelled the same way in clang and cl.exe,.
7060 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7061 Args.AddAllArgs(CmdArgs, options::OPT_I);
7062
7063 // Optimization level.
7064 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7065 if (A->getOption().getID() == options::OPT_O0) {
7066 CmdArgs.push_back("/Od");
7067 } else {
7068 StringRef OptLevel = A->getValue();
7069 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7070 A->render(Args, CmdArgs);
7071 else if (OptLevel == "3")
7072 CmdArgs.push_back("/Ox");
7073 }
7074 }
7075
7076 // Flags for which clang-cl have an alias.
7077 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7078
7079 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7080 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7081 : "/GR-");
7082 if (Args.hasArg(options::OPT_fsyntax_only))
7083 CmdArgs.push_back("/Zs");
7084
7085 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7086 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7087 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7088
7089 // Flags that can simply be passed through.
7090 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7091 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7092
7093 // The order of these flags is relevant, so pick the last one.
7094 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7095 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7096 A->render(Args, CmdArgs);
7097
7098
7099 // Input filename.
7100 assert(Inputs.size() == 1);
7101 const InputInfo &II = Inputs[0];
7102 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7103 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7104 if (II.isFilename())
7105 CmdArgs.push_back(II.getFilename());
7106 else
7107 II.getInputArg().renderAsInput(Args, CmdArgs);
7108
7109 // Output filename.
7110 assert(Output.getType() == types::TY_Object);
7111 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7112 Output.getFilename());
7113 CmdArgs.push_back(Fo);
7114
7115 const Driver &D = getToolChain().getDriver();
7116 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
7117
7118 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7119}
7120
7121
7122/// XCore Tools
7123// We pass assemble and link construction to the xcc tool.
7124
7125void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7126 const InputInfo &Output,
7127 const InputInfoList &Inputs,
7128 const ArgList &Args,
7129 const char *LinkingOutput) const {
7130 ArgStringList CmdArgs;
7131
7132 CmdArgs.push_back("-o");
7133 CmdArgs.push_back(Output.getFilename());
7134
7135 CmdArgs.push_back("-c");
7136
7137 if (Args.hasArg(options::OPT_g_Group)) {
7138 CmdArgs.push_back("-g");
7139 }
7140
7141 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7142 options::OPT_Xassembler);
7143
7144 for (InputInfoList::const_iterator
7145 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7146 const InputInfo &II = *it;
7147 CmdArgs.push_back(II.getFilename());
7148 }
7149
7150 const char *Exec =
7151 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7152 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7153}
7154
7155void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7156 const InputInfo &Output,
7157 const InputInfoList &Inputs,
7158 const ArgList &Args,
7159 const char *LinkingOutput) const {
7160 ArgStringList CmdArgs;
7161
7162 if (Output.isFilename()) {
7163 CmdArgs.push_back("-o");
7164 CmdArgs.push_back(Output.getFilename());
7165 } else {
7166 assert(Output.isNothing() && "Invalid output.");
7167 }
7168
7169 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7170
7171 const char *Exec =
7172 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7173 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7174}
| 4618
4619 // Forward -g, assuming we are dealing with an actual assembly file.
4620 if (SourceAction->getType() == types::TY_Asm ||
4621 SourceAction->getType() == types::TY_PP_Asm) {
4622 if (Args.hasArg(options::OPT_gstabs))
4623 CmdArgs.push_back("--gstabs");
4624 else if (Args.hasArg(options::OPT_g_Group))
4625 CmdArgs.push_back("-g");
4626 }
4627
4628 // Derived from asm spec.
4629 AddDarwinArch(Args, CmdArgs);
4630
4631 // Use -force_cpusubtype_ALL on x86 by default.
4632 if (getToolChain().getArch() == llvm::Triple::x86 ||
4633 getToolChain().getArch() == llvm::Triple::x86_64 ||
4634 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4635 CmdArgs.push_back("-force_cpusubtype_ALL");
4636
4637 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
4638 (((Args.hasArg(options::OPT_mkernel) ||
4639 Args.hasArg(options::OPT_fapple_kext)) &&
4640 (!getDarwinToolChain().isTargetIPhoneOS() ||
4641 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4642 Args.hasArg(options::OPT_static)))
4643 CmdArgs.push_back("-static");
4644
4645 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4646 options::OPT_Xassembler);
4647
4648 assert(Output.isFilename() && "Unexpected lipo output.");
4649 CmdArgs.push_back("-o");
4650 CmdArgs.push_back(Output.getFilename());
4651
4652 assert(Input.isFilename() && "Invalid input.");
4653 CmdArgs.push_back(Input.getFilename());
4654
4655 // asm_final spec is empty.
4656
4657 const char *Exec =
4658 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4659 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4660}
4661
4662void darwin::DarwinTool::anchor() {}
4663
4664void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4665 ArgStringList &CmdArgs) const {
4666 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4667
4668 // Derived from darwin_arch spec.
4669 CmdArgs.push_back("-arch");
4670 CmdArgs.push_back(Args.MakeArgString(ArchName));
4671
4672 // FIXME: Is this needed anymore?
4673 if (ArchName == "arm")
4674 CmdArgs.push_back("-force_cpusubtype_ALL");
4675}
4676
4677bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4678 // We only need to generate a temp path for LTO if we aren't compiling object
4679 // files. When compiling source files, we run 'dsymutil' after linking. We
4680 // don't run 'dsymutil' when compiling object files.
4681 for (InputInfoList::const_iterator
4682 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4683 if (it->getType() != types::TY_Object)
4684 return true;
4685
4686 return false;
4687}
4688
4689void darwin::Link::AddLinkArgs(Compilation &C,
4690 const ArgList &Args,
4691 ArgStringList &CmdArgs,
4692 const InputInfoList &Inputs) const {
4693 const Driver &D = getToolChain().getDriver();
4694 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4695
4696 unsigned Version[3] = { 0, 0, 0 };
4697 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4698 bool HadExtra;
4699 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4700 Version[1], Version[2], HadExtra) ||
4701 HadExtra)
4702 D.Diag(diag::err_drv_invalid_version_number)
4703 << A->getAsString(Args);
4704 }
4705
4706 // Newer linkers support -demangle, pass it if supported and not disabled by
4707 // the user.
4708 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4709 // Don't pass -demangle to ld_classic.
4710 //
4711 // FIXME: This is a temporary workaround, ld should be handling this.
4712 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4713 Args.hasArg(options::OPT_static));
4714 if (getToolChain().getArch() == llvm::Triple::x86) {
4715 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4716 options::OPT_Wl_COMMA),
4717 ie = Args.filtered_end(); it != ie; ++it) {
4718 const Arg *A = *it;
4719 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4720 if (StringRef(A->getValue(i)) == "-kext")
4721 UsesLdClassic = true;
4722 }
4723 }
4724 if (!UsesLdClassic)
4725 CmdArgs.push_back("-demangle");
4726 }
4727
4728 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4729 CmdArgs.push_back("-export_dynamic");
4730
4731 // If we are using LTO, then automatically create a temporary file path for
4732 // the linker to use, so that it's lifetime will extend past a possible
4733 // dsymutil step.
4734 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4735 const char *TmpPath = C.getArgs().MakeArgString(
4736 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4737 C.addTempFile(TmpPath);
4738 CmdArgs.push_back("-object_path_lto");
4739 CmdArgs.push_back(TmpPath);
4740 }
4741
4742 // Derived from the "link" spec.
4743 Args.AddAllArgs(CmdArgs, options::OPT_static);
4744 if (!Args.hasArg(options::OPT_static))
4745 CmdArgs.push_back("-dynamic");
4746 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4747 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4748 // here. How do we wish to handle such things?
4749 }
4750
4751 if (!Args.hasArg(options::OPT_dynamiclib)) {
4752 AddDarwinArch(Args, CmdArgs);
4753 // FIXME: Why do this only on this path?
4754 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4755
4756 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4757 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4758 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4759
4760 Arg *A;
4761 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4762 (A = Args.getLastArg(options::OPT_current__version)) ||
4763 (A = Args.getLastArg(options::OPT_install__name)))
4764 D.Diag(diag::err_drv_argument_only_allowed_with)
4765 << A->getAsString(Args) << "-dynamiclib";
4766
4767 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4768 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4769 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4770 } else {
4771 CmdArgs.push_back("-dylib");
4772
4773 Arg *A;
4774 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4775 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4776 (A = Args.getLastArg(options::OPT_client__name)) ||
4777 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4778 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4779 (A = Args.getLastArg(options::OPT_private__bundle)))
4780 D.Diag(diag::err_drv_argument_not_allowed_with)
4781 << A->getAsString(Args) << "-dynamiclib";
4782
4783 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4784 "-dylib_compatibility_version");
4785 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4786 "-dylib_current_version");
4787
4788 AddDarwinArch(Args, CmdArgs);
4789
4790 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4791 "-dylib_install_name");
4792 }
4793
4794 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4795 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4796 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4797 if (DarwinTC.isTargetIPhoneOS())
4798 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4799 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4800 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4801 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4802 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4803 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4804 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4805 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4806 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4807 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4808 Args.AddAllArgs(CmdArgs, options::OPT_init);
4809
4810 // Add the deployment target.
4811 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4812
4813 // If we had an explicit -mios-simulator-version-min argument, honor that,
4814 // otherwise use the traditional deployment targets. We can't just check the
4815 // is-sim attribute because existing code follows this path, and the linker
4816 // may not handle the argument.
4817 //
4818 // FIXME: We may be able to remove this, once we can verify no one depends on
4819 // it.
4820 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4821 CmdArgs.push_back("-ios_simulator_version_min");
4822 else if (DarwinTC.isTargetIPhoneOS())
4823 CmdArgs.push_back("-iphoneos_version_min");
4824 else
4825 CmdArgs.push_back("-macosx_version_min");
4826 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4827
4828 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4829 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4830 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4831 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4832 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4833
4834 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4835 options::OPT_fno_pie,
4836 options::OPT_fno_PIE)) {
4837 if (A->getOption().matches(options::OPT_fpie) ||
4838 A->getOption().matches(options::OPT_fPIE))
4839 CmdArgs.push_back("-pie");
4840 else
4841 CmdArgs.push_back("-no_pie");
4842 }
4843
4844 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4845 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4846 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4847 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4848 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4849 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4850 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4851 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4852 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4853 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4854 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4855 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4856 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4857 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4858 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4859 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4860
4861 // Give --sysroot= preference, over the Apple specific behavior to also use
4862 // --isysroot as the syslibroot.
4863 StringRef sysroot = C.getSysRoot();
4864 if (sysroot != "") {
4865 CmdArgs.push_back("-syslibroot");
4866 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4867 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4868 CmdArgs.push_back("-syslibroot");
4869 CmdArgs.push_back(A->getValue());
4870 }
4871
4872 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4873 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4874 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4875 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4876 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4877 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4878 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4879 Args.AddAllArgs(CmdArgs, options::OPT_y);
4880 Args.AddLastArg(CmdArgs, options::OPT_w);
4881 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4882 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4883 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4884 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4885 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4886 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4887 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4888 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4889 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4890 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4891 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4892 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4893}
4894
4895void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4896 const InputInfo &Output,
4897 const InputInfoList &Inputs,
4898 const ArgList &Args,
4899 const char *LinkingOutput) const {
4900 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4901
4902 // The logic here is derived from gcc's behavior; most of which
4903 // comes from specs (starting with link_command). Consult gcc for
4904 // more information.
4905 ArgStringList CmdArgs;
4906
4907 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4908 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4909 options::OPT_ccc_arcmt_migrate)) {
4910 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4911 (*I)->claim();
4912 const char *Exec =
4913 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4914 CmdArgs.push_back(Output.getFilename());
4915 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4916 return;
4917 }
4918
4919 // I'm not sure why this particular decomposition exists in gcc, but
4920 // we follow suite for ease of comparison.
4921 AddLinkArgs(C, Args, CmdArgs, Inputs);
4922
4923 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4924 Args.AddAllArgs(CmdArgs, options::OPT_s);
4925 Args.AddAllArgs(CmdArgs, options::OPT_t);
4926 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4927 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4928 Args.AddLastArg(CmdArgs, options::OPT_e);
4929 Args.AddAllArgs(CmdArgs, options::OPT_r);
4930
4931 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4932 // members of static archive libraries which implement Objective-C classes or
4933 // categories.
4934 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4935 CmdArgs.push_back("-ObjC");
4936
4937 CmdArgs.push_back("-o");
4938 CmdArgs.push_back(Output.getFilename());
4939
4940 if (!Args.hasArg(options::OPT_nostdlib) &&
4941 !Args.hasArg(options::OPT_nostartfiles)) {
4942 // Derived from startfile spec.
4943 if (Args.hasArg(options::OPT_dynamiclib)) {
4944 // Derived from darwin_dylib1 spec.
4945 if (getDarwinToolChain().isTargetIOSSimulator()) {
4946 // The simulator doesn't have a versioned crt1 file.
4947 CmdArgs.push_back("-ldylib1.o");
4948 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4949 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4950 CmdArgs.push_back("-ldylib1.o");
4951 } else {
4952 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4953 CmdArgs.push_back("-ldylib1.o");
4954 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4955 CmdArgs.push_back("-ldylib1.10.5.o");
4956 }
4957 } else {
4958 if (Args.hasArg(options::OPT_bundle)) {
4959 if (!Args.hasArg(options::OPT_static)) {
4960 // Derived from darwin_bundle1 spec.
4961 if (getDarwinToolChain().isTargetIOSSimulator()) {
4962 // The simulator doesn't have a versioned crt1 file.
4963 CmdArgs.push_back("-lbundle1.o");
4964 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4965 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4966 CmdArgs.push_back("-lbundle1.o");
4967 } else {
4968 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4969 CmdArgs.push_back("-lbundle1.o");
4970 }
4971 }
4972 } else {
4973 if (Args.hasArg(options::OPT_pg) &&
4974 getToolChain().SupportsProfiling()) {
4975 if (Args.hasArg(options::OPT_static) ||
4976 Args.hasArg(options::OPT_object) ||
4977 Args.hasArg(options::OPT_preload)) {
4978 CmdArgs.push_back("-lgcrt0.o");
4979 } else {
4980 CmdArgs.push_back("-lgcrt1.o");
4981
4982 // darwin_crt2 spec is empty.
4983 }
4984 // By default on OS X 10.8 and later, we don't link with a crt1.o
4985 // file and the linker knows to use _main as the entry point. But,
4986 // when compiling with -pg, we need to link with the gcrt1.o file,
4987 // so pass the -no_new_main option to tell the linker to use the
4988 // "start" symbol as the entry point.
4989 if (getDarwinToolChain().isTargetMacOS() &&
4990 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4991 CmdArgs.push_back("-no_new_main");
4992 } else {
4993 if (Args.hasArg(options::OPT_static) ||
4994 Args.hasArg(options::OPT_object) ||
4995 Args.hasArg(options::OPT_preload)) {
4996 CmdArgs.push_back("-lcrt0.o");
4997 } else {
4998 // Derived from darwin_crt1 spec.
4999 if (getDarwinToolChain().isTargetIOSSimulator()) {
5000 // The simulator doesn't have a versioned crt1 file.
5001 CmdArgs.push_back("-lcrt1.o");
5002 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
5003 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
5004 CmdArgs.push_back("-lcrt1.o");
5005 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
5006 CmdArgs.push_back("-lcrt1.3.1.o");
5007 } else {
5008 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
5009 CmdArgs.push_back("-lcrt1.o");
5010 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
5011 CmdArgs.push_back("-lcrt1.10.5.o");
5012 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
5013 CmdArgs.push_back("-lcrt1.10.6.o");
5014
5015 // darwin_crt2 spec is empty.
5016 }
5017 }
5018 }
5019 }
5020 }
5021
5022 if (!getDarwinToolChain().isTargetIPhoneOS() &&
5023 Args.hasArg(options::OPT_shared_libgcc) &&
5024 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
5025 const char *Str =
5026 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
5027 CmdArgs.push_back(Str);
5028 }
5029 }
5030
5031 Args.AddAllArgs(CmdArgs, options::OPT_L);
5032
5033 if (Args.hasArg(options::OPT_fopenmp))
5034 // This is more complicated in gcc...
5035 CmdArgs.push_back("-lgomp");
5036
5037 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5038
5039 if (isObjCRuntimeLinked(Args) &&
5040 !Args.hasArg(options::OPT_nostdlib) &&
5041 !Args.hasArg(options::OPT_nodefaultlibs)) {
5042 // Avoid linking compatibility stubs on i386 mac.
5043 if (!getDarwinToolChain().isTargetMacOS() ||
5044 getDarwinToolChain().getArch() != llvm::Triple::x86) {
5045 // If we don't have ARC or subscripting runtime support, link in the
5046 // runtime stubs. We have to do this *before* adding any of the normal
5047 // linker inputs so that its initializer gets run first.
5048 ObjCRuntime runtime =
5049 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
5050 // We use arclite library for both ARC and subscripting support.
5051 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
5052 !runtime.hasSubscripting())
5053 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
5054 }
5055 CmdArgs.push_back("-framework");
5056 CmdArgs.push_back("Foundation");
5057 // Link libobj.
5058 CmdArgs.push_back("-lobjc");
5059 }
5060
5061 if (LinkingOutput) {
5062 CmdArgs.push_back("-arch_multiple");
5063 CmdArgs.push_back("-final_output");
5064 CmdArgs.push_back(LinkingOutput);
5065 }
5066
5067 if (Args.hasArg(options::OPT_fnested_functions))
5068 CmdArgs.push_back("-allow_stack_execute");
5069
5070 if (!Args.hasArg(options::OPT_nostdlib) &&
5071 !Args.hasArg(options::OPT_nodefaultlibs)) {
5072 if (getToolChain().getDriver().CCCIsCXX())
5073 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5074
5075 // link_ssp spec is empty.
5076
5077 // Let the tool chain choose which runtime library to link.
5078 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5079 }
5080
5081 if (!Args.hasArg(options::OPT_nostdlib) &&
5082 !Args.hasArg(options::OPT_nostartfiles)) {
5083 // endfile_spec is empty.
5084 }
5085
5086 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5087 Args.AddAllArgs(CmdArgs, options::OPT_F);
5088
5089 const char *Exec =
5090 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5091 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5092}
5093
5094void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
5095 const InputInfo &Output,
5096 const InputInfoList &Inputs,
5097 const ArgList &Args,
5098 const char *LinkingOutput) const {
5099 ArgStringList CmdArgs;
5100
5101 CmdArgs.push_back("-create");
5102 assert(Output.isFilename() && "Unexpected lipo output.");
5103
5104 CmdArgs.push_back("-output");
5105 CmdArgs.push_back(Output.getFilename());
5106
5107 for (InputInfoList::const_iterator
5108 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5109 const InputInfo &II = *it;
5110 assert(II.isFilename() && "Unexpected lipo input.");
5111 CmdArgs.push_back(II.getFilename());
5112 }
5113 const char *Exec =
5114 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5115 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5116}
5117
5118void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
5119 const InputInfo &Output,
5120 const InputInfoList &Inputs,
5121 const ArgList &Args,
5122 const char *LinkingOutput) const {
5123 ArgStringList CmdArgs;
5124
5125 CmdArgs.push_back("-o");
5126 CmdArgs.push_back(Output.getFilename());
5127
5128 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5129 const InputInfo &Input = Inputs[0];
5130 assert(Input.isFilename() && "Unexpected dsymutil input.");
5131 CmdArgs.push_back(Input.getFilename());
5132
5133 const char *Exec =
5134 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5135 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5136}
5137
5138void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
5139 const InputInfo &Output,
5140 const InputInfoList &Inputs,
5141 const ArgList &Args,
5142 const char *LinkingOutput) const {
5143 ArgStringList CmdArgs;
5144 CmdArgs.push_back("--verify");
5145 CmdArgs.push_back("--debug-info");
5146 CmdArgs.push_back("--eh-frame");
5147 CmdArgs.push_back("--quiet");
5148
5149 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5150 const InputInfo &Input = Inputs[0];
5151 assert(Input.isFilename() && "Unexpected verify input");
5152
5153 // Grabbing the output of the earlier dsymutil run.
5154 CmdArgs.push_back(Input.getFilename());
5155
5156 const char *Exec =
5157 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5158 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5159}
5160
5161void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5162 const InputInfo &Output,
5163 const InputInfoList &Inputs,
5164 const ArgList &Args,
5165 const char *LinkingOutput) const {
5166 ArgStringList CmdArgs;
5167
5168 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5169 options::OPT_Xassembler);
5170
5171 CmdArgs.push_back("-o");
5172 CmdArgs.push_back(Output.getFilename());
5173
5174 for (InputInfoList::const_iterator
5175 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5176 const InputInfo &II = *it;
5177 CmdArgs.push_back(II.getFilename());
5178 }
5179
5180 const char *Exec =
5181 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5182 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5183}
5184
5185
5186void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5187 const InputInfo &Output,
5188 const InputInfoList &Inputs,
5189 const ArgList &Args,
5190 const char *LinkingOutput) const {
5191 // FIXME: Find a real GCC, don't hard-code versions here
5192 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5193 const llvm::Triple &T = getToolChain().getTriple();
5194 std::string LibPath = "/usr/lib/";
5195 llvm::Triple::ArchType Arch = T.getArch();
5196 switch (Arch) {
5197 case llvm::Triple::x86:
5198 GCCLibPath +=
5199 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5200 break;
5201 case llvm::Triple::x86_64:
5202 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5203 GCCLibPath += "/4.5.2/amd64/";
5204 LibPath += "amd64/";
5205 break;
5206 default:
5207 llvm_unreachable("Unsupported architecture");
5208 }
5209
5210 ArgStringList CmdArgs;
5211
5212 // Demangle C++ names in errors
5213 CmdArgs.push_back("-C");
5214
5215 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5216 (!Args.hasArg(options::OPT_shared))) {
5217 CmdArgs.push_back("-e");
5218 CmdArgs.push_back("_start");
5219 }
5220
5221 if (Args.hasArg(options::OPT_static)) {
5222 CmdArgs.push_back("-Bstatic");
5223 CmdArgs.push_back("-dn");
5224 } else {
5225 CmdArgs.push_back("-Bdynamic");
5226 if (Args.hasArg(options::OPT_shared)) {
5227 CmdArgs.push_back("-shared");
5228 } else {
5229 CmdArgs.push_back("--dynamic-linker");
5230 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5231 }
5232 }
5233
5234 if (Output.isFilename()) {
5235 CmdArgs.push_back("-o");
5236 CmdArgs.push_back(Output.getFilename());
5237 } else {
5238 assert(Output.isNothing() && "Invalid output.");
5239 }
5240
5241 if (!Args.hasArg(options::OPT_nostdlib) &&
5242 !Args.hasArg(options::OPT_nostartfiles)) {
5243 if (!Args.hasArg(options::OPT_shared)) {
5244 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5245 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5246 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5247 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5248 } else {
5249 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5250 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5251 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5252 }
5253 if (getToolChain().getDriver().CCCIsCXX())
5254 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5255 }
5256
5257 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5258
5259 Args.AddAllArgs(CmdArgs, options::OPT_L);
5260 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5261 Args.AddAllArgs(CmdArgs, options::OPT_e);
5262 Args.AddAllArgs(CmdArgs, options::OPT_r);
5263
5264 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5265
5266 if (!Args.hasArg(options::OPT_nostdlib) &&
5267 !Args.hasArg(options::OPT_nodefaultlibs)) {
5268 if (getToolChain().getDriver().CCCIsCXX())
5269 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5270 CmdArgs.push_back("-lgcc_s");
5271 if (!Args.hasArg(options::OPT_shared)) {
5272 CmdArgs.push_back("-lgcc");
5273 CmdArgs.push_back("-lc");
5274 CmdArgs.push_back("-lm");
5275 }
5276 }
5277
5278 if (!Args.hasArg(options::OPT_nostdlib) &&
5279 !Args.hasArg(options::OPT_nostartfiles)) {
5280 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5281 }
5282 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5283
5284 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5285
5286 const char *Exec =
5287 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5288 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5289}
5290
5291void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5292 const InputInfo &Output,
5293 const InputInfoList &Inputs,
5294 const ArgList &Args,
5295 const char *LinkingOutput) const {
5296 ArgStringList CmdArgs;
5297
5298 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5299 options::OPT_Xassembler);
5300
5301 CmdArgs.push_back("-o");
5302 CmdArgs.push_back(Output.getFilename());
5303
5304 for (InputInfoList::const_iterator
5305 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5306 const InputInfo &II = *it;
5307 CmdArgs.push_back(II.getFilename());
5308 }
5309
5310 const char *Exec =
5311 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5312 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5313}
5314
5315void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
5316 const InputInfo &Output,
5317 const InputInfoList &Inputs,
5318 const ArgList &Args,
5319 const char *LinkingOutput) const {
5320 ArgStringList CmdArgs;
5321
5322 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5323 (!Args.hasArg(options::OPT_shared))) {
5324 CmdArgs.push_back("-e");
5325 CmdArgs.push_back("_start");
5326 }
5327
5328 if (Args.hasArg(options::OPT_static)) {
5329 CmdArgs.push_back("-Bstatic");
5330 CmdArgs.push_back("-dn");
5331 } else {
5332// CmdArgs.push_back("--eh-frame-hdr");
5333 CmdArgs.push_back("-Bdynamic");
5334 if (Args.hasArg(options::OPT_shared)) {
5335 CmdArgs.push_back("-shared");
5336 } else {
5337 CmdArgs.push_back("--dynamic-linker");
5338 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5339 }
5340 }
5341
5342 if (Output.isFilename()) {
5343 CmdArgs.push_back("-o");
5344 CmdArgs.push_back(Output.getFilename());
5345 } else {
5346 assert(Output.isNothing() && "Invalid output.");
5347 }
5348
5349 if (!Args.hasArg(options::OPT_nostdlib) &&
5350 !Args.hasArg(options::OPT_nostartfiles)) {
5351 if (!Args.hasArg(options::OPT_shared)) {
5352 CmdArgs.push_back(Args.MakeArgString(
5353 getToolChain().GetFilePath("crt1.o")));
5354 CmdArgs.push_back(Args.MakeArgString(
5355 getToolChain().GetFilePath("crti.o")));
5356 CmdArgs.push_back(Args.MakeArgString(
5357 getToolChain().GetFilePath("crtbegin.o")));
5358 } else {
5359 CmdArgs.push_back(Args.MakeArgString(
5360 getToolChain().GetFilePath("crti.o")));
5361 }
5362 CmdArgs.push_back(Args.MakeArgString(
5363 getToolChain().GetFilePath("crtn.o")));
5364 }
5365
5366 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5367 + getToolChain().getTripleString()
5368 + "/4.2.4"));
5369
5370 Args.AddAllArgs(CmdArgs, options::OPT_L);
5371 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5372 Args.AddAllArgs(CmdArgs, options::OPT_e);
5373
5374 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5375
5376 if (!Args.hasArg(options::OPT_nostdlib) &&
5377 !Args.hasArg(options::OPT_nodefaultlibs)) {
5378 // FIXME: For some reason GCC passes -lgcc before adding
5379 // the default system libraries. Just mimic this for now.
5380 CmdArgs.push_back("-lgcc");
5381
5382 if (Args.hasArg(options::OPT_pthread))
5383 CmdArgs.push_back("-pthread");
5384 if (!Args.hasArg(options::OPT_shared))
5385 CmdArgs.push_back("-lc");
5386 CmdArgs.push_back("-lgcc");
5387 }
5388
5389 if (!Args.hasArg(options::OPT_nostdlib) &&
5390 !Args.hasArg(options::OPT_nostartfiles)) {
5391 if (!Args.hasArg(options::OPT_shared))
5392 CmdArgs.push_back(Args.MakeArgString(
5393 getToolChain().GetFilePath("crtend.o")));
5394 }
5395
5396 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5397
5398 const char *Exec =
5399 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5400 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5401}
5402
5403void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5404 const InputInfo &Output,
5405 const InputInfoList &Inputs,
5406 const ArgList &Args,
5407 const char *LinkingOutput) const {
5408 ArgStringList CmdArgs;
5409
5410 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5411 // instruct as in the base system to assemble 32-bit code.
5412 if (getToolChain().getArch() == llvm::Triple::x86)
5413 CmdArgs.push_back("--32");
5414 else if (getToolChain().getArch() == llvm::Triple::ppc) {
5415 CmdArgs.push_back("-mppc");
5416 CmdArgs.push_back("-many");
5417 } else if (getToolChain().getArch() == llvm::Triple::mips64 ||
5418 getToolChain().getArch() == llvm::Triple::mips64el) {
5419 StringRef CPUName;
5420 StringRef ABIName;
5421 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5422
5423 CmdArgs.push_back("-mabi");
5424 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5425
5426 if (getToolChain().getArch() == llvm::Triple::mips64)
5427 CmdArgs.push_back("-EB");
5428 else
5429 CmdArgs.push_back("-EL");
5430
5431 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5432 options::OPT_fpic, options::OPT_fno_pic,
5433 options::OPT_fPIE, options::OPT_fno_PIE,
5434 options::OPT_fpie, options::OPT_fno_pie);
5435 if (LastPICArg &&
5436 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5437 LastPICArg->getOption().matches(options::OPT_fpic) ||
5438 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5439 LastPICArg->getOption().matches(options::OPT_fpie))) {
5440 CmdArgs.push_back("-KPIC");
5441 }
5442 }
5443
5444 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5445 options::OPT_Xassembler);
5446
5447 CmdArgs.push_back("-o");
5448 CmdArgs.push_back(Output.getFilename());
5449
5450 for (InputInfoList::const_iterator
5451 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5452 const InputInfo &II = *it;
5453 CmdArgs.push_back(II.getFilename());
5454 }
5455
5456 const char *Exec =
5457 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5458 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5459}
5460
5461void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5462 const InputInfo &Output,
5463 const InputInfoList &Inputs,
5464 const ArgList &Args,
5465 const char *LinkingOutput) const {
5466 const Driver &D = getToolChain().getDriver();
5467 ArgStringList CmdArgs;
5468
5469 // Silence warning for "clang -g foo.o -o foo"
5470 Args.ClaimAllArgs(options::OPT_g_Group);
5471 // and "clang -emit-llvm foo.o -o foo"
5472 Args.ClaimAllArgs(options::OPT_emit_llvm);
5473 // and for "clang -w foo.o -o foo". Other warning options are already
5474 // handled somewhere else.
5475 Args.ClaimAllArgs(options::OPT_w);
5476
5477 if (getToolChain().getArch() == llvm::Triple::mips64)
5478 CmdArgs.push_back("-EB");
5479 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5480 CmdArgs.push_back("-EL");
5481
5482 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5483 (!Args.hasArg(options::OPT_shared))) {
5484 CmdArgs.push_back("-e");
5485 CmdArgs.push_back("__start");
5486 }
5487
5488 if (Args.hasArg(options::OPT_static)) {
5489 CmdArgs.push_back("-Bstatic");
5490 } else {
5491 if (Args.hasArg(options::OPT_rdynamic))
5492 CmdArgs.push_back("-export-dynamic");
5493 CmdArgs.push_back("--eh-frame-hdr");
5494 CmdArgs.push_back("-Bdynamic");
5495 if (Args.hasArg(options::OPT_shared)) {
5496 CmdArgs.push_back("-shared");
5497 } else {
5498 CmdArgs.push_back("-dynamic-linker");
5499 CmdArgs.push_back("/usr/libexec/ld.so");
5500 }
5501 }
5502
5503 if (Args.hasArg(options::OPT_nopie))
5504 CmdArgs.push_back("-nopie");
5505
5506 if (Output.isFilename()) {
5507 CmdArgs.push_back("-o");
5508 CmdArgs.push_back(Output.getFilename());
5509 } else {
5510 assert(Output.isNothing() && "Invalid output.");
5511 }
5512
5513 if (!Args.hasArg(options::OPT_nostdlib) &&
5514 !Args.hasArg(options::OPT_nostartfiles)) {
5515 if (!Args.hasArg(options::OPT_shared)) {
5516 if (Args.hasArg(options::OPT_pg))
5517 CmdArgs.push_back(Args.MakeArgString(
5518 getToolChain().GetFilePath("gcrt0.o")));
5519 else
5520 CmdArgs.push_back(Args.MakeArgString(
5521 getToolChain().GetFilePath("crt0.o")));
5522 CmdArgs.push_back(Args.MakeArgString(
5523 getToolChain().GetFilePath("crtbegin.o")));
5524 } else {
5525 CmdArgs.push_back(Args.MakeArgString(
5526 getToolChain().GetFilePath("crtbeginS.o")));
5527 }
5528 }
5529
5530 std::string Triple = getToolChain().getTripleString();
5531 if (Triple.substr(0, 6) == "x86_64")
5532 Triple.replace(0, 6, "amd64");
5533 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
5534 "/4.2.1"));
5535
5536 Args.AddAllArgs(CmdArgs, options::OPT_L);
5537 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5538 Args.AddAllArgs(CmdArgs, options::OPT_e);
5539 Args.AddAllArgs(CmdArgs, options::OPT_s);
5540 Args.AddAllArgs(CmdArgs, options::OPT_t);
5541 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5542 Args.AddAllArgs(CmdArgs, options::OPT_r);
5543
5544 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5545
5546 if (!Args.hasArg(options::OPT_nostdlib) &&
5547 !Args.hasArg(options::OPT_nodefaultlibs)) {
5548 if (D.CCCIsCXX()) {
5549 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5550 if (Args.hasArg(options::OPT_pg))
5551 CmdArgs.push_back("-lm_p");
5552 else
5553 CmdArgs.push_back("-lm");
5554 }
5555
5556 // FIXME: For some reason GCC passes -lgcc before adding
5557 // the default system libraries. Just mimic this for now.
5558 CmdArgs.push_back("-lgcc");
5559
5560 if (Args.hasArg(options::OPT_pthread)) {
5561 if (!Args.hasArg(options::OPT_shared) &&
5562 Args.hasArg(options::OPT_pg))
5563 CmdArgs.push_back("-lpthread_p");
5564 else
5565 CmdArgs.push_back("-lpthread");
5566 }
5567
5568 if (!Args.hasArg(options::OPT_shared)) {
5569 if (Args.hasArg(options::OPT_pg))
5570 CmdArgs.push_back("-lc_p");
5571 else
5572 CmdArgs.push_back("-lc");
5573 }
5574
5575 CmdArgs.push_back("-lgcc");
5576 }
5577
5578 if (!Args.hasArg(options::OPT_nostdlib) &&
5579 !Args.hasArg(options::OPT_nostartfiles)) {
5580 if (!Args.hasArg(options::OPT_shared))
5581 CmdArgs.push_back(Args.MakeArgString(
5582 getToolChain().GetFilePath("crtend.o")));
5583 else
5584 CmdArgs.push_back(Args.MakeArgString(
5585 getToolChain().GetFilePath("crtendS.o")));
5586 }
5587
5588 const char *Exec =
5589 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5590 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5591}
5592
5593void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5594 const InputInfo &Output,
5595 const InputInfoList &Inputs,
5596 const ArgList &Args,
5597 const char *LinkingOutput) const {
5598 ArgStringList CmdArgs;
5599
5600 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5601 options::OPT_Xassembler);
5602
5603 CmdArgs.push_back("-o");
5604 CmdArgs.push_back(Output.getFilename());
5605
5606 for (InputInfoList::const_iterator
5607 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5608 const InputInfo &II = *it;
5609 CmdArgs.push_back(II.getFilename());
5610 }
5611
5612 const char *Exec =
5613 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5614 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5615}
5616
5617void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5618 const InputInfo &Output,
5619 const InputInfoList &Inputs,
5620 const ArgList &Args,
5621 const char *LinkingOutput) const {
5622 const Driver &D = getToolChain().getDriver();
5623 ArgStringList CmdArgs;
5624
5625 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5626 (!Args.hasArg(options::OPT_shared))) {
5627 CmdArgs.push_back("-e");
5628 CmdArgs.push_back("__start");
5629 }
5630
5631 if (Args.hasArg(options::OPT_static)) {
5632 CmdArgs.push_back("-Bstatic");
5633 } else {
5634 if (Args.hasArg(options::OPT_rdynamic))
5635 CmdArgs.push_back("-export-dynamic");
5636 CmdArgs.push_back("--eh-frame-hdr");
5637 CmdArgs.push_back("-Bdynamic");
5638 if (Args.hasArg(options::OPT_shared)) {
5639 CmdArgs.push_back("-shared");
5640 } else {
5641 CmdArgs.push_back("-dynamic-linker");
5642 CmdArgs.push_back("/usr/libexec/ld.so");
5643 }
5644 }
5645
5646 if (Output.isFilename()) {
5647 CmdArgs.push_back("-o");
5648 CmdArgs.push_back(Output.getFilename());
5649 } else {
5650 assert(Output.isNothing() && "Invalid output.");
5651 }
5652
5653 if (!Args.hasArg(options::OPT_nostdlib) &&
5654 !Args.hasArg(options::OPT_nostartfiles)) {
5655 if (!Args.hasArg(options::OPT_shared)) {
5656 if (Args.hasArg(options::OPT_pg))
5657 CmdArgs.push_back(Args.MakeArgString(
5658 getToolChain().GetFilePath("gcrt0.o")));
5659 else
5660 CmdArgs.push_back(Args.MakeArgString(
5661 getToolChain().GetFilePath("crt0.o")));
5662 CmdArgs.push_back(Args.MakeArgString(
5663 getToolChain().GetFilePath("crtbegin.o")));
5664 } else {
5665 CmdArgs.push_back(Args.MakeArgString(
5666 getToolChain().GetFilePath("crtbeginS.o")));
5667 }
5668 }
5669
5670 Args.AddAllArgs(CmdArgs, options::OPT_L);
5671 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5672 Args.AddAllArgs(CmdArgs, options::OPT_e);
5673
5674 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5675
5676 if (!Args.hasArg(options::OPT_nostdlib) &&
5677 !Args.hasArg(options::OPT_nodefaultlibs)) {
5678 if (D.CCCIsCXX()) {
5679 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5680 if (Args.hasArg(options::OPT_pg))
5681 CmdArgs.push_back("-lm_p");
5682 else
5683 CmdArgs.push_back("-lm");
5684 }
5685
5686 if (Args.hasArg(options::OPT_pthread)) {
5687 if (!Args.hasArg(options::OPT_shared) &&
5688 Args.hasArg(options::OPT_pg))
5689 CmdArgs.push_back("-lpthread_p");
5690 else
5691 CmdArgs.push_back("-lpthread");
5692 }
5693
5694 if (!Args.hasArg(options::OPT_shared)) {
5695 if (Args.hasArg(options::OPT_pg))
5696 CmdArgs.push_back("-lc_p");
5697 else
5698 CmdArgs.push_back("-lc");
5699 }
5700
5701 StringRef MyArch;
5702 switch (getToolChain().getTriple().getArch()) {
5703 case llvm::Triple::arm:
5704 MyArch = "arm";
5705 break;
5706 case llvm::Triple::x86:
5707 MyArch = "i386";
5708 break;
5709 case llvm::Triple::x86_64:
5710 MyArch = "amd64";
5711 break;
5712 default:
5713 llvm_unreachable("Unsupported architecture");
5714 }
5715 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
5716 }
5717
5718 if (!Args.hasArg(options::OPT_nostdlib) &&
5719 !Args.hasArg(options::OPT_nostartfiles)) {
5720 if (!Args.hasArg(options::OPT_shared))
5721 CmdArgs.push_back(Args.MakeArgString(
5722 getToolChain().GetFilePath("crtend.o")));
5723 else
5724 CmdArgs.push_back(Args.MakeArgString(
5725 getToolChain().GetFilePath("crtendS.o")));
5726 }
5727
5728 const char *Exec =
5729 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5730 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5731}
5732
5733void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5734 const InputInfo &Output,
5735 const InputInfoList &Inputs,
5736 const ArgList &Args,
5737 const char *LinkingOutput) const {
5738 ArgStringList CmdArgs;
5739
5740 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5741 // instruct as in the base system to assemble 32-bit code.
5742 if (getToolChain().getArch() == llvm::Triple::x86)
5743 CmdArgs.push_back("--32");
5744 else if (getToolChain().getArch() == llvm::Triple::ppc)
5745 CmdArgs.push_back("-a32");
5746 else if (getToolChain().getArch() == llvm::Triple::mips ||
5747 getToolChain().getArch() == llvm::Triple::mipsel ||
5748 getToolChain().getArch() == llvm::Triple::mips64 ||
5749 getToolChain().getArch() == llvm::Triple::mips64el) {
5750 StringRef CPUName;
5751 StringRef ABIName;
5752 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5753
5754 CmdArgs.push_back("-march");
5755 CmdArgs.push_back(CPUName.data());
5756
5757 CmdArgs.push_back("-mabi");
5758 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5759
5760 if (getToolChain().getArch() == llvm::Triple::mips ||
5761 getToolChain().getArch() == llvm::Triple::mips64)
5762 CmdArgs.push_back("-EB");
5763 else
5764 CmdArgs.push_back("-EL");
5765
5766 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5767 options::OPT_fpic, options::OPT_fno_pic,
5768 options::OPT_fPIE, options::OPT_fno_PIE,
5769 options::OPT_fpie, options::OPT_fno_pie);
5770 if (LastPICArg &&
5771 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5772 LastPICArg->getOption().matches(options::OPT_fpic) ||
5773 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5774 LastPICArg->getOption().matches(options::OPT_fpie))) {
5775 CmdArgs.push_back("-KPIC");
5776 }
5777 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5778 getToolChain().getArch() == llvm::Triple::thumb) {
5779 CmdArgs.push_back("-mfpu=softvfp");
5780 switch(getToolChain().getTriple().getEnvironment()) {
5781 case llvm::Triple::GNUEABI:
5782 case llvm::Triple::EABI:
5783 CmdArgs.push_back("-meabi=5");
5784 break;
5785
5786 default:
5787 CmdArgs.push_back("-matpcs");
5788 }
5789 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
5790 getToolChain().getArch() == llvm::Triple::sparcv9) {
5791 if (getToolChain().getArch() == llvm::Triple::sparc)
5792 CmdArgs.push_back("-Av8plusa");
5793 else
5794 CmdArgs.push_back("-Av9a");
5795
5796 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5797 options::OPT_fpic, options::OPT_fno_pic,
5798 options::OPT_fPIE, options::OPT_fno_PIE,
5799 options::OPT_fpie, options::OPT_fno_pie);
5800 if (LastPICArg &&
5801 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5802 LastPICArg->getOption().matches(options::OPT_fpic) ||
5803 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5804 LastPICArg->getOption().matches(options::OPT_fpie))) {
5805 CmdArgs.push_back("-KPIC");
5806 }
5807 }
5808
5809 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5810 options::OPT_Xassembler);
5811
5812 CmdArgs.push_back("-o");
5813 CmdArgs.push_back(Output.getFilename());
5814
5815 for (InputInfoList::const_iterator
5816 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5817 const InputInfo &II = *it;
5818 CmdArgs.push_back(II.getFilename());
5819 }
5820
5821 const char *Exec =
5822 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5823 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5824}
5825
5826void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5827 const InputInfo &Output,
5828 const InputInfoList &Inputs,
5829 const ArgList &Args,
5830 const char *LinkingOutput) const {
5831 const toolchains::FreeBSD& ToolChain =
5832 static_cast<const toolchains::FreeBSD&>(getToolChain());
5833 const Driver &D = ToolChain.getDriver();
5834 ArgStringList CmdArgs;
5835
5836 // Silence warning for "clang -g foo.o -o foo"
5837 Args.ClaimAllArgs(options::OPT_g_Group);
5838 // and "clang -emit-llvm foo.o -o foo"
5839 Args.ClaimAllArgs(options::OPT_emit_llvm);
5840 // and for "clang -w foo.o -o foo". Other warning options are already
5841 // handled somewhere else.
5842 Args.ClaimAllArgs(options::OPT_w);
5843
5844 if (!D.SysRoot.empty())
5845 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5846
5847 if (Args.hasArg(options::OPT_pie))
5848 CmdArgs.push_back("-pie");
5849
5850 if (Args.hasArg(options::OPT_static)) {
5851 CmdArgs.push_back("-Bstatic");
5852 } else {
5853 if (Args.hasArg(options::OPT_rdynamic))
5854 CmdArgs.push_back("-export-dynamic");
5855 CmdArgs.push_back("--eh-frame-hdr");
5856 if (Args.hasArg(options::OPT_shared)) {
5857 CmdArgs.push_back("-Bshareable");
5858 } else {
5859 CmdArgs.push_back("-dynamic-linker");
5860 CmdArgs.push_back("/libexec/ld-elf.so.1");
5861 }
5862 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5863 llvm::Triple::ArchType Arch = ToolChain.getArch();
5864 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5865 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5866 CmdArgs.push_back("--hash-style=both");
5867 }
5868 }
5869 CmdArgs.push_back("--enable-new-dtags");
5870 }
5871
5872 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5873 // instruct ld in the base system to link 32-bit code.
5874 if (ToolChain.getArch() == llvm::Triple::x86) {
5875 CmdArgs.push_back("-m");
5876 CmdArgs.push_back("elf_i386_fbsd");
5877 }
5878
5879 if (ToolChain.getArch() == llvm::Triple::ppc) {
5880 CmdArgs.push_back("-m");
5881 CmdArgs.push_back("elf32ppc_fbsd");
5882 }
5883
5884 if (Output.isFilename()) {
5885 CmdArgs.push_back("-o");
5886 CmdArgs.push_back(Output.getFilename());
5887 } else {
5888 assert(Output.isNothing() && "Invalid output.");
5889 }
5890
5891 if (!Args.hasArg(options::OPT_nostdlib) &&
5892 !Args.hasArg(options::OPT_nostartfiles)) {
5893 const char *crt1 = NULL;
5894 if (!Args.hasArg(options::OPT_shared)) {
5895 if (Args.hasArg(options::OPT_pg))
5896 crt1 = "gcrt1.o";
5897 else if (Args.hasArg(options::OPT_pie))
5898 crt1 = "Scrt1.o";
5899 else
5900 crt1 = "crt1.o";
5901 }
5902 if (crt1)
5903 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5904
5905 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5906
5907 const char *crtbegin = NULL;
5908 if (Args.hasArg(options::OPT_static))
5909 crtbegin = "crtbeginT.o";
5910 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5911 crtbegin = "crtbeginS.o";
5912 else
5913 crtbegin = "crtbegin.o";
5914
5915 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5916 }
5917
5918 Args.AddAllArgs(CmdArgs, options::OPT_L);
5919 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5920 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5921 i != e; ++i)
5922 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5923 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5924 Args.AddAllArgs(CmdArgs, options::OPT_e);
5925 Args.AddAllArgs(CmdArgs, options::OPT_s);
5926 Args.AddAllArgs(CmdArgs, options::OPT_t);
5927 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5928 Args.AddAllArgs(CmdArgs, options::OPT_r);
5929
5930 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5931 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5932 // forward.
5933 if (D.IsUsingLTO(Args)) {
5934 CmdArgs.push_back("-plugin");
5935 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5936 CmdArgs.push_back(Args.MakeArgString(Plugin));
5937
5938 // Try to pass driver level flags relevant to LTO code generation down to
5939 // the plugin.
5940
5941 // Handle flags for selecting CPU variants.
5942 std::string CPU = getCPUName(Args, ToolChain.getTriple());
5943 if (!CPU.empty()) {
5944 CmdArgs.push_back(
5945 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5946 CPU));
5947 }
5948 }
5949
5950 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5951
5952 if (!Args.hasArg(options::OPT_nostdlib) &&
5953 !Args.hasArg(options::OPT_nodefaultlibs)) {
5954 if (D.CCCIsCXX()) {
5955 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5956 if (Args.hasArg(options::OPT_pg))
5957 CmdArgs.push_back("-lm_p");
5958 else
5959 CmdArgs.push_back("-lm");
5960 }
5961 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5962 // the default system libraries. Just mimic this for now.
5963 if (Args.hasArg(options::OPT_pg))
5964 CmdArgs.push_back("-lgcc_p");
5965 else
5966 CmdArgs.push_back("-lgcc");
5967 if (Args.hasArg(options::OPT_static)) {
5968 CmdArgs.push_back("-lgcc_eh");
5969 } else if (Args.hasArg(options::OPT_pg)) {
5970 CmdArgs.push_back("-lgcc_eh_p");
5971 } else {
5972 CmdArgs.push_back("--as-needed");
5973 CmdArgs.push_back("-lgcc_s");
5974 CmdArgs.push_back("--no-as-needed");
5975 }
5976
5977 if (Args.hasArg(options::OPT_pthread)) {
5978 if (Args.hasArg(options::OPT_pg))
5979 CmdArgs.push_back("-lpthread_p");
5980 else
5981 CmdArgs.push_back("-lpthread");
5982 }
5983
5984 if (Args.hasArg(options::OPT_pg)) {
5985 if (Args.hasArg(options::OPT_shared))
5986 CmdArgs.push_back("-lc");
5987 else
5988 CmdArgs.push_back("-lc_p");
5989 CmdArgs.push_back("-lgcc_p");
5990 } else {
5991 CmdArgs.push_back("-lc");
5992 CmdArgs.push_back("-lgcc");
5993 }
5994
5995 if (Args.hasArg(options::OPT_static)) {
5996 CmdArgs.push_back("-lgcc_eh");
5997 } else if (Args.hasArg(options::OPT_pg)) {
5998 CmdArgs.push_back("-lgcc_eh_p");
5999 } else {
6000 CmdArgs.push_back("--as-needed");
6001 CmdArgs.push_back("-lgcc_s");
6002 CmdArgs.push_back("--no-as-needed");
6003 }
6004 }
6005
6006 if (!Args.hasArg(options::OPT_nostdlib) &&
6007 !Args.hasArg(options::OPT_nostartfiles)) {
6008 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6009 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6010 else
6011 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6012 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6013 }
6014
6015 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
6016
6017 const char *Exec =
6018 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
6019 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6020}
6021
6022void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6023 const InputInfo &Output,
6024 const InputInfoList &Inputs,
6025 const ArgList &Args,
6026 const char *LinkingOutput) const {
6027 ArgStringList CmdArgs;
6028
6029 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6030 // instruct as in the base system to assemble 32-bit code.
6031 if (getToolChain().getArch() == llvm::Triple::x86)
6032 CmdArgs.push_back("--32");
6033
6034 // Pass the target CPU to GNU as for ARM, since the source code might
6035 // not have the correct .cpu annotation.
6036 if (getToolChain().getArch() == llvm::Triple::arm) {
6037 std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple()));
6038 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6039 }
6040
6041 if (getToolChain().getArch() == llvm::Triple::mips ||
6042 getToolChain().getArch() == llvm::Triple::mipsel ||
6043 getToolChain().getArch() == llvm::Triple::mips64 ||
6044 getToolChain().getArch() == llvm::Triple::mips64el) {
6045 StringRef CPUName;
6046 StringRef ABIName;
6047 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6048
6049 CmdArgs.push_back("-march");
6050 CmdArgs.push_back(CPUName.data());
6051
6052 CmdArgs.push_back("-mabi");
6053 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6054
6055 if (getToolChain().getArch() == llvm::Triple::mips ||
6056 getToolChain().getArch() == llvm::Triple::mips64)
6057 CmdArgs.push_back("-EB");
6058 else
6059 CmdArgs.push_back("-EL");
6060
6061 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6062 options::OPT_fpic, options::OPT_fno_pic,
6063 options::OPT_fPIE, options::OPT_fno_PIE,
6064 options::OPT_fpie, options::OPT_fno_pie);
6065 if (LastPICArg &&
6066 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6067 LastPICArg->getOption().matches(options::OPT_fpic) ||
6068 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6069 LastPICArg->getOption().matches(options::OPT_fpie))) {
6070 CmdArgs.push_back("-KPIC");
6071 }
6072 }
6073
6074 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6075 options::OPT_Xassembler);
6076
6077 CmdArgs.push_back("-o");
6078 CmdArgs.push_back(Output.getFilename());
6079
6080 for (InputInfoList::const_iterator
6081 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6082 const InputInfo &II = *it;
6083 CmdArgs.push_back(II.getFilename());
6084 }
6085
6086 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6087 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6088}
6089
6090void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6091 const InputInfo &Output,
6092 const InputInfoList &Inputs,
6093 const ArgList &Args,
6094 const char *LinkingOutput) const {
6095 const Driver &D = getToolChain().getDriver();
6096 ArgStringList CmdArgs;
6097
6098 if (!D.SysRoot.empty())
6099 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6100
6101 if (Args.hasArg(options::OPT_static)) {
6102 CmdArgs.push_back("-Bstatic");
6103 } else {
6104 if (Args.hasArg(options::OPT_rdynamic))
6105 CmdArgs.push_back("-export-dynamic");
6106 CmdArgs.push_back("--eh-frame-hdr");
6107 if (Args.hasArg(options::OPT_shared)) {
6108 CmdArgs.push_back("-Bshareable");
6109 } else {
6110 CmdArgs.push_back("-dynamic-linker");
6111 CmdArgs.push_back("/libexec/ld.elf_so");
6112 }
6113 }
6114
6115 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6116 // instruct ld in the base system to link 32-bit code.
6117 if (getToolChain().getArch() == llvm::Triple::x86) {
6118 CmdArgs.push_back("-m");
6119 CmdArgs.push_back("elf_i386");
6120 }
6121
6122 if (Output.isFilename()) {
6123 CmdArgs.push_back("-o");
6124 CmdArgs.push_back(Output.getFilename());
6125 } else {
6126 assert(Output.isNothing() && "Invalid output.");
6127 }
6128
6129 if (!Args.hasArg(options::OPT_nostdlib) &&
6130 !Args.hasArg(options::OPT_nostartfiles)) {
6131 if (!Args.hasArg(options::OPT_shared)) {
6132 CmdArgs.push_back(Args.MakeArgString(
6133 getToolChain().GetFilePath("crt0.o")));
6134 CmdArgs.push_back(Args.MakeArgString(
6135 getToolChain().GetFilePath("crti.o")));
6136 CmdArgs.push_back(Args.MakeArgString(
6137 getToolChain().GetFilePath("crtbegin.o")));
6138 } else {
6139 CmdArgs.push_back(Args.MakeArgString(
6140 getToolChain().GetFilePath("crti.o")));
6141 CmdArgs.push_back(Args.MakeArgString(
6142 getToolChain().GetFilePath("crtbeginS.o")));
6143 }
6144 }
6145
6146 Args.AddAllArgs(CmdArgs, options::OPT_L);
6147 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6148 Args.AddAllArgs(CmdArgs, options::OPT_e);
6149 Args.AddAllArgs(CmdArgs, options::OPT_s);
6150 Args.AddAllArgs(CmdArgs, options::OPT_t);
6151 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6152 Args.AddAllArgs(CmdArgs, options::OPT_r);
6153
6154 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6155
6156 unsigned Major, Minor, Micro;
6157 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6158 bool useLibgcc = true;
6159 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
6160 if (getToolChain().getArch() == llvm::Triple::x86 ||
6161 getToolChain().getArch() == llvm::Triple::x86_64)
6162 useLibgcc = false;
6163 }
6164
6165 if (!Args.hasArg(options::OPT_nostdlib) &&
6166 !Args.hasArg(options::OPT_nodefaultlibs)) {
6167 if (D.CCCIsCXX()) {
6168 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6169 CmdArgs.push_back("-lm");
6170 }
6171 if (Args.hasArg(options::OPT_pthread))
6172 CmdArgs.push_back("-lpthread");
6173 CmdArgs.push_back("-lc");
6174
6175 if (useLibgcc) {
6176 if (Args.hasArg(options::OPT_static)) {
6177 // libgcc_eh depends on libc, so resolve as much as possible,
6178 // pull in any new requirements from libc and then get the rest
6179 // of libgcc.
6180 CmdArgs.push_back("-lgcc_eh");
6181 CmdArgs.push_back("-lc");
6182 CmdArgs.push_back("-lgcc");
6183 } else {
6184 CmdArgs.push_back("-lgcc");
6185 CmdArgs.push_back("--as-needed");
6186 CmdArgs.push_back("-lgcc_s");
6187 CmdArgs.push_back("--no-as-needed");
6188 }
6189 }
6190 }
6191
6192 if (!Args.hasArg(options::OPT_nostdlib) &&
6193 !Args.hasArg(options::OPT_nostartfiles)) {
6194 if (!Args.hasArg(options::OPT_shared))
6195 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6196 "crtend.o")));
6197 else
6198 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6199 "crtendS.o")));
6200 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6201 "crtn.o")));
6202 }
6203
6204 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6205
6206 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6207 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6208}
6209
6210void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6211 const InputInfo &Output,
6212 const InputInfoList &Inputs,
6213 const ArgList &Args,
6214 const char *LinkingOutput) const {
6215 ArgStringList CmdArgs;
6216 bool NeedsKPIC = false;
6217
6218 // Add --32/--64 to make sure we get the format we want.
6219 // This is incomplete
6220 if (getToolChain().getArch() == llvm::Triple::x86) {
6221 CmdArgs.push_back("--32");
6222 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6223 CmdArgs.push_back("--64");
6224 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6225 CmdArgs.push_back("-a32");
6226 CmdArgs.push_back("-mppc");
6227 CmdArgs.push_back("-many");
6228 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6229 CmdArgs.push_back("-a64");
6230 CmdArgs.push_back("-mppc64");
6231 CmdArgs.push_back("-many");
6232 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6233 CmdArgs.push_back("-a64");
6234 CmdArgs.push_back("-mppc64le");
6235 CmdArgs.push_back("-many");
6236 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6237 CmdArgs.push_back("-32");
6238 CmdArgs.push_back("-Av8plusa");
6239 NeedsKPIC = true;
6240 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6241 CmdArgs.push_back("-64");
6242 CmdArgs.push_back("-Av9a");
6243 NeedsKPIC = true;
6244 } else if (getToolChain().getArch() == llvm::Triple::arm) {
6245 StringRef MArch = getToolChain().getArchName();
6246 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6247 CmdArgs.push_back("-mfpu=neon");
6248 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6249 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
6250
6251 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
6252 getToolChain().getTriple());
6253 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6254
6255 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6256 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6257 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6258 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6259 getToolChain().getArch() == llvm::Triple::mipsel ||
6260 getToolChain().getArch() == llvm::Triple::mips64 ||
6261 getToolChain().getArch() == llvm::Triple::mips64el) {
6262 StringRef CPUName;
6263 StringRef ABIName;
6264 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6265
6266 CmdArgs.push_back("-march");
6267 CmdArgs.push_back(CPUName.data());
6268
6269 CmdArgs.push_back("-mabi");
6270 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6271
6272 if (getToolChain().getArch() == llvm::Triple::mips ||
6273 getToolChain().getArch() == llvm::Triple::mips64)
6274 CmdArgs.push_back("-EB");
6275 else
6276 CmdArgs.push_back("-EL");
6277
6278 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6279 if (StringRef(A->getValue()) == "2008")
6280 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6281 }
6282
6283 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) {
6284 if (A->getOption().matches(options::OPT_mfp32))
6285 CmdArgs.push_back(Args.MakeArgString("-mfp32"));
6286 else
6287 CmdArgs.push_back(Args.MakeArgString("-mfp64"));
6288 }
6289
6290 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6291 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6292 options::OPT_mno_micromips);
6293 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6294 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6295
6296 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6297 // Do not use AddLastArg because not all versions of MIPS assembler
6298 // support -mmsa / -mno-msa options.
6299 if (A->getOption().matches(options::OPT_mmsa))
6300 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6301 }
6302
6303 NeedsKPIC = true;
6304 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6305 // Always pass an -march option, since our default of z10 is later
6306 // than the GNU assembler's default.
6307 StringRef CPUName = getSystemZTargetCPU(Args);
6308 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6309 }
6310
6311 if (NeedsKPIC) {
6312 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6313 options::OPT_fpic, options::OPT_fno_pic,
6314 options::OPT_fPIE, options::OPT_fno_PIE,
6315 options::OPT_fpie, options::OPT_fno_pie);
6316 if (LastPICArg &&
6317 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6318 LastPICArg->getOption().matches(options::OPT_fpic) ||
6319 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6320 LastPICArg->getOption().matches(options::OPT_fpie))) {
6321 CmdArgs.push_back("-KPIC");
6322 }
6323 }
6324
6325 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6326 options::OPT_Xassembler);
6327
6328 CmdArgs.push_back("-o");
6329 CmdArgs.push_back(Output.getFilename());
6330
6331 for (InputInfoList::const_iterator
6332 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6333 const InputInfo &II = *it;
6334 CmdArgs.push_back(II.getFilename());
6335 }
6336
6337 const char *Exec =
6338 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6339 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6340
6341 // Handle the debug info splitting at object creation time if we're
6342 // creating an object.
6343 // TODO: Currently only works on linux with newer objcopy.
6344 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6345 getToolChain().getTriple().isOSLinux())
6346 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6347 SplitDebugName(Args, Inputs));
6348}
6349
6350static void AddLibgcc(llvm::Triple Triple, const Driver &D,
6351 ArgStringList &CmdArgs, const ArgList &Args) {
6352 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
6353 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6354 Args.hasArg(options::OPT_static);
6355 if (!D.CCCIsCXX())
6356 CmdArgs.push_back("-lgcc");
6357
6358 if (StaticLibgcc || isAndroid) {
6359 if (D.CCCIsCXX())
6360 CmdArgs.push_back("-lgcc");
6361 } else {
6362 if (!D.CCCIsCXX())
6363 CmdArgs.push_back("--as-needed");
6364 CmdArgs.push_back("-lgcc_s");
6365 if (!D.CCCIsCXX())
6366 CmdArgs.push_back("--no-as-needed");
6367 }
6368
6369 if (StaticLibgcc && !isAndroid)
6370 CmdArgs.push_back("-lgcc_eh");
6371 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
6372 CmdArgs.push_back("-lgcc");
6373
6374 // According to Android ABI, we have to link with libdl if we are
6375 // linking with non-static libgcc.
6376 //
6377 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6378 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6379 if (isAndroid && !StaticLibgcc)
6380 CmdArgs.push_back("-ldl");
6381}
6382
6383static bool hasMipsN32ABIArg(const ArgList &Args) {
6384 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6385 return A && (A->getValue() == StringRef("n32"));
6386}
6387
6388static StringRef getLinuxDynamicLinker(const ArgList &Args,
6389 const toolchains::Linux &ToolChain) {
6390 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6391 return "/system/bin/linker";
6392 else if (ToolChain.getArch() == llvm::Triple::x86 ||
6393 ToolChain.getArch() == llvm::Triple::sparc)
6394 return "/lib/ld-linux.so.2";
6395 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6396 return "/lib/ld-linux-aarch64.so.1";
6397 else if (ToolChain.getArch() == llvm::Triple::arm ||
6398 ToolChain.getArch() == llvm::Triple::thumb) {
6399 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6400 return "/lib/ld-linux-armhf.so.3";
6401 else
6402 return "/lib/ld-linux.so.3";
6403 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6404 ToolChain.getArch() == llvm::Triple::mipsel)
6405 return "/lib/ld.so.1";
6406 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6407 ToolChain.getArch() == llvm::Triple::mips64el) {
6408 if (hasMipsN32ABIArg(Args))
6409 return "/lib32/ld.so.1";
6410 else
6411 return "/lib64/ld.so.1";
6412 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6413 return "/lib/ld.so.1";
6414 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6415 ToolChain.getArch() == llvm::Triple::ppc64le ||
6416 ToolChain.getArch() == llvm::Triple::systemz)
6417 return "/lib64/ld64.so.1";
6418 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6419 return "/lib64/ld-linux.so.2";
6420 else
6421 return "/lib64/ld-linux-x86-64.so.2";
6422}
6423
6424void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6425 const InputInfo &Output,
6426 const InputInfoList &Inputs,
6427 const ArgList &Args,
6428 const char *LinkingOutput) const {
6429 const toolchains::Linux& ToolChain =
6430 static_cast<const toolchains::Linux&>(getToolChain());
6431 const Driver &D = ToolChain.getDriver();
6432 const bool isAndroid =
6433 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
6434 const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
6435 const bool IsPIE =
6436 !Args.hasArg(options::OPT_shared) &&
6437 (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
6438
6439 ArgStringList CmdArgs;
6440
6441 // Silence warning for "clang -g foo.o -o foo"
6442 Args.ClaimAllArgs(options::OPT_g_Group);
6443 // and "clang -emit-llvm foo.o -o foo"
6444 Args.ClaimAllArgs(options::OPT_emit_llvm);
6445 // and for "clang -w foo.o -o foo". Other warning options are already
6446 // handled somewhere else.
6447 Args.ClaimAllArgs(options::OPT_w);
6448
6449 if (!D.SysRoot.empty())
6450 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6451
6452 if (IsPIE)
6453 CmdArgs.push_back("-pie");
6454
6455 if (Args.hasArg(options::OPT_rdynamic))
6456 CmdArgs.push_back("-export-dynamic");
6457
6458 if (Args.hasArg(options::OPT_s))
6459 CmdArgs.push_back("-s");
6460
6461 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6462 e = ToolChain.ExtraOpts.end();
6463 i != e; ++i)
6464 CmdArgs.push_back(i->c_str());
6465
6466 if (!Args.hasArg(options::OPT_static)) {
6467 CmdArgs.push_back("--eh-frame-hdr");
6468 }
6469
6470 CmdArgs.push_back("-m");
6471 if (ToolChain.getArch() == llvm::Triple::x86)
6472 CmdArgs.push_back("elf_i386");
6473 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6474 CmdArgs.push_back("aarch64linux");
6475 else if (ToolChain.getArch() == llvm::Triple::arm
6476 || ToolChain.getArch() == llvm::Triple::thumb)
6477 CmdArgs.push_back("armelf_linux_eabi");
6478 else if (ToolChain.getArch() == llvm::Triple::ppc)
6479 CmdArgs.push_back("elf32ppclinux");
6480 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6481 CmdArgs.push_back("elf64ppc");
6482 else if (ToolChain.getArch() == llvm::Triple::sparc)
6483 CmdArgs.push_back("elf32_sparc");
6484 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6485 CmdArgs.push_back("elf64_sparc");
6486 else if (ToolChain.getArch() == llvm::Triple::mips)
6487 CmdArgs.push_back("elf32btsmip");
6488 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6489 CmdArgs.push_back("elf32ltsmip");
6490 else if (ToolChain.getArch() == llvm::Triple::mips64) {
6491 if (hasMipsN32ABIArg(Args))
6492 CmdArgs.push_back("elf32btsmipn32");
6493 else
6494 CmdArgs.push_back("elf64btsmip");
6495 }
6496 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6497 if (hasMipsN32ABIArg(Args))
6498 CmdArgs.push_back("elf32ltsmipn32");
6499 else
6500 CmdArgs.push_back("elf64ltsmip");
6501 }
6502 else if (ToolChain.getArch() == llvm::Triple::systemz)
6503 CmdArgs.push_back("elf64_s390");
6504 else
6505 CmdArgs.push_back("elf_x86_64");
6506
6507 if (Args.hasArg(options::OPT_static)) {
6508 if (ToolChain.getArch() == llvm::Triple::arm
6509 || ToolChain.getArch() == llvm::Triple::thumb)
6510 CmdArgs.push_back("-Bstatic");
6511 else
6512 CmdArgs.push_back("-static");
6513 } else if (Args.hasArg(options::OPT_shared)) {
6514 CmdArgs.push_back("-shared");
6515 if (isAndroid) {
6516 CmdArgs.push_back("-Bsymbolic");
6517 }
6518 }
6519
6520 if (ToolChain.getArch() == llvm::Triple::arm ||
6521 ToolChain.getArch() == llvm::Triple::thumb ||
6522 (!Args.hasArg(options::OPT_static) &&
6523 !Args.hasArg(options::OPT_shared))) {
6524 CmdArgs.push_back("-dynamic-linker");
6525 CmdArgs.push_back(Args.MakeArgString(
6526 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
6527 }
6528
6529 CmdArgs.push_back("-o");
6530 CmdArgs.push_back(Output.getFilename());
6531
6532 if (!Args.hasArg(options::OPT_nostdlib) &&
6533 !Args.hasArg(options::OPT_nostartfiles)) {
6534 if (!isAndroid) {
6535 const char *crt1 = NULL;
6536 if (!Args.hasArg(options::OPT_shared)){
6537 if (Args.hasArg(options::OPT_pg))
6538 crt1 = "gcrt1.o";
6539 else if (IsPIE)
6540 crt1 = "Scrt1.o";
6541 else
6542 crt1 = "crt1.o";
6543 }
6544 if (crt1)
6545 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6546
6547 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6548 }
6549
6550 const char *crtbegin;
6551 if (Args.hasArg(options::OPT_static))
6552 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
6553 else if (Args.hasArg(options::OPT_shared))
6554 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
6555 else if (IsPIE)
6556 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
6557 else
6558 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
6559 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6560
6561 // Add crtfastmath.o if available and fast math is enabled.
6562 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
6563 }
6564
6565 Args.AddAllArgs(CmdArgs, options::OPT_L);
6566
6567 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6568
6569 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6570 i != e; ++i)
6571 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
6572
6573 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6574 // as gold requires -plugin to come before any -plugin-opt that -Wl might
6575 // forward.
6576 if (D.IsUsingLTO(Args)) {
6577 CmdArgs.push_back("-plugin");
6578 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6579 CmdArgs.push_back(Args.MakeArgString(Plugin));
6580
6581 // Try to pass driver level flags relevant to LTO code generation down to
6582 // the plugin.
6583
6584 // Handle flags for selecting CPU variants.
6585 std::string CPU = getCPUName(Args, ToolChain.getTriple());
6586 if (!CPU.empty()) {
6587 CmdArgs.push_back(
6588 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6589 CPU));
6590 }
6591 }
6592
6593
6594 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6595 CmdArgs.push_back("--no-demangle");
6596
6597 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6598
6599 // Call these before we add the C++ ABI library.
6600 if (Sanitize.needsUbsanRt())
6601 addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
6602 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
6603 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
6604 if (Sanitize.needsAsanRt())
6605 addAsanRTLinux(getToolChain(), Args, CmdArgs);
6606 if (Sanitize.needsTsanRt())
6607 addTsanRTLinux(getToolChain(), Args, CmdArgs);
6608 if (Sanitize.needsMsanRt())
6609 addMsanRTLinux(getToolChain(), Args, CmdArgs);
6610 if (Sanitize.needsLsanRt())
6611 addLsanRTLinux(getToolChain(), Args, CmdArgs);
6612 if (Sanitize.needsDfsanRt())
6613 addDfsanRTLinux(getToolChain(), Args, CmdArgs);
6614
6615 // The profile runtime also needs access to system libraries.
6616 addProfileRTLinux(getToolChain(), Args, CmdArgs);
6617
6618 if (D.CCCIsCXX() &&
6619 !Args.hasArg(options::OPT_nostdlib) &&
6620 !Args.hasArg(options::OPT_nodefaultlibs)) {
6621 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6622 !Args.hasArg(options::OPT_static);
6623 if (OnlyLibstdcxxStatic)
6624 CmdArgs.push_back("-Bstatic");
6625 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6626 if (OnlyLibstdcxxStatic)
6627 CmdArgs.push_back("-Bdynamic");
6628 CmdArgs.push_back("-lm");
6629 }
6630
6631 if (!Args.hasArg(options::OPT_nostdlib)) {
6632 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6633 if (Args.hasArg(options::OPT_static))
6634 CmdArgs.push_back("--start-group");
6635
6636 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6637 if (OpenMP) {
6638 CmdArgs.push_back("-lgomp");
6639
6640 // FIXME: Exclude this for platforms whith libgomp that doesn't require
6641 // librt. Most modern Linux platfroms require it, but some may not.
6642 CmdArgs.push_back("-lrt");
6643 }
6644
6645 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6646
6647 if (Args.hasArg(options::OPT_pthread) ||
6648 Args.hasArg(options::OPT_pthreads) || OpenMP)
6649 CmdArgs.push_back("-lpthread");
6650
6651 CmdArgs.push_back("-lc");
6652
6653 if (Args.hasArg(options::OPT_static))
6654 CmdArgs.push_back("--end-group");
6655 else
6656 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6657 }
6658
6659 if (!Args.hasArg(options::OPT_nostartfiles)) {
6660 const char *crtend;
6661 if (Args.hasArg(options::OPT_shared))
6662 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
6663 else if (IsPIE)
6664 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
6665 else
6666 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
6667
6668 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
6669 if (!isAndroid)
6670 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6671 }
6672 }
6673
6674 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6675}
6676
6677void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6678 const InputInfo &Output,
6679 const InputInfoList &Inputs,
6680 const ArgList &Args,
6681 const char *LinkingOutput) const {
6682 ArgStringList CmdArgs;
6683
6684 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6685 options::OPT_Xassembler);
6686
6687 CmdArgs.push_back("-o");
6688 CmdArgs.push_back(Output.getFilename());
6689
6690 for (InputInfoList::const_iterator
6691 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6692 const InputInfo &II = *it;
6693 CmdArgs.push_back(II.getFilename());
6694 }
6695
6696 const char *Exec =
6697 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6698 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6699}
6700
6701void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
6702 const InputInfo &Output,
6703 const InputInfoList &Inputs,
6704 const ArgList &Args,
6705 const char *LinkingOutput) const {
6706 const Driver &D = getToolChain().getDriver();
6707 ArgStringList CmdArgs;
6708
6709 if (Output.isFilename()) {
6710 CmdArgs.push_back("-o");
6711 CmdArgs.push_back(Output.getFilename());
6712 } else {
6713 assert(Output.isNothing() && "Invalid output.");
6714 }
6715
6716 if (!Args.hasArg(options::OPT_nostdlib) &&
6717 !Args.hasArg(options::OPT_nostartfiles)) {
6718 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6719 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6720 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6722 }
6723
6724 Args.AddAllArgs(CmdArgs, options::OPT_L);
6725 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6726 Args.AddAllArgs(CmdArgs, options::OPT_e);
6727
6728 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6729
6730 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6731
6732 if (!Args.hasArg(options::OPT_nostdlib) &&
6733 !Args.hasArg(options::OPT_nodefaultlibs)) {
6734 if (D.CCCIsCXX()) {
6735 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6736 CmdArgs.push_back("-lm");
6737 }
6738 }
6739
6740 if (!Args.hasArg(options::OPT_nostdlib) &&
6741 !Args.hasArg(options::OPT_nostartfiles)) {
6742 if (Args.hasArg(options::OPT_pthread))
6743 CmdArgs.push_back("-lpthread");
6744 CmdArgs.push_back("-lc");
6745 CmdArgs.push_back("-lCompilerRT-Generic");
6746 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6747 CmdArgs.push_back(
6748 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6749 }
6750
6751 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6752 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6753}
6754
6755/// DragonFly Tools
6756
6757// For now, DragonFly Assemble does just about the same as for
6758// FreeBSD, but this may change soon.
6759void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6760 const InputInfo &Output,
6761 const InputInfoList &Inputs,
6762 const ArgList &Args,
6763 const char *LinkingOutput) const {
6764 ArgStringList CmdArgs;
6765
6766 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6767 // instruct as in the base system to assemble 32-bit code.
6768 if (getToolChain().getArch() == llvm::Triple::x86)
6769 CmdArgs.push_back("--32");
6770
6771 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6772 options::OPT_Xassembler);
6773
6774 CmdArgs.push_back("-o");
6775 CmdArgs.push_back(Output.getFilename());
6776
6777 for (InputInfoList::const_iterator
6778 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6779 const InputInfo &II = *it;
6780 CmdArgs.push_back(II.getFilename());
6781 }
6782
6783 const char *Exec =
6784 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6785 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6786}
6787
6788void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6789 const InputInfo &Output,
6790 const InputInfoList &Inputs,
6791 const ArgList &Args,
6792 const char *LinkingOutput) const {
6793 bool UseGCC47 = false;
6794 const Driver &D = getToolChain().getDriver();
6795 ArgStringList CmdArgs;
6796
6797 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6798 UseGCC47 = false;
6799
6800 if (!D.SysRoot.empty())
6801 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6802
6803 CmdArgs.push_back("--eh-frame-hdr");
6804 if (Args.hasArg(options::OPT_static)) {
6805 CmdArgs.push_back("-Bstatic");
6806 } else {
6807 if (Args.hasArg(options::OPT_rdynamic))
6808 CmdArgs.push_back("-export-dynamic");
6809 if (Args.hasArg(options::OPT_shared))
6810 CmdArgs.push_back("-Bshareable");
6811 else {
6812 CmdArgs.push_back("-dynamic-linker");
6813 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6814 }
6815 CmdArgs.push_back("--hash-style=both");
6816 }
6817
6818 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6819 // instruct ld in the base system to link 32-bit code.
6820 if (getToolChain().getArch() == llvm::Triple::x86) {
6821 CmdArgs.push_back("-m");
6822 CmdArgs.push_back("elf_i386");
6823 }
6824
6825 if (Output.isFilename()) {
6826 CmdArgs.push_back("-o");
6827 CmdArgs.push_back(Output.getFilename());
6828 } else {
6829 assert(Output.isNothing() && "Invalid output.");
6830 }
6831
6832 if (!Args.hasArg(options::OPT_nostdlib) &&
6833 !Args.hasArg(options::OPT_nostartfiles)) {
6834 if (!Args.hasArg(options::OPT_shared)) {
6835 if (Args.hasArg(options::OPT_pg))
6836 CmdArgs.push_back(Args.MakeArgString(
6837 getToolChain().GetFilePath("gcrt1.o")));
6838 else {
6839 if (Args.hasArg(options::OPT_pie))
6840 CmdArgs.push_back(Args.MakeArgString(
6841 getToolChain().GetFilePath("Scrt1.o")));
6842 else
6843 CmdArgs.push_back(Args.MakeArgString(
6844 getToolChain().GetFilePath("crt1.o")));
6845 }
6846 }
6847 CmdArgs.push_back(Args.MakeArgString(
6848 getToolChain().GetFilePath("crti.o")));
6849 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6850 CmdArgs.push_back(Args.MakeArgString(
6851 getToolChain().GetFilePath("crtbeginS.o")));
6852 else
6853 CmdArgs.push_back(Args.MakeArgString(
6854 getToolChain().GetFilePath("crtbegin.o")));
6855 }
6856
6857 Args.AddAllArgs(CmdArgs, options::OPT_L);
6858 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6859 Args.AddAllArgs(CmdArgs, options::OPT_e);
6860
6861 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6862
6863 if (!Args.hasArg(options::OPT_nostdlib) &&
6864 !Args.hasArg(options::OPT_nodefaultlibs)) {
6865 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6866 // rpaths
6867 if (UseGCC47)
6868 CmdArgs.push_back("-L/usr/lib/gcc47");
6869 else
6870 CmdArgs.push_back("-L/usr/lib/gcc44");
6871
6872 if (!Args.hasArg(options::OPT_static)) {
6873 if (UseGCC47) {
6874 CmdArgs.push_back("-rpath");
6875 CmdArgs.push_back("/usr/lib/gcc47");
6876 } else {
6877 CmdArgs.push_back("-rpath");
6878 CmdArgs.push_back("/usr/lib/gcc44");
6879 }
6880 }
6881
6882 if (D.CCCIsCXX()) {
6883 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6884 CmdArgs.push_back("-lm");
6885 }
6886
6887 if (Args.hasArg(options::OPT_pthread))
6888 CmdArgs.push_back("-lpthread");
6889
6890 if (!Args.hasArg(options::OPT_nolibc)) {
6891 CmdArgs.push_back("-lc");
6892 }
6893
6894 if (UseGCC47) {
6895 if (Args.hasArg(options::OPT_static) ||
6896 Args.hasArg(options::OPT_static_libgcc)) {
6897 CmdArgs.push_back("-lgcc");
6898 CmdArgs.push_back("-lgcc_eh");
6899 } else {
6900 if (Args.hasArg(options::OPT_shared_libgcc)) {
6901 CmdArgs.push_back("-lgcc_pic");
6902 if (!Args.hasArg(options::OPT_shared))
6903 CmdArgs.push_back("-lgcc");
6904 } else {
6905 CmdArgs.push_back("-lgcc");
6906 CmdArgs.push_back("--as-needed");
6907 CmdArgs.push_back("-lgcc_pic");
6908 CmdArgs.push_back("--no-as-needed");
6909 }
6910 }
6911 } else {
6912 if (Args.hasArg(options::OPT_shared)) {
6913 CmdArgs.push_back("-lgcc_pic");
6914 } else {
6915 CmdArgs.push_back("-lgcc");
6916 }
6917 }
6918 }
6919
6920 if (!Args.hasArg(options::OPT_nostdlib) &&
6921 !Args.hasArg(options::OPT_nostartfiles)) {
6922 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6923 CmdArgs.push_back(Args.MakeArgString(
6924 getToolChain().GetFilePath("crtendS.o")));
6925 else
6926 CmdArgs.push_back(Args.MakeArgString(
6927 getToolChain().GetFilePath("crtend.o")));
6928 CmdArgs.push_back(Args.MakeArgString(
6929 getToolChain().GetFilePath("crtn.o")));
6930 }
6931
6932 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6933
6934 const char *Exec =
6935 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6936 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6937}
6938
6939void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6940 const InputInfo &Output,
6941 const InputInfoList &Inputs,
6942 const ArgList &Args,
6943 const char *LinkingOutput) const {
6944 ArgStringList CmdArgs;
6945
6946 if (Output.isFilename()) {
6947 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6948 Output.getFilename()));
6949 } else {
6950 assert(Output.isNothing() && "Invalid output.");
6951 }
6952
6953 if (!Args.hasArg(options::OPT_nostdlib) &&
6954 !Args.hasArg(options::OPT_nostartfiles) &&
6955 !C.getDriver().IsCLMode()) {
6956 CmdArgs.push_back("-defaultlib:libcmt");
6957 }
6958
6959 CmdArgs.push_back("-nologo");
6960
6961 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6962
6963 if (DLL) {
6964 CmdArgs.push_back(Args.MakeArgString("-dll"));
6965
6966 SmallString<128> ImplibName(Output.getFilename());
6967 llvm::sys::path::replace_extension(ImplibName, "lib");
6968 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6969 ImplibName.str()));
6970 }
6971
6972 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
6973 CmdArgs.push_back(Args.MakeArgString("-debug"));
6974 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
6975 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
6976 llvm::sys::path::append(LibSanitizer, "lib", "windows");
6977 if (DLL) {
6978 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
6979 } else {
6980 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6981 }
6982 // FIXME: Handle 64-bit.
6983 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6984 }
6985
6986 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6987 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
6988
6989 // Add filenames immediately.
6990 for (InputInfoList::const_iterator
6991 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6992 if (it->isFilename())
6993 CmdArgs.push_back(it->getFilename());
6994 else
6995 it->getInputArg().renderAsInput(Args, CmdArgs);
6996 }
6997
6998 const char *Exec =
6999 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
7000 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7001}
7002
7003void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7004 const InputInfo &Output,
7005 const InputInfoList &Inputs,
7006 const ArgList &Args,
7007 const char *LinkingOutput) const {
7008 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7009}
7010
7011// Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7012// If one cannot be found, return FallbackName.
7013// We do this special search to prevent clang-cl from falling back onto itself
7014// if it's available as cl.exe on the path.
7015static std::string FindFallback(const char *FallbackName,
7016 const char *ClangProgramPath) {
7017 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7018 if (!OptPath.hasValue())
7019 return FallbackName;
7020
7021#ifdef LLVM_ON_WIN32
7022 const StringRef PathSeparators = ";";
7023#else
7024 const StringRef PathSeparators = ":";
7025#endif
7026
7027 SmallVector<StringRef, 8> PathSegments;
7028 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7029
7030 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7031 const StringRef &PathSegment = PathSegments[i];
7032 if (PathSegment.empty())
7033 continue;
7034
7035 SmallString<128> FilePath(PathSegment);
7036 llvm::sys::path::append(FilePath, FallbackName);
7037 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7038 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7039 return FilePath.str();
7040 }
7041
7042 return FallbackName;
7043}
7044
7045Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7046 const InputInfo &Output,
7047 const InputInfoList &Inputs,
7048 const ArgList &Args,
7049 const char *LinkingOutput) const {
7050 ArgStringList CmdArgs;
7051 CmdArgs.push_back("/nologo");
7052 CmdArgs.push_back("/c"); // Compile only.
7053 CmdArgs.push_back("/W0"); // No warnings.
7054
7055 // The goal is to be able to invoke this tool correctly based on
7056 // any flag accepted by clang-cl.
7057
7058 // These are spelled the same way in clang and cl.exe,.
7059 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7060 Args.AddAllArgs(CmdArgs, options::OPT_I);
7061
7062 // Optimization level.
7063 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7064 if (A->getOption().getID() == options::OPT_O0) {
7065 CmdArgs.push_back("/Od");
7066 } else {
7067 StringRef OptLevel = A->getValue();
7068 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7069 A->render(Args, CmdArgs);
7070 else if (OptLevel == "3")
7071 CmdArgs.push_back("/Ox");
7072 }
7073 }
7074
7075 // Flags for which clang-cl have an alias.
7076 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7077
7078 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7079 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7080 : "/GR-");
7081 if (Args.hasArg(options::OPT_fsyntax_only))
7082 CmdArgs.push_back("/Zs");
7083
7084 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7085 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7086 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7087
7088 // Flags that can simply be passed through.
7089 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7090 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7091
7092 // The order of these flags is relevant, so pick the last one.
7093 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7094 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7095 A->render(Args, CmdArgs);
7096
7097
7098 // Input filename.
7099 assert(Inputs.size() == 1);
7100 const InputInfo &II = Inputs[0];
7101 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7102 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7103 if (II.isFilename())
7104 CmdArgs.push_back(II.getFilename());
7105 else
7106 II.getInputArg().renderAsInput(Args, CmdArgs);
7107
7108 // Output filename.
7109 assert(Output.getType() == types::TY_Object);
7110 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7111 Output.getFilename());
7112 CmdArgs.push_back(Fo);
7113
7114 const Driver &D = getToolChain().getDriver();
7115 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
7116
7117 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7118}
7119
7120
7121/// XCore Tools
7122// We pass assemble and link construction to the xcc tool.
7123
7124void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7125 const InputInfo &Output,
7126 const InputInfoList &Inputs,
7127 const ArgList &Args,
7128 const char *LinkingOutput) const {
7129 ArgStringList CmdArgs;
7130
7131 CmdArgs.push_back("-o");
7132 CmdArgs.push_back(Output.getFilename());
7133
7134 CmdArgs.push_back("-c");
7135
7136 if (Args.hasArg(options::OPT_g_Group)) {
7137 CmdArgs.push_back("-g");
7138 }
7139
7140 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7141 options::OPT_Xassembler);
7142
7143 for (InputInfoList::const_iterator
7144 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7145 const InputInfo &II = *it;
7146 CmdArgs.push_back(II.getFilename());
7147 }
7148
7149 const char *Exec =
7150 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7151 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7152}
7153
7154void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7155 const InputInfo &Output,
7156 const InputInfoList &Inputs,
7157 const ArgList &Args,
7158 const char *LinkingOutput) const {
7159 ArgStringList CmdArgs;
7160
7161 if (Output.isFilename()) {
7162 CmdArgs.push_back("-o");
7163 CmdArgs.push_back(Output.getFilename());
7164 } else {
7165 assert(Output.isNothing() && "Invalid output.");
7166 }
7167
7168 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7169
7170 const char *Exec =
7171 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7172 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7173}
|